@trydecember/cli 0.4.2 → 0.4.4

package/dist/december.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@trydecember/cli",
-    version: "0.4.2",
+    version: "0.4.4",
     description: "a coding agent for terminal and cloud.",
     homepage: "https://trydecember.com",
     repository: {
@@ -11072,10 +11072,13 @@ async function providerFetch(url, init) {
   if (!res.ok) {
     const text = await res.text();
     const normalized = normalizeErrorResponse(text);
+    const headers = new Headers(res.headers);
+    headers.delete("retry-after");
+    headers.delete("retry-after-ms");
     return new Response(normalized, {
       status: res.status,
       statusText: res.statusText,
-      headers: res.headers
+      headers
     });
   }
   return res;
@@ -11085,7 +11088,8 @@ function openaiProvider(baseURL, apiKey, defaultHeaders, customClient) {
     baseURL,
     apiKey: apiKey || process.env.OPENAI_API_KEY || "dummy-key",
     defaultHeaders,
-    fetch: providerFetch
+    fetch: providerFetch,
+    maxRetries: 0
   });
   return createProvider({
     id: "openai",
@@ -11184,6 +11188,11 @@ function openaiProvider(baseURL, apiKey, defaultHeaders, customClient) {
     }
     const activeToolCalls = new Map;
     for await (const chunk of stream) {
+      if (chunk.error) {
+        const errObj = chunk.error;
+        const msg = typeof errObj === "string" ? errObj : errObj.message || JSON.stringify(errObj);
+        throw new Error(msg);
+      }
       if (chunk.usage) {
         const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens;
         yield {
@@ -64374,6 +64383,7 @@ function parseIgnoreLines(content) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
       continue;
+    const isRootAnchored = trimmed.startsWith("/");
     let clean = trimmed;
     if (clean.startsWith("/")) {
       clean = clean.slice(1);
@@ -64386,7 +64396,7 @@ function parseIgnoreLines(content) {
       if (!clean.endsWith("/**")) {
         patterns.push(`${clean}/**`);
       }
-      if (!clean.startsWith("**/")) {
+      if (!isRootAnchored && !clean.startsWith("**/")) {
         patterns.push(`**/${clean}`);
         patterns.push(`**/${clean}/**`);
       }
@@ -66471,15 +66481,23 @@ function anthropicProvider(baseURL, apiKey, customClientOrDefaultHeaders, custom
           antMessages.push({ role: "assistant", content });
         }
       } else {
-        antMessages.push({
-          role: msg.role,
-          content: [
-            {
-              type: "text",
-              text: msg.content
-            }
-          ]
-        });
+        const prev = antMessages[antMessages.length - 1];
+        if (prev && prev.role === "user" && Array.isArray(prev.content)) {
+          prev.content.push({
+            type: "text",
+            text: msg.content
+          });
+        } else {
+          antMessages.push({
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: msg.content
+              }
+            ]
+          });
+        }
       }
     }
     if (antMessages.length >= 4) {
@@ -109443,6 +109461,14 @@ var LIVE_MODEL_CACHE_TTL_MS, liveModelCache, diskCacheLoaded = false, getCurated
     case "aurikoai":
     case "auriko-ai":
       return [
+        {
+          label: "DeepSeek V4 Flash",
+          value: "deepseek-v4-flash"
+        },
+        {
+          label: "Gemini 2.5 Flash",
+          value: "gemini-2.5-flash"
+        },
         {
           label: "Claude Sonnet 4.6",
           value: "claude-sonnet-4-6"
@@ -109455,18 +109481,10 @@ var LIVE_MODEL_CACHE_TTL_MS, liveModelCache, diskCacheLoaded = false, getCurated
           label: "Claude Opus 4.7",
           value: "claude-opus-4-7"
         },
-        {
-          label: "DeepSeek V4 Flash",
-          value: "deepseek-v4-flash"
-        },
         {
           label: "DeepSeek V4 Pro",
           value: "deepseek-v4-pro"
         },
-        {
-          label: "Gemini 2.5 Flash",
-          value: "gemini-2.5-flash"
-        },
         {
           label: "Gemini 2.5 Pro",
           value: "gemini-2.5-pro"
@@ -111283,9 +111301,15 @@ var LIVE_MODEL_CACHE_TTL_MS, liveModelCache, diskCacheLoaded = false, getCurated
   if (normalized === "anyapi") {
     return "anthropic/claude-sonnet-4-6";
   }
+  if (normalized === "auriko" || normalized === "aurikoai" || normalized === "auriko-ai") {
+    return "deepseek-v4-flash";
+  }
   if (normalized === "bailing") {
     return "Ling-1T";
   }
+  if (normalized === "baseten" || normalized === "basetenco" || normalized === "baseten-co") {
+    return "deepseek-ai/DeepSeek-V4.1-Flash";
+  }
   if (normalized === "berget") {
     return "mistralai/Mistral-Small-3.2-24B-Instruct-2506";
   }
@@ -119420,6 +119444,190 @@ var init_browser = __esm(() => {
   };
 });
 
+// ../../packages/tools/src/code_intelligence.ts
+function formatDiagnostics(diags, path) {
+  const target = path ? ` for ${path}` : "";
+  if (!diags) {
+    return `No diagnostic errors found${target}.`;
+  }
+  if (typeof diags === "string") {
+    const trimmed = diags.trim();
+    if (!trimmed) {
+      return `No diagnostic errors found${target}.`;
+    }
+    return `Diagnostic errors found${target}:
+${trimmed}`;
+  }
+  if (Array.isArray(diags)) {
+    if (diags.length === 0) {
+      return `No diagnostic errors found${target}.`;
+    }
+    const formatted = diags.map((d) => {
+      const loc = d.line ? `:${d.line}${d.column ? `:${d.column}` : ""}` : "";
+      return `${d.filePath}${loc} - [${d.severity ?? "error"}] ${d.message}${d.source ? ` (${d.source})` : ""}`;
+    }).join(`
+`);
+    return `Diagnostic errors found${target}:
+${formatted}`;
+  }
+  return `No diagnostic errors found${target}.`;
+}
+var codeIntelligenceSchema, CodeIntelligenceTool;
+var init_code_intelligence = __esm(() => {
+  init_esm2();
+  codeIntelligenceSchema = Type2.Object({
+    action: Type2.Union([
+      Type2.Literal("diagnostics"),
+      Type2.Literal("definition"),
+      Type2.Literal("references"),
+      Type2.Literal("outline")
+    ], {
+      description: 'The code intelligence action to perform: "diagnostics", "definition", "references", or "outline".'
+    }),
+    path: Type2.Optional(Type2.String({
+      description: 'Relative or absolute file path or directory to query. Required for "definition", "references", and "outline".'
+    })),
+    line: Type2.Optional(Type2.Integer({
+      description: "1-indexed line number of the symbol for definition or references lookup."
+    })),
+    column: Type2.Optional(Type2.Integer({
+      description: "1-indexed column number of the symbol for definition or references lookup."
+    })),
+    symbol: Type2.Optional(Type2.String({
+      description: "Optional symbol name to search for in the file if line and column are not specified."
+    }))
+  });
+  CodeIntelligenceTool = {
+    name: "code_intelligence",
+    description: "Query on-demand code intelligence, symbol definitions, call site references, document outline, and compiler diagnostics across the workspace or for a specific file.",
+    inputSchema: codeIntelligenceSchema,
+    execute: async ({ action, path, line, column, symbol }, context) => {
+      if (action !== "diagnostics" && action !== "definition" && action !== "references" && action !== "outline") {
+        return `Unsupported action: "${action}". Supported actions: "diagnostics", "definition", "references", "outline".`;
+      }
+      if (action === "diagnostics") {
+        const diagFn = context.operations.diagnostics?.getDiagnostics || context.operations.lsp?.getDiagnostics;
+        if (!diagFn) {
+          return "Error: Diagnostics operations are not supported in the current environment.";
+        }
+        try {
+          const diags = await diagFn(path ?? "");
+          return formatDiagnostics(diags, path);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return `Error retrieving diagnostics: ${message}`;
+        }
+      }
+      if (action === "outline") {
+        if (!path) {
+          return 'Error: "path" parameter is required for "outline" action.';
+        }
+        if (!context.operations.lsp?.getOutline) {
+          return "Error: LSP operations are not supported in the current environment.";
+        }
+        try {
+          const symbols = await context.operations.lsp.getOutline(path);
+          if (!symbols || symbols.length === 0) {
+            return `No document symbols found for ${path}.`;
+          }
+          const lines = symbols.map((s) => `- [${s.kind}] ${s.name} (${path}:${s.line}:${s.column})${s.containerName ? ` (in ${s.containerName})` : ""}`);
+          return `Document outline for ${path}:
+${lines.join(`
+`)}`;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return `Error retrieving outline: ${message}`;
+        }
+      }
+      if (!path) {
+        return `Error: "path" parameter is required for "${action}" action.`;
+      }
+      let targetLine = line;
+      let targetColumn = column;
+      if ((targetLine === undefined || targetColumn === undefined) && symbol) {
+        try {
+          const content = await context.operations.fs.readFile(path);
+          const fileLines = content.split(`
+`);
+          let fallbackLine;
+          let fallbackCol;
+          for (let i = 0;i < fileLines.length; i++) {
+            const lineStr = fileLines[i];
+            const idx = lineStr.indexOf(symbol);
+            if (idx !== -1) {
+              if (/^\s*import\b/.test(lineStr)) {
+                if (fallbackLine === undefined) {
+                  fallbackLine = i + 1;
+                  fallbackCol = idx + 1;
+                }
+              } else {
+                targetLine = i + 1;
+                targetColumn = idx + 1;
+                break;
+              }
+            }
+          }
+          if (targetLine === undefined) {
+            targetLine = fallbackLine;
+            targetColumn = fallbackCol;
+          }
+          if (targetLine === undefined || targetColumn === undefined) {
+            return `Symbol "${symbol}" not found in ${path}.`;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return `Error reading file ${path}: ${message}`;
+        }
+      }
+      if (targetLine === undefined || targetColumn === undefined) {
+        return `Error: "line" and "column" (or "symbol") are required for "${action}" action.`;
+      }
+      if (action === "definition") {
+        if (!context.operations.lsp?.getDefinition) {
+          return "Error: LSP operations are not supported in the current environment.";
+        }
+        try {
+          const raw = await context.operations.lsp.getDefinition(path, targetLine, targetColumn);
+          const locs = Array.isArray(raw) ? raw : raw ? [raw] : [];
+          if (locs.length === 0) {
+            return `No definition found for symbol at ${path}:${targetLine}:${targetColumn}.`;
+          }
+          if (locs.length === 1) {
+            const loc = locs[0];
+            return `Definition found at ${loc.filePath}:${loc.line}:${loc.column}`;
+          }
+          const list = locs.map((l) => `- ${l.filePath}:${l.line}:${l.column}`).join(`
+`);
+          return `Definition(s) found:
+${list}`;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return `Error retrieving definition: ${message}`;
+        }
+      }
+      if (action === "references") {
+        if (!context.operations.lsp?.getReferences) {
+          return "Error: LSP operations are not supported in the current environment.";
+        }
+        try {
+          const refs = await context.operations.lsp.getReferences(path, targetLine, targetColumn);
+          if (!refs || refs.length === 0) {
+            return `No references found for symbol at ${path}:${targetLine}:${targetColumn}.`;
+          }
+          const list = refs.map((r) => `- ${r.filePath}:${r.line}:${r.column}`).join(`
+`);
+          return `Found ${refs.length} reference(s) for symbol at ${path}:${targetLine}:${targetColumn}:
+${list}`;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return `Error retrieving references: ${message}`;
+        }
+      }
+      return `Unsupported action: "${action}".`;
+    }
+  };
+});
+
 // ../../packages/tools/src/deferred-registry.ts
 class DeferredToolRegistry {
   tools = new Map;
@@ -121273,6 +121481,264 @@ var init_ls = __esm(() => {
   };
 });
 
+// ../../packages/tools/src/manage_memory.ts
+import path20 from "node:path";
+function resolveWriteTarget(cwd, target, category) {
+  const isRules = target === "rules" || target === "RULES.md" || !target && category === "rules";
+  if (isRules) {
+    if (target === "RULES.md") {
+      return { relativePath: "RULES.md", isRules: true };
+    }
+    return { relativePath: "RULES.md", isRules: true };
+  }
+  if (target === "MEMORY.md") {
+    return { relativePath: "MEMORY.md", isRules: false };
+  }
+  return { relativePath: path20.join(".december", "memory.md"), isRules: false };
+}
+function resolveReadCandidates(target) {
+  if (target === "rules" || target === "RULES.md") {
+    return ["RULES.md", path20.join(".december", "rules.md"), path20.join(".december", "RULES.md")];
+  }
+  if (target === "memory" || target === "MEMORY.md") {
+    return [
+      path20.join(".december", "memory.md"),
+      "MEMORY.md",
+      path20.join(".december", "MEMORY.md")
+    ];
+  }
+  return [
+    path20.join(".december", "memory.md"),
+    "MEMORY.md",
+    "RULES.md",
+    path20.join(".december", "rules.md")
+  ];
+}
+function normalizeEntry(text) {
+  return text.replace(/^[-*•]\s+/, "").trim();
+}
+var manageMemorySchema, ManageMemoryTool;
+var init_manage_memory = __esm(() => {
+  init_esm2();
+  manageMemorySchema = Type2.Object({
+    action: Type2.Union([Type2.Literal("record"), Type2.Literal("read"), Type2.Literal("forget")], {
+      description: 'The action to perform: "record" to store an entry, "read" to inspect entries, or "forget" to prune an entry.'
+    }),
+    entry: Type2.Optional(Type2.String({
+      description: "The memory or rule entry text to record or forget."
+    })),
+    category: Type2.Optional(Type2.Union([
+      Type2.Literal("build_and_test"),
+      Type2.Literal("conventions"),
+      Type2.Literal("architecture"),
+      Type2.Literal("quirks"),
+      Type2.Literal("rules"),
+      Type2.Literal("general")
+    ], {
+      description: "Category header: build_and_test, conventions, architecture, quirks, rules, or general."
+    })),
+    target: Type2.Optional(Type2.Union([
+      Type2.Literal("memory"),
+      Type2.Literal("rules"),
+      Type2.Literal("MEMORY.md"),
+      Type2.Literal("RULES.md")
+    ], {
+      description: 'Target file: "memory" (.december/memory.md or MEMORY.md) or "rules" (RULES.md or .december/rules.md). Defaults to memory for general/memory entries, or rules if category is "rules".'
+    })),
+    query: Type2.Optional(Type2.String({
+      description: "Optional query keyword to filter entries when reading."
+    }))
+  });
+  ManageMemoryTool = {
+    name: "manage_memory",
+    description: "Use this tool to record, read, or forget persistent notes, conventions, build/test commands, quirks, and rules across sessions in workspace memory (.december/memory.md, MEMORY.md, RULES.md).",
+    inputSchema: manageMemorySchema,
+    execute: async ({ action, entry, category, target, query }, context) => {
+      const cwd = context.operations.env.cwd();
+      switch (action) {
+        case "record": {
+          if (!entry || !entry.trim()) {
+            return 'Error: "entry" parameter is required for action "record".';
+          }
+          const cleanEntry = normalizeEntry(entry);
+          if (!cleanEntry) {
+            return 'Error: "entry" parameter cannot be empty.';
+          }
+          const { relativePath, isRules } = resolveWriteTarget(cwd, target, category);
+          const fullPath = path20.isAbsolute(relativePath) ? relativePath : path20.join(cwd, relativePath);
+          const cat = category || (isRules ? "rules" : "conventions");
+          let existingContent = "";
+          try {
+            existingContent = await context.operations.fs.readFile(fullPath);
+          } catch {}
+          const lines = existingContent.split(`
+`);
+          for (const line of lines) {
+            const lineContent = normalizeEntry(line);
+            if (lineContent && lineContent.toLowerCase() === cleanEntry.toLowerCase()) {
+              return `Entry already exists in ${relativePath} under "${cat}". Skipped duplicate.`;
+            }
+          }
+          const headerRegex = new RegExp(`^##\\s+${cat}\\b`, "im");
+          const headerMatch = existingContent.match(headerRegex);
+          let updatedContent = "";
+          if (headerMatch && headerMatch.index !== undefined) {
+            const headerIndex = headerMatch.index;
+            const rest = existingContent.slice(headerIndex);
+            const nextHeaderMatch = rest.slice(headerMatch[0].length).match(/\n##\s+/i);
+            if (nextHeaderMatch && nextHeaderMatch.index !== undefined) {
+              const insertPos = headerIndex + headerMatch[0].length + nextHeaderMatch.index;
+              updatedContent = `${existingContent.slice(0, insertPos)}
+- ${cleanEntry}${existingContent.slice(insertPos)}`;
+            } else {
+              updatedContent = `${existingContent.trimEnd()}
+- ${cleanEntry}
+`;
+            }
+          } else {
+            const prefix = existingContent.trim() ? `${existingContent.trimEnd()}
+
+` : "";
+            updatedContent = `${prefix}## ${cat}
+- ${cleanEntry}
+`;
+          }
+          try {
+            await context.operations.fs.writeFile(fullPath, updatedContent);
+            return `Recorded entry under "${cat}" in ${relativePath}.`;
+          } catch (err) {
+            return `Failed to write memory file: ${err.message}`;
+          }
+        }
+        case "read": {
+          const candidates = resolveReadCandidates(target);
+          const contents = [];
+          for (const candidate of candidates) {
+            const fullPath = path20.isAbsolute(candidate) ? candidate : path20.join(cwd, candidate);
+            try {
+              const text = await context.operations.fs.readFile(fullPath);
+              if (text && text.trim()) {
+                contents.push({ file: candidate, text: text.trim() });
+              }
+            } catch {}
+          }
+          if (contents.length === 0) {
+            return "No memory or rules entries found.";
+          }
+          if (category) {
+            const matchedSections = [];
+            const catLower = category.toLowerCase();
+            for (const item of contents) {
+              const lines = item.text.split(`
+`);
+              let inCategory = false;
+              const sectionLines = [];
+              for (const line of lines) {
+                if (line.startsWith("## ")) {
+                  const headerName = line.slice(3).trim().toLowerCase();
+                  if (headerName === catLower) {
+                    inCategory = true;
+                    sectionLines.push(line);
+                  } else {
+                    inCategory = false;
+                  }
+                } else if (inCategory) {
+                  sectionLines.push(line);
+                }
+              }
+              if (sectionLines.length > 0) {
+                matchedSections.push(`### Source: ${item.file}
+${sectionLines.join(`
+`).trim()}`);
+              }
+            }
+            if (matchedSections.length === 0) {
+              return `No entries found under category "${category}".`;
+            }
+            return matchedSections.join(`
+
+`);
+          }
+          if (query) {
+            const queryLower = query.toLowerCase();
+            const matchedLines = [];
+            for (const item of contents) {
+              const lines = item.text.split(`
+`);
+              let currentHeader = "";
+              const fileMatches = [];
+              for (const line of lines) {
+                if (line.startsWith("## ")) {
+                  currentHeader = line;
+                } else if (line.toLowerCase().includes(queryLower)) {
+                  if (currentHeader && !fileMatches.includes(currentHeader)) {
+                    fileMatches.push(currentHeader);
+                  }
+                  fileMatches.push(line);
+                }
+              }
+              if (fileMatches.length > 0) {
+                matchedLines.push(`### Source: ${item.file}
+${fileMatches.join(`
+`)}`);
+              }
+            }
+            if (matchedLines.length === 0) {
+              return `No memory entries found matching "${query}".`;
+            }
+            return matchedLines.join(`
+
+`);
+          }
+          return contents.map((c) => `### Source: ${c.file}
+${c.text}`).join(`
+
+`);
+        }
+        case "forget": {
+          if (!entry || !entry.trim()) {
+            return 'Error: "entry" parameter is required for action "forget".';
+          }
+          const targetClean = normalizeEntry(entry).toLowerCase();
+          const candidates = resolveReadCandidates(target);
+          let removed = false;
+          for (const candidate of candidates) {
+            const fullPath = path20.isAbsolute(candidate) ? candidate : path20.join(cwd, candidate);
+            try {
+              const text = await context.operations.fs.readFile(fullPath);
+              const lines = text.split(`
+`);
+              const newLines = [];
+              let fileModified = false;
+              for (const line of lines) {
+                const lineClean = normalizeEntry(line).toLowerCase();
+                if (lineClean && (lineClean === targetClean || lineClean.includes(targetClean))) {
+                  fileModified = true;
+                  removed = true;
+                  continue;
+                }
+                newLines.push(line);
+              }
+              if (fileModified) {
+                await context.operations.fs.writeFile(fullPath, newLines.join(`
+`).trimEnd() + `
+`);
+              }
+            } catch {}
+          }
+          if (removed) {
+            return "Removed entry from memory.";
+          }
+          return "Entry not found in memory.";
+        }
+        default: {
+          return "Invalid action. Supported actions: record, read, forget.";
+        }
+      }
+    }
+  };
+});
+
 // ../../packages/tools/src/manage_task.ts
 var manageTaskSchema, ManageTaskTool;
 var init_manage_task = __esm(() => {
@@ -162241,7 +162707,7 @@ ${formatted}`;
 
 // ../../packages/tools/src/bash-operations.ts
 import { spawn as spawn2 } from "node:child_process";
-import path20 from "node:path";
+import path21 from "node:path";
 function trackDetachedChildPid(pid) {
   trackedDetachedChildPids.add(pid);
 }
@@ -162251,7 +162717,7 @@ function untrackDetachedChildPid(pid) {
 function killProcessGroup(pid) {
   if (process.platform === "win32") {
     try {
-      const child = spawn2(path20.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe"), ["/F", "/T", "/PID", String(pid)], {
+      const child = spawn2(path21.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "taskkill.exe"), ["/F", "/T", "/PID", String(pid)], {
         stdio: "ignore",
         detached: true,
         windowsHide: true
@@ -162369,12 +162835,14 @@ var init_src4 = __esm(() => {
   init_ask_question();
   init_bash();
   init_browser();
+  init_code_intelligence();
   init_deferred_registry();
   init_edit();
   init_edit_diff();
   init_find();
   init_grep();
   init_ls();
+  init_manage_memory();
   init_manage_task();
   init_read();
   init_search_tools();
@@ -162392,11 +162860,13 @@ var init_src4 = __esm(() => {
   init_grep();
   init_ask_question();
   init_manage_task();
+  init_manage_memory();
   init_browser();
   init_web_search();
   init_diff_preview();
   init_deferred_registry();
   init_search_tools();
+  init_code_intelligence();
   CORE_TOOLS = [
     BashTool,
     ReadFileTool,
@@ -162407,7 +162877,9 @@ var init_src4 = __esm(() => {
     FindFilesTool,
     GrepSearchTool,
     AskQuestionTool,
-    SearchToolsTool
+    SearchToolsTool,
+    CodeIntelligenceTool,
+    ManageMemoryTool
   ];
   DEFERRED_TOOLS = [ManageTaskTool, BrowserTool, WebSearchTool];
   defaultDeferredRegistry.register(BrowserTool, {
@@ -162422,6 +162894,10 @@ var init_src4 = __esm(() => {
     category: "task",
     keywords: ["task", "background", "kill", "status", "process", "pid", "manage_task"]
   });
+  defaultDeferredRegistry.register(ManageMemoryTool, {
+    category: "memory",
+    keywords: ["memory", "rules", "conventions", "quirks", "manage_memory", "remember", "forget"]
+  });
 });
 
 // ../../node_modules/.bun/uuid@14.0.1/node_modules/uuid/dist-node/rng.js
@@ -162626,6 +163102,64 @@ function estimateTokens(messages) {
     return acc + Math.ceil((text.length + toolInput.length) / 4);
   }, 0);
 }
+function isSafeCompactionBoundary(messages, splitIndex, startIndex = 0) {
+  if (splitIndex <= startIndex || splitIndex >= messages.length) {
+    return false;
+  }
+  if (messages[splitIndex]?.role === "tool") {
+    return false;
+  }
+  const preCallIds = new Set;
+  for (let i = startIndex;i < splitIndex; i++) {
+    const msg = messages[i];
+    if (msg?.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        if (tc.id)
+          preCallIds.add(tc.id);
+      }
+    }
+  }
+  for (let i = splitIndex;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg?.role === "tool" && msg.toolCallId && preCallIds.has(msg.toolCallId)) {
+      return false;
+    }
+  }
+  const postCallIds = new Set;
+  for (let i = splitIndex;i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg?.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        if (tc.id)
+          postCallIds.add(tc.id);
+      }
+    }
+  }
+  for (let i = startIndex;i < splitIndex; i++) {
+    const msg = messages[i];
+    if (msg?.role === "tool" && msg.toolCallId && postCallIds.has(msg.toolCallId)) {
+      return false;
+    }
+  }
+  return true;
+}
+function findSafeCompactionBoundary(messages, targetIndex, startIndex = 1) {
+  if (isSafeCompactionBoundary(messages, targetIndex, startIndex)) {
+    return targetIndex;
+  }
+  const maxDelta = messages.length;
+  for (let delta = 1;delta < maxDelta; delta++) {
+    const left = targetIndex - delta;
+    if (left > startIndex && isSafeCompactionBoundary(messages, left, startIndex)) {
+      return left;
+    }
+    const right = targetIndex + delta;
+    if (right < messages.length && isSafeCompactionBoundary(messages, right, startIndex)) {
+      return right;
+    }
+  }
+  return targetIndex;
+}
 async function compactContextIfNeeded(messages, llm, maxTokens, modelOptions, signal) {
   let limit = maxTokens;
   if (!limit) {
@@ -162644,10 +163178,17 @@ async function compactContextIfNeeded(messages, llm, maxTokens, modelOptions, si
   if (messages.length <= PROTECTED_TAIL + 1) {
     return messages;
   }
-  const systemPrompt = messages[0];
-  const middleHistory = messages.slice(1, messages.length - PROTECTED_TAIL);
-  const recentHistory = messages.slice(messages.length - PROTECTED_TAIL);
-  const hasPreviousSummary = middleHistory.length > 0 && middleHistory[0].role === "system" && middleHistory[0].content.includes("[COMPACTED HISTORY SUMMARY]");
+  const hasSystemPrompt = messages[0]?.role === "system";
+  const systemPrompt = hasSystemPrompt ? messages[0] : undefined;
+  const historyStartIndex = hasSystemPrompt ? 1 : 0;
+  const targetIndex = messages.length - PROTECTED_TAIL;
+  const safeSplitIndex = findSafeCompactionBoundary(messages, targetIndex, historyStartIndex);
+  if (safeSplitIndex <= historyStartIndex || safeSplitIndex >= messages.length) {
+    return messages;
+  }
+  const middleHistory = messages.slice(historyStartIndex, safeSplitIndex);
+  const recentHistory = messages.slice(safeSplitIndex);
+  const hasPreviousSummary = middleHistory.length > 0 && (middleHistory[0].role === "system" || middleHistory[0].role === "user") && middleHistory[0].content.includes("[COMPACTED HISTORY SUMMARY]");
   let previousSummaryText = "";
   let messagesToSummarize = middleHistory;
   if (hasPreviousSummary) {
@@ -162655,6 +163196,9 @@ async function compactContextIfNeeded(messages, llm, maxTokens, modelOptions, si
 `, "");
     messagesToSummarize = middleHistory.slice(1);
   }
+  if (messagesToSummarize.length === 0) {
+    return messages;
+  }
   const fileManifests = extractFileManifests(messagesToSummarize, previousSummaryText);
   const historyText = messagesToSummarize.map((m) => {
     let txt = `[${m.role.toUpperCase()}]: ${m.content}`;
@@ -162792,7 +163336,7 @@ ${fileManifests.modifiedFiles.join(`
     content: `[COMPACTED HISTORY SUMMARY]
 ${finalSummary}`
   };
-  return [systemPrompt, summaryMessage, ...recentHistory];
+  return systemPrompt ? [systemPrompt, summaryMessage, ...recentHistory] : [summaryMessage, ...recentHistory];
 }
 var DEFAULT_MAX_TOKENS = 32000, PRUNE_PROTECT_TOKENS = 40000, PRUNE_MINIMUM_SAVINGS = 15000, PRUNE_PROTECT_STEPS = 3, PRUNE_PROTECTED_TOOLS;
 var init_compaction = __esm(() => {
@@ -162801,10 +163345,144 @@ var init_compaction = __esm(() => {
 });
 
 // ../../packages/agent/src/conversation-manager.ts
+import fs19 from "node:fs";
+import path22 from "node:path";
+
 class ConversationManager {
   _messages = [];
-  constructor(initialMessages = []) {
+  workspaceRoot;
+  constructor(initialMessagesOrOptions, options) {
+    let initialMessages = [];
+    let opts;
+    if (Array.isArray(initialMessagesOrOptions)) {
+      initialMessages = initialMessagesOrOptions;
+      opts = options;
+    } else if (initialMessagesOrOptions && typeof initialMessagesOrOptions === "object") {
+      opts = initialMessagesOrOptions;
+    }
     this._messages = initialMessages;
+    if (opts?.workspaceRoot) {
+      this.workspaceRoot = opts.workspaceRoot;
+      this.initSession({
+        workspaceRoot: opts.workspaceRoot,
+        systemPrompt: opts.systemPrompt
+      });
+    }
+  }
+  initSession(optionsOrWorkspaceRoot, systemPromptArg) {
+    let workspaceRoot;
+    let systemPrompt;
+    if (typeof optionsOrWorkspaceRoot === "string") {
+      workspaceRoot = optionsOrWorkspaceRoot;
+      systemPrompt = systemPromptArg;
+    } else if (optionsOrWorkspaceRoot && typeof optionsOrWorkspaceRoot === "object") {
+      workspaceRoot = optionsOrWorkspaceRoot.workspaceRoot;
+      systemPrompt = optionsOrWorkspaceRoot.systemPrompt;
+    } else {
+      workspaceRoot = this.workspaceRoot;
+      systemPrompt = systemPromptArg;
+    }
+    if (workspaceRoot) {
+      this.workspaceRoot = workspaceRoot;
+    }
+    const existingSystemIndex = this._messages.findIndex((m) => m.role === "system");
+    let prompt = systemPrompt;
+    if (prompt === undefined) {
+      if (existingSystemIndex !== -1) {
+        prompt = this._messages[existingSystemIndex].content;
+      } else {
+        prompt = "";
+      }
+    }
+    const memoryContent = this.readWorkspaceMemory(workspaceRoot);
+    let finalPrompt = prompt;
+    if (memoryContent) {
+      finalPrompt = this.injectMemoryBlock(prompt, memoryContent);
+    }
+    if (existingSystemIndex !== -1) {
+      this._messages[existingSystemIndex].content = finalPrompt;
+    } else if (finalPrompt) {
+      this._messages.unshift({
+        role: "system",
+        content: finalPrompt,
+        id: v4_default2(),
+        timestamp: Date.now()
+      });
+    }
+    return finalPrompt;
+  }
+  readWorkspaceMemory(workspaceRoot) {
+    if (!workspaceRoot)
+      return "";
+    const memoryCandidates = [
+      path22.join(workspaceRoot, ".december", "memory.md"),
+      path22.join(workspaceRoot, "MEMORY.md"),
+      path22.join(workspaceRoot, ".december", "MEMORY.md"),
+      path22.join(workspaceRoot, "memory.md")
+    ];
+    const rulesCandidates = [
+      path22.join(workspaceRoot, "RULES.md"),
+      path22.join(workspaceRoot, ".december", "rules.md"),
+      path22.join(workspaceRoot, ".december", "RULES.md"),
+      path22.join(workspaceRoot, "rules.md")
+    ];
+    let memoryText = "";
+    for (const candidate of memoryCandidates) {
+      try {
+        if (fs19.existsSync(candidate) && fs19.statSync(candidate).isFile()) {
+          const content = fs19.readFileSync(candidate, "utf8").trim();
+          if (content) {
+            memoryText = content;
+            break;
+          }
+        }
+      } catch {}
+    }
+    let rulesText = "";
+    for (const candidate of rulesCandidates) {
+      try {
+        if (fs19.existsSync(candidate) && fs19.statSync(candidate).isFile()) {
+          const content = fs19.readFileSync(candidate, "utf8").trim();
+          if (content) {
+            rulesText = content;
+            break;
+          }
+        }
+      } catch {}
+    }
+    const parts = [];
+    if (memoryText)
+      parts.push(memoryText);
+    if (rulesText && rulesText !== memoryText)
+      parts.push(rulesText);
+    return parts.join(`
+
+`).trim();
+  }
+  injectMemoryBlock(prompt, memoryContent) {
+    if (!memoryContent.trim())
+      return prompt;
+    if (prompt.includes("<project_memory>"))
+      return prompt;
+    const block = `<project_memory>
+${memoryContent.trim()}
+</project_memory>`;
+    if (!prompt)
+      return block;
+    if (prompt.includes(`
+
+Current date:`)) {
+      return prompt.replace(`
+
+Current date:`, `
+
+${block}
+
+Current date:`);
+    }
+    return `${prompt}
+
+${block}`;
   }
   get messages() {
     return this._messages;
@@ -163559,10 +164237,10 @@ class LangfuseMedia {
       this._contentType = contentType;
       this._source = "bytes";
     } else if (filePath && contentType) {
-      if (!fs19) {
+      if (!fs20) {
         throw new Error("File system support is not available in this environment");
       }
-      if (!fs19.existsSync(filePath)) {
+      if (!fs20.existsSync(filePath)) {
         throw new Error(`File at path ${filePath} does not exist`);
       }
       this._contentBytes = this.readFile(filePath);
@@ -163574,10 +164252,10 @@ class LangfuseMedia {
   }
   readFile(filePath) {
     try {
-      if (!fs19) {
+      if (!fs20) {
         throw new Error("File system support is not available in this environment");
       }
-      return fs19.readFileSync(filePath);
+      return fs20.readFileSync(filePath);
     } catch (error) {
       console.error(`Error reading file at path ${filePath}`, error);
       return;
@@ -164699,7 +165377,7 @@ var DEFAULT_PROMPT_CACHE_TTL_SECONDS = 60, LangfusePersistedProperty, ChatMessag
     }
   });
   return queryParams.toString();
-}, utils, common_release_envs, fs19 = null, cryptoModule = null, dynamicImport = (module) => {
+}, utils, common_release_envs, fs20 = null, cryptoModule = null, dynamicImport = (module) => {
   return import(module);
 }, MAX_EVENT_SIZE_BYTES, MAX_BATCH_SIZE_BYTES, ENVIRONMENT_PATTERN, WHITELISTED_LANGFUSE_INTERNAL_ENVIRONMENTS, LangfuseFetchHttpError, LangfuseFetchNetworkError, SUPPORT_URL = "https://langfuse.com/support", API_DOCS_URL = "https://api.reference.langfuse.com", RBAC_DOCS_URL = "https://langfuse.com/docs/rbac", INSTALLATION_DOCS_URL = "https://langfuse.com/docs/sdk/typescript/guide", RATE_LIMITS_URL = "https://langfuse.com/faq/all/api-limits", NPM_PACKAGE_URL = "https://www.npmjs.com/package/langfuse", updatePromptResponse, defaultServerErrorPrompt, defaultErrorResponse, errorResponseByCode, LangfuseCore, LangfuseTraceClient, LangfuseObservationClient, LangfuseSpanClient, LangfuseGenerationClient, LangfuseEventClient;
 var init_lib = __esm(() => {
@@ -164878,12 +165556,12 @@ var init_lib = __esm(() => {
   ];
   if (typeof globalThis.Deno !== "undefined") {
     Promise.all([dynamicImport("node:fs"), dynamicImport("node:crypto")]).then(([importedFs, importedCrypto]) => {
-      fs19 = importedFs;
+      fs20 = importedFs;
       cryptoModule = importedCrypto;
     }).catch();
   } else if (typeof process !== "undefined" && process.versions?.node) {
     Promise.all([dynamicImport("fs"), dynamicImport("crypto")]).then(([importedFs, importedCrypto]) => {
-      fs19 = importedFs;
+      fs20 = importedFs;
       cryptoModule = importedCrypto;
     }).catch();
   } else if (typeof crypto !== "undefined") {
@@ -166386,29 +167064,73 @@ var init_tracer_factory = __esm(() => {
 });
 
 // ../../packages/agent/src/utils/evaporation.ts
-function evaporateStaleToolOutputs(messages, preserveRecentTurns = 3) {
+function isErrorToolOutput(content) {
+  const lower = content.toLowerCase();
+  return content.includes("[Tool Error]") || lower.includes("error:") || lower.includes("command failed") || lower.includes("exit code 1") || lower.includes("exit code 2") || lower.includes("failed:") || lower.includes("traceback (most recent call last)") || lower.includes("exception:") || lower.includes("fatal:") || lower.includes("panic:") || lower.includes("syntaxerror");
+}
+function truncateLargeToolOutput(rawContent, maxBytes = 6 * 1024, headLines = 20, tailLines = 20) {
+  const byteLength = Buffer.byteLength(rawContent, "utf8");
+  if (byteLength <= maxBytes) {
+    return rawContent;
+  }
+  if (isErrorToolOutput(rawContent)) {
+    return rawContent;
+  }
+  const lines = rawContent.split(`
+`);
+  if (lines.length <= headLines + tailLines) {
+    return rawContent;
+  }
+  const head = lines.slice(0, headLines).join(`
+`);
+  const tail = lines.slice(lines.length - tailLines).join(`
+`);
+  const omittedLines = lines.length - headLines - tailLines;
+  const omittedBytes = byteLength - Buffer.byteLength(head, "utf8") - Buffer.byteLength(tail, "utf8");
+  const omittedKb = (omittedBytes / 1024).toFixed(1);
+  const banner = `
+
+[... ${omittedLines} lines truncated (${omittedKb} KB) ...]
+
+`;
+  return head + banner + tail;
+}
+function evaporateStaleToolOutputs(messages, preserveRecentTurnsOrOptions = 3, preserveRecentStepsArg) {
   if (!messages || messages.length === 0)
     return [];
+  let preserveRecentTurns = 3;
+  let preserveRecentSteps = 2;
+  let maxOutputSize = 6 * 1024;
+  let headLines = 20;
+  let tailLines = 20;
+  if (typeof preserveRecentTurnsOrOptions === "number") {
+    preserveRecentTurns = preserveRecentTurnsOrOptions;
+    if (preserveRecentStepsArg !== undefined) {
+      preserveRecentSteps = preserveRecentStepsArg;
+    }
+  } else if (typeof preserveRecentTurnsOrOptions === "object") {
+    preserveRecentTurns = preserveRecentTurnsOrOptions.preserveRecentTurns ?? 3;
+    preserveRecentSteps = preserveRecentTurnsOrOptions.preserveRecentSteps ?? 2;
+    maxOutputSize = preserveRecentTurnsOrOptions.maxOutputSize ?? 6 * 1024;
+    headLines = preserveRecentTurnsOrOptions.headLines ?? 20;
+    tailLines = preserveRecentTurnsOrOptions.tailLines ?? 20;
+  }
   let userTurnsSeen = 0;
-  let cutoffIndex = 0;
+  let agentStepsSeen = 0;
+  const isStale = new Array(messages.length).fill(false);
   for (let i = messages.length - 1;i >= 0; i--) {
     const msg = messages[i];
+    if (!msg)
+      continue;
     if (msg.role === "user" && !msg.isUI) {
       userTurnsSeen++;
-      if (userTurnsSeen >= preserveRecentTurns) {
-        cutoffIndex = i;
-        break;
-      }
     }
-  }
-  if (userTurnsSeen < preserveRecentTurns || cutoffIndex <= 0) {
-    return messages.map((m) => ({
-      role: m.role,
-      content: m.content,
-      thinking: m.thinking,
-      toolCalls: m.toolCalls,
-      toolCallId: m.toolCallId
-    }));
+    if (msg.role === "assistant" && (msg.toolCalls?.length || 0) > 0) {
+      agentStepsSeen++;
+    }
+    if (userTurnsSeen >= preserveRecentTurns || agentStepsSeen >= preserveRecentSteps) {
+      isStale[i] = true;
+    }
   }
   return messages.map((msg, idx) => {
     const baseMsg = {
@@ -166418,27 +167140,37 @@ function evaporateStaleToolOutputs(messages, preserveRecentTurns = 3) {
       toolCalls: msg.toolCalls,
       toolCallId: msg.toolCallId
     };
-    if (idx >= cutoffIndex) {
+    if (msg.role !== "tool") {
       return baseMsg;
     }
-    if (msg.role === "tool") {
-      const rawContent = typeof msg.content === "string" ? msg.content : "";
-      if (rawContent.length < 200) {
-        return baseMsg;
-      }
-      if (rawContent.includes("[Tool Error]") || rawContent.toLowerCase().includes("error:") || rawContent.toLowerCase().includes("command failed")) {
-        return baseMsg;
-      }
+    const rawContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    if (rawContent.length < 200) {
+      return baseMsg;
+    }
+    if (isErrorToolOutput(rawContent)) {
+      return baseMsg;
+    }
+    if (rawContent.startsWith("[Tool Output Evaporated:") || rawContent.startsWith("[tool output microcompacted:") || rawContent.startsWith("[Old tool result content cleared]")) {
+      return baseMsg;
+    }
+    if (isStale[idx]) {
       const lines = rawContent.split(`
 `);
       const lineCount = lines.length;
       const byteSize = (Buffer.byteLength(rawContent, "utf8") / 1024).toFixed(1);
-      const tombstone = `[Tool Output Evaporated: ${lineCount} lines (${byteSize} KB). Content previously processed by assistant.]`;
+      const tombstone = `[Tool Output Evaporated: ${lineCount} lines (${byteSize} KB). exit code 0. Content previously processed by assistant.]`;
       return {
         ...baseMsg,
         content: tombstone
       };
     }
+    const truncated = truncateLargeToolOutput(rawContent, maxOutputSize, headLines, tailLines);
+    if (truncated !== rawContent) {
+      return {
+        ...baseMsg,
+        content: truncated
+      };
+    }
     return baseMsg;
   });
 }
@@ -166503,8 +167235,14 @@ class Agent2 {
     this.convertToLlm = config.convertToLlm || this.defaultConvertToLlm;
     this.steeringQueue = new PendingMessageQueue(config.steeringMode || "all");
     this.followUpQueue = new PendingMessageQueue(config.followUpMode || "all");
-    this.conversation = new ConversationManager;
     this.workspaceDir = config.workspaceDir;
+    this.conversation = new ConversationManager([], {
+      workspaceRoot: config.workspaceDir
+    });
+    this.systemPrompt = this.conversation.initSession({
+      workspaceRoot: config.workspaceDir,
+      systemPrompt: this.systemPrompt
+    });
     this.logsDir = config.logsDir;
     this.disableLogging = config.disableLogging || false;
     this.deferredRegistry = config.deferredRegistry || new DeferredToolRegistry;
@@ -166522,10 +167260,12 @@ class Agent2 {
         this.deferredRegistry.register(tool);
       }
     }
-    this.conversation.addMessage({
-      role: "system",
-      content: this.systemPrompt
-    });
+    if (this.conversation.messages.length === 0) {
+      this.conversation.addMessage({
+        role: "system",
+        content: this.systemPrompt
+      });
+    }
   }
   get messages() {
     return this.conversation.messages;
@@ -166535,16 +167275,26 @@ class Agent2 {
   }
   defaultConvertToLlm(messages) {
     const filtered = messages.filter((m) => !m.isUI);
-    const evaporated = evaporateStaleToolOutputs(filtered, 3);
+    const evaporated = evaporateStaleToolOutputs(filtered, {
+      preserveRecentTurns: 3,
+      preserveRecentSteps: 2,
+      maxOutputSize: 6 * 1024
+    });
     const merged = [];
-    for (const msg of evaporated) {
+    for (let i = 0;i < evaporated.length; i++) {
+      const msg = evaporated[i];
+      let role = msg.role;
+      const content = msg.content;
+      if (role === "system" && i > 0 && content.includes("[COMPACTED HISTORY SUMMARY]")) {
+        role = "user";
+      }
       const prev = merged[merged.length - 1];
-      if (prev && prev.role === "user" && msg.role === "user" && !prev.toolCalls && !msg.toolCalls) {
+      if (prev && prev.role === "user" && role === "user" && !prev.toolCalls && !msg.toolCalls) {
         prev.content = `${prev.content}
 
-${msg.content}`;
+${content}`;
       } else {
-        merged.push({ ...msg });
+        merged.push({ ...msg, role, content });
       }
     }
     return merged;
@@ -166858,9 +167608,9 @@ var init_p_retry = __esm(() => {
 });
 
 // ../../packages/agent/src/utils/request-logger.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os11 from "node:os";
-import path21 from "node:path";
+import path23 from "node:path";
 function createRequestLogEntry(params) {
   const {
     turn,
@@ -166913,11 +167663,11 @@ function getGlobalConfigDir() {
   const home = process.env.HOME || os11.homedir();
   const isTestEnv = !!process.env.VITEST;
   if (isTestEnv && home === os11.homedir()) {
-    return path21.join(os11.tmpdir(), "december-test-config", ".december");
+    return path23.join(os11.tmpdir(), "december-test-config", ".december");
   }
-  const canonicalDir = path21.join(home, ".december");
-  const legacyDir = path21.join(home, ".config", "december");
-  if (fs20.existsSync(canonicalDir) || !fs20.existsSync(legacyDir)) {
+  const canonicalDir = path23.join(home, ".december");
+  const legacyDir = path23.join(home, ".config", "december");
+  if (fs21.existsSync(canonicalDir) || !fs21.existsSync(legacyDir)) {
     return canonicalDir;
   }
   return legacyDir;
@@ -166927,7 +167677,7 @@ function getLogsDir(customDir) {
     return customDir;
   if (process.env.DECEMBER_LOGS_DIR)
     return process.env.DECEMBER_LOGS_DIR;
-  return path21.join(getGlobalConfigDir(), "logs");
+  return path23.join(getGlobalConfigDir(), "logs");
 }
 function getSessionLogPath(sessionIdOrLogsDir, logsDirOrSessionId) {
   if (!sessionIdOrLogsDir && !logsDirOrSessionId)
@@ -166935,7 +167685,7 @@ function getSessionLogPath(sessionIdOrLogsDir, logsDirOrSessionId) {
   let sessionId;
   let customDir;
   if (logsDirOrSessionId) {
-    if (sessionIdOrLogsDir.startsWith("session-") || !sessionIdOrLogsDir.includes(path21.sep) && logsDirOrSessionId.includes(path21.sep)) {
+    if (sessionIdOrLogsDir.startsWith("session-") || !sessionIdOrLogsDir.includes(path23.sep) && logsDirOrSessionId.includes(path23.sep)) {
       sessionId = sessionIdOrLogsDir;
       customDir = logsDirOrSessionId;
     } else {
@@ -166946,7 +167696,7 @@ function getSessionLogPath(sessionIdOrLogsDir, logsDirOrSessionId) {
     sessionId = sessionIdOrLogsDir;
   }
   const cleanSessionId = sessionId.startsWith("session-") ? sessionId : `session-${sessionId}`;
-  return path21.join(getLogsDir(customDir), `${cleanSessionId}.jsonl`);
+  return path23.join(getLogsDir(customDir), `${cleanSessionId}.jsonl`);
 }
 async function appendTurnLog(arg1, arg2, arg3) {
   try {
@@ -166969,11 +167719,11 @@ async function appendTurnLog(arg1, arg2, arg3) {
     const logFile = getSessionLogPath(sessionId, logsDir);
     if (!logFile)
       return;
-    const dir = path21.dirname(logFile);
-    await fs20.promises.mkdir(dir, { recursive: true });
+    const dir = path23.dirname(logFile);
+    await fs21.promises.mkdir(dir, { recursive: true });
     const line = JSON.stringify(entry) + `
 `;
-    await fs20.promises.appendFile(logFile, line, "utf8");
+    await fs21.promises.appendFile(logFile, line, "utf8");
   } catch {}
 }
 var init_request_logger = __esm(() => {
@@ -167752,17 +168502,17 @@ var init_agent_loop = __esm(() => {
   ]);
 });
 // ../../packages/agent/src/skills/skill-subagent.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 async function executeSkillInSubagent(options) {
   const { skill, args = [], task, parentAgent, signal, onEvent } = options;
   let rawBody = skill.content || "";
-  if (!rawBody && skill.entryFilePath && fs21.existsSync(skill.entryFilePath)) {
+  if (!rawBody && skill.entryFilePath && fs22.existsSync(skill.entryFilePath)) {
     try {
       const parsed = parseSkillFile(skill.entryFilePath);
       rawBody = parsed.body;
     } catch {
       try {
-        rawBody = fs21.readFileSync(skill.entryFilePath, "utf8");
+        rawBody = fs22.readFileSync(skill.entryFilePath, "utf8");
       } catch (err) {
         return {
           success: false,
@@ -167910,9 +168660,9 @@ var init_run_skill_tool = __esm(() => {
 });
 
 // ../../packages/agent/src/harness/agent-harness.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import os12 from "node:os";
-import path22 from "node:path";
+import path24 from "node:path";
 function isReasoningModel(model, thinkingLevel) {
   if (thinkingLevel === "off") {
     return false;
@@ -167937,7 +168687,8 @@ function getModelFamilyPrompt(options) {
 - Proactive Task Breakdown: Break down complex requests into orderly stages, verify each stage empirically, and maintain single-step transitions.`;
   } else if (model.includes("gemini")) {
     roleGuidelines = `### Model Specialization (Gemini)
-- Structured Execution: Follow clear operational phases: 1) Explore and gather context, 2) Formulate targeted edits, 3) Verify thoroughly.
+- Structured Execution: Follow clear operational phases: 1) Explore and gather context (inspect repo layout in monorepos before deep-diving), 2) Formulate targeted edits, 3) Verify thoroughly.
+- Efficient Verification: Run verification tests only after modifying files, not during early exploratory discovery. Once targeted tests pass and git diff is verified clean, complete your response immediately without repeating status, diff, or test commands.
 - Absolute File Paths: STRICTLY specify absolute file paths when referencing, viewing, or editing files. NEVER output ambiguous relative paths.`;
   }
   return {
@@ -167973,22 +168724,22 @@ function discoverProjectRules(startDir, rootBoundary) {
     "AGENTS.override.md",
     "AGENTS.md",
     "CLAUDE.md",
-    path22.join(".december", "rules.md"),
-    path22.join(".december", "AGENTS.md")
+    path24.join(".december", "rules.md"),
+    path24.join(".december", "AGENTS.md")
   ];
   const seen = new Set;
-  let current = path22.resolve(startDir);
-  const boundary = rootBoundary ? path22.resolve(rootBoundary) : path22.parse(current).root;
+  let current = path24.resolve(startDir);
+  const boundary = rootBoundary ? path24.resolve(rootBoundary) : path24.parse(current).root;
   const collectedFiles = [];
   while (true) {
     for (const name of candidateNames) {
-      const candidatePath = path22.join(current, name);
-      if (fs22.existsSync(candidatePath)) {
+      const candidatePath = path24.join(current, name);
+      if (fs23.existsSync(candidatePath)) {
         try {
-          if (fs22.statSync(candidatePath).isFile()) {
+          if (fs23.statSync(candidatePath).isFile()) {
             if (!seen.has(candidatePath)) {
               seen.add(candidatePath);
-              const content = fs22.readFileSync(candidatePath, "utf8").trim();
+              const content = fs23.readFileSync(candidatePath, "utf8").trim();
               if (content) {
                 collectedFiles.unshift({ path: candidatePath, content });
               }
@@ -167999,7 +168750,7 @@ function discoverProjectRules(startDir, rootBoundary) {
     }
     if (current === boundary)
       break;
-    const parent = path22.dirname(current);
+    const parent = path24.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -168007,17 +168758,17 @@ function discoverProjectRules(startDir, rootBoundary) {
   const home = process.env.HOME || process.env.USERPROFILE || os12.homedir();
   const globalCandidateDirs = [
     process.env.DECEMBER_CONFIG_DIR,
-    path22.join(home, ".december"),
-    path22.join(home, ".config", "december")
+    path24.join(home, ".december"),
+    path24.join(home, ".config", "december")
   ].filter((dir) => !!dir);
   for (const globalDir of globalCandidateDirs) {
     for (const candidate of ["rules.md", "AGENTS.md"]) {
-      const globalPath = path22.join(globalDir, candidate);
-      if (fs22.existsSync(globalPath) && !seen.has(globalPath)) {
+      const globalPath = path24.join(globalDir, candidate);
+      if (fs23.existsSync(globalPath) && !seen.has(globalPath)) {
         try {
-          if (fs22.statSync(globalPath).isFile()) {
+          if (fs23.statSync(globalPath).isFile()) {
             seen.add(globalPath);
-            const content = fs22.readFileSync(globalPath, "utf8").trim();
+            const content = fs23.readFileSync(globalPath, "utf8").trim();
             if (content) {
               collectedFiles.unshift({ path: globalPath, content });
             }
@@ -168099,7 +168850,7 @@ You operate across two environments seamlessly: locally via a terminal CLI, and
     `### Core Operating Principles & Guardrails
 1. Inspect Logs & Stack Traces First: NEVER diagnose errors or failures without fetching and reading full un-truncated error logs. Base diagnoses strictly on empirical log evidence.
 2. Root Cause Resolution: NEVER mask symptoms, swallow exceptions silently, use dummy fallbacks, or delete/comment out failing tests. Address the root cause directly.
-3. Execution & Verification: NEVER claim a task or fix is complete without running build, type-check, or test verification commands to empirically prove it works.
+3. Execution & Verification: NEVER claim a task or fix is complete without running build, type-check, or test verification commands to empirically prove it works. Do not run heavy build or test suites prematurely during early discovery before any code is modified. Target verification to the modified component rather than full monorepo rebuilds when possible. Once targeted verification succeeds and git diff confirms clean changes, conclude your turn promptly without redundant re-verification loops.
 4. Preserving Integrity: Always preserve existing docstrings, comments, and public API signatures unless explicitly asked to modify them.
 5. Absolute File Paths: ALWAYS specify absolute file paths when referencing, viewing, or editing files.
 6. Strict Workspace Boundary: All operations (file reads, writes, searches, bash commands) must be strictly confined within the workspace directory (/workspace or current working directory). NEVER inspect, explore, or search system root paths or directories outside the workspace (such as /etc, /root, /bin, /var).
@@ -168273,6 +169024,12 @@ var init_agent_harness = __esm(() => {
       guidelines: [
         "Use 'run_skill' to delegate complex procedural workflows or specialized domain tasks to an isolated subagent, keeping the main conversation context clean."
       ]
+    },
+    manage_memory: {
+      snippet: "Record, read, or prune persistent workspace rules and memories",
+      guidelines: [
+        "Use 'manage_memory' to record learned conventions, build/test commands, architecture notes, and quirks into persistent workspace memory."
+      ]
     }
   };
 });
@@ -168287,10 +169044,383 @@ var init_telemetry = __esm(() => {
   init_tracer_factory();
 });
 
+// ../../packages/agent/src/lsp-client.ts
+import { spawn as spawn3 } from "node:child_process";
+import fs24 from "node:fs";
+import path25 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+class LspClient {
+  workspaceRoot;
+  binaryPath;
+  requestTimeoutMs;
+  child = null;
+  nextId = 1;
+  pendingRequests = new Map;
+  buffer = Buffer.alloc(0);
+  diagnosticsByUri = new Map;
+  openedDocuments = new Set;
+  initPromise = null;
+  isShutdown = false;
+  constructor(options) {
+    this.workspaceRoot = path25.resolve(options.workspaceRoot);
+    this.binaryPath = options.binaryPath;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 15000;
+  }
+  async start() {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.initInternal();
+    return this.initPromise;
+  }
+  findBinary() {
+    if (this.binaryPath && fs24.existsSync(this.binaryPath)) {
+      return this.binaryPath;
+    }
+    const candidatePaths = [
+      path25.resolve(this.workspaceRoot, "node_modules/.bin/typescript-language-server"),
+      path25.resolve(process.cwd(), "node_modules/.bin/typescript-language-server"),
+      path25.resolve(process.cwd(), "node_modules/typescript-language-server/lib/cli.mjs")
+    ];
+    for (const candidate of candidatePaths) {
+      if (fs24.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return "typescript-language-server";
+  }
+  async initInternal() {
+    const bin = this.findBinary();
+    this.child = spawn3(bin, ["--stdio"], {
+      cwd: this.workspaceRoot,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child.stdout?.on("data", (chunk) => {
+      this.handleStdout(chunk);
+    });
+    this.child.stderr?.on("data", (_chunk) => {});
+    this.child.on("error", (err) => {
+      this.rejectAllPending(new Error(`LSP process error: ${err.message}`));
+    });
+    this.child.on("exit", (code) => {
+      this.rejectAllPending(new Error(`LSP process exited with code ${code}`));
+      this.child = null;
+      this.initPromise = null;
+    });
+    const rootUri = pathToFileURL(this.workspaceRoot).toString();
+    await this.sendRequest("initialize", {
+      processId: process.pid,
+      rootUri,
+      rootPath: this.workspaceRoot,
+      capabilities: {
+        textDocument: {
+          definition: { dynamicRegistration: false, linkSupport: true },
+          references: { dynamicRegistration: false },
+          documentSymbol: {
+            dynamicRegistration: false,
+            hierarchicalDocumentSymbolSupport: true
+          },
+          synchronization: {
+            dynamicRegistration: false,
+            willSave: false,
+            didSave: true
+          }
+        }
+      }
+    });
+    this.sendNotification("initialized", {});
+  }
+  handleStdout(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    while (true) {
+      const headerEnd = this.buffer.indexOf(`\r
+\r
+`);
+      if (headerEnd === -1)
+        break;
+      const headerStr = this.buffer.subarray(0, headerEnd).toString("utf8");
+      const match = headerStr.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.subarray(headerEnd + 4);
+        continue;
+      }
+      const contentLength = parseInt(match[1], 10);
+      const totalMsgLength = headerEnd + 4 + contentLength;
+      if (this.buffer.length < totalMsgLength)
+        break;
+      const body = this.buffer.subarray(headerEnd + 4, totalMsgLength).toString("utf8");
+      this.buffer = this.buffer.subarray(totalMsgLength);
+      try {
+        const msg = JSON.parse(body);
+        if (msg.id !== undefined && this.pendingRequests.has(msg.id)) {
+          const pending = this.pendingRequests.get(msg.id);
+          clearTimeout(pending.timeout);
+          this.pendingRequests.delete(msg.id);
+          if (msg.error) {
+            pending.reject(new Error(msg.error.message || "LSP error"));
+          } else {
+            pending.resolve(msg.result);
+          }
+        } else if (msg.method === "textDocument/publishDiagnostics") {
+          this.handlePublishDiagnostics(msg.params);
+        }
+      } catch {}
+    }
+  }
+  handlePublishDiagnostics(params) {
+    if (!params || !params.uri || !Array.isArray(params.diagnostics))
+      return;
+    const uri = params.uri;
+    const filePath = fileURLToPath(uri);
+    const items = params.diagnostics.map((d) => {
+      const sevNum = d.severity ?? 1;
+      const severity = sevNum === 1 ? "error" : sevNum === 2 ? "warning" : "info";
+      return {
+        filePath,
+        line: (d.range?.start?.line ?? 0) + 1,
+        column: (d.range?.start?.character ?? 0) + 1,
+        message: d.message || "",
+        severity,
+        source: d.source || "typescript"
+      };
+    });
+    this.diagnosticsByUri.set(uri, items);
+  }
+  sendRequest(method, params) {
+    if (!this.child || !this.child.stdin || this.isShutdown) {
+      return Promise.reject(new Error("LSP client is not running"));
+    }
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`LSP request "${method}" timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+      const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+      const header = `Content-Length: ${Buffer.byteLength(payload, "utf8")}\r
+\r
+`;
+      this.child?.stdin?.write(header + payload);
+    });
+  }
+  sendNotification(method, params) {
+    if (!this.child || !this.child.stdin || this.isShutdown)
+      return;
+    const payload = JSON.stringify({ jsonrpc: "2.0", method, params });
+    const header = `Content-Length: ${Buffer.byteLength(payload, "utf8")}\r
+\r
+`;
+    this.child.stdin.write(header + payload);
+  }
+  async openDocument(filePath, content) {
+    const absPath = path25.isAbsolute(filePath) ? filePath : path25.resolve(this.workspaceRoot, filePath);
+    const uri = pathToFileURL(absPath).toString();
+    if (this.openedDocuments.has(uri)) {
+      return uri;
+    }
+    let fileContent = content;
+    if (fileContent === undefined) {
+      try {
+        fileContent = fs24.readFileSync(absPath, "utf8");
+      } catch {
+        fileContent = "";
+      }
+    }
+    this.sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri,
+        languageId: "typescript",
+        version: 1,
+        text: fileContent
+      }
+    });
+    this.openedDocuments.add(uri);
+    return uri;
+  }
+  async getDefinition(filePath, line, column) {
+    const queryRawDefinition = async (targetFile, targetLine, targetCol) => {
+      await this.start();
+      const uri = await this.openDocument(targetFile);
+      const raw = await this.sendRequest("textDocument/definition", {
+        textDocument: { uri },
+        position: {
+          line: Math.max(0, targetLine - 1),
+          character: Math.max(0, targetCol - 1)
+        }
+      });
+      if (!raw)
+        return [];
+      const array = Array.isArray(raw) ? raw : [raw];
+      const locations = [];
+      for (const loc of array) {
+        const targetUri = loc.targetUri || loc.uri;
+        if (!targetUri)
+          continue;
+        const targetRange = loc.targetSelectionRange || loc.targetRange || loc.range;
+        const targetFilePath = fileURLToPath(targetUri);
+        locations.push({
+          filePath: targetFilePath,
+          line: (targetRange?.start?.line ?? 0) + 1,
+          column: (targetRange?.start?.character ?? 0) + 1
+        });
+      }
+      return locations;
+    };
+    const initial = await queryRawDefinition(filePath, line, column);
+    const resolved = [];
+    for (const loc of initial) {
+      try {
+        const content = fs24.readFileSync(loc.filePath, "utf8");
+        const lines = content.split(`
+`);
+        const lineContent = lines[loc.line - 1] || "";
+        if (/^\s*import\b/.test(lineContent)) {
+          const secondHop = await queryRawDefinition(loc.filePath, loc.line, loc.column);
+          if (secondHop.length > 0 && !(secondHop.length === 1 && secondHop[0].filePath === loc.filePath && secondHop[0].line === loc.line)) {
+            resolved.push(...secondHop);
+            continue;
+          }
+        }
+      } catch {}
+      resolved.push(loc);
+    }
+    return resolved;
+  }
+  async getReferences(filePath, line, column) {
+    await this.start();
+    const uri = await this.openDocument(filePath);
+    const raw = await this.sendRequest("textDocument/references", {
+      textDocument: { uri },
+      position: {
+        line: Math.max(0, line - 1),
+        character: Math.max(0, column - 1)
+      },
+      context: { includeDeclaration: true }
+    });
+    if (!raw || !Array.isArray(raw))
+      return [];
+    const locations = [];
+    for (const loc of raw) {
+      if (!loc.uri)
+        continue;
+      const targetFilePath = fileURLToPath(loc.uri);
+      locations.push({
+        filePath: targetFilePath,
+        line: (loc.range?.start?.line ?? 0) + 1,
+        column: (loc.range?.start?.character ?? 0) + 1
+      });
+    }
+    return locations;
+  }
+  async getOutline(filePath) {
+    await this.start();
+    const uri = await this.openDocument(filePath);
+    const raw = await this.sendRequest("textDocument/documentSymbol", {
+      textDocument: { uri }
+    });
+    if (!raw || !Array.isArray(raw))
+      return [];
+    const items = [];
+    const extractSymbols = (symbols, containerName) => {
+      for (const sym of symbols) {
+        const kindStr = SYMBOL_KINDS[sym.kind] || "symbol";
+        const range = sym.range || sym.location?.range;
+        const line = (range?.start?.line ?? 0) + 1;
+        const column = (range?.start?.character ?? 0) + 1;
+        items.push({
+          name: sym.name || "anonymous",
+          kind: kindStr,
+          line,
+          column,
+          containerName: sym.containerName || containerName
+        });
+        if (Array.isArray(sym.children) && sym.children.length > 0) {
+          extractSymbols(sym.children, sym.name);
+        }
+      }
+    };
+    extractSymbols(raw);
+    return items;
+  }
+  getDiagnostics(filePath) {
+    if (filePath) {
+      const absPath = path25.isAbsolute(filePath) ? filePath : path25.resolve(this.workspaceRoot, filePath);
+      const uri = pathToFileURL(absPath).toString();
+      return this.diagnosticsByUri.get(uri) || [];
+    }
+    const all = [];
+    for (const items of this.diagnosticsByUri.values()) {
+      all.push(...items);
+    }
+    return all;
+  }
+  async shutdown() {
+    if (this.isShutdown)
+      return;
+    this.isShutdown = true;
+    if (this.child) {
+      try {
+        await Promise.race([
+          this.sendRequest("shutdown", {}),
+          new Promise((r) => setTimeout(r, 500))
+        ]);
+        this.sendNotification("exit", {});
+      } catch {}
+      try {
+        this.child.kill("SIGTERM");
+      } catch {}
+      this.child = null;
+    }
+    this.rejectAllPending(new Error("LSP client shutdown"));
+  }
+  rejectAllPending(err) {
+    for (const [id, pending] of this.pendingRequests.entries()) {
+      clearTimeout(pending.timeout);
+      pending.reject(err);
+      this.pendingRequests.delete(id);
+    }
+  }
+}
+var SYMBOL_KINDS;
+var init_lsp_client = __esm(() => {
+  SYMBOL_KINDS = {
+    1: "file",
+    2: "module",
+    3: "namespace",
+    4: "package",
+    5: "class",
+    6: "method",
+    7: "property",
+    8: "field",
+    9: "constructor",
+    10: "enum",
+    11: "interface",
+    12: "function",
+    13: "variable",
+    14: "constant",
+    15: "string",
+    16: "number",
+    17: "boolean",
+    18: "array",
+    19: "object",
+    20: "key",
+    21: "null",
+    22: "enumMember",
+    23: "struct",
+    24: "event",
+    25: "operator",
+    26: "typeParameter"
+  };
+});
+
 // ../../packages/agent/src/index.ts
 var exports_src3 = {};
 __export(exports_src3, {
   AgentHarness: () => AgentHarness,
+  LspClient: () => LspClient,
   runAgentLoop: () => runAgentLoop
 });
 var init_src5 = __esm(() => {
@@ -168303,6 +169433,7 @@ var init_src5 = __esm(() => {
   init_telemetry();
   init_skill_subagent();
   init_run_skill_tool();
+  init_lsp_client();
 });
 
 // src/headless-runner.ts
@@ -168580,8 +169711,8 @@ var exports_file_session_repository = {};
 __export(exports_file_session_repository, {
   FileSessionRepository: () => FileSessionRepository
 });
-import fs23 from "node:fs/promises";
-import path23 from "node:path";
+import fs25 from "node:fs/promises";
+import path26 from "node:path";
 
 class FileSessionRepository {
   sessionDir;
@@ -168591,22 +169722,22 @@ class FileSessionRepository {
     if (sessionDir) {
       this.sessionDir = sessionDir;
     } else {
-      this.sessionDir = path23.join(getConfigDir(), "sessions");
-      const legacyDir = path23.join(getLegacyConfigDir(), "sessions");
+      this.sessionDir = path26.join(getConfigDir(), "sessions");
+      const legacyDir = path26.join(getLegacyConfigDir(), "sessions");
       if (legacyDir !== this.sessionDir) {
         this.legacySessionDir = legacyDir;
       }
     }
   }
   async saveContext(sessionId, messages) {
-    await fs23.mkdir(this.sessionDir, { recursive: true });
-    const historyPath = path23.join(this.sessionDir, `${sessionId}.jsonl`);
+    await fs25.mkdir(this.sessionDir, { recursive: true });
+    const historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
     let existing = this.sessionCache[sessionId];
     if (!existing) {
       existing = {};
       this.sessionCache[sessionId] = existing;
       try {
-        const data = await fs23.readFile(historyPath, "utf-8");
+        const data = await fs25.readFile(historyPath, "utf-8");
         const lines = data.split(`
 `).filter((l) => l.trim().length > 0);
         for (const l of lines) {
@@ -168630,19 +169761,19 @@ class FileSessionRepository {
       }
     }
     if (appendContent) {
-      await fs23.appendFile(historyPath, appendContent, "utf-8");
+      await fs25.appendFile(historyPath, appendContent, "utf-8");
     }
   }
   async loadContext(sessionId) {
-    let historyPath = path23.join(this.sessionDir, `${sessionId}.jsonl`);
+    let historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
     try {
       let data;
       try {
-        data = await fs23.readFile(historyPath, "utf-8");
+        data = await fs25.readFile(historyPath, "utf-8");
       } catch (err) {
         if (this.legacySessionDir) {
-          const legacyPath = path23.join(this.legacySessionDir, `${sessionId}.jsonl`);
-          data = await fs23.readFile(legacyPath, "utf-8");
+          const legacyPath = path26.join(this.legacySessionDir, `${sessionId}.jsonl`);
+          data = await fs25.readFile(legacyPath, "utf-8");
           historyPath = legacyPath;
         } else {
           throw err;
@@ -168683,7 +169814,7 @@ class FileSessionRepository {
       if (msgs.length < lines.length) {
         const compacted = msgs.map((m) => JSON.stringify(m)).join(`
 `);
-        await fs23.writeFile(historyPath, compacted, "utf-8").catch(() => {});
+        await fs25.writeFile(historyPath, compacted, "utf-8").catch(() => {});
       }
       const cacheObj = {};
       for (const msg of msgs) {
@@ -168697,12 +169828,12 @@ class FileSessionRepository {
   }
   async listSessions() {
     try {
-      await fs23.mkdir(this.sessionDir, { recursive: true });
+      await fs25.mkdir(this.sessionDir, { recursive: true });
       const sessions = [];
       const seenIds = new Set;
       const processDirectory = async (dirPath) => {
         try {
-          const dirFiles = await fs23.readdir(dirPath);
+          const dirFiles = await fs25.readdir(dirPath);
           for (const file of dirFiles) {
             if (!file.endsWith(".jsonl"))
               continue;
@@ -168710,10 +169841,10 @@ class FileSessionRepository {
             if (seenIds.has(id))
               continue;
             seenIds.add(id);
-            const filePath = path23.join(dirPath, file);
+            const filePath = path26.join(dirPath, file);
             try {
-              const stat = await fs23.stat(filePath);
-              const data = await fs23.readFile(filePath, "utf-8");
+              const stat = await fs25.stat(filePath);
+              const data = await fs25.readFile(filePath, "utf-8");
               const lines = data.split(`
 `).filter((l) => l.trim().length > 0);
               let preview = "";
@@ -168747,20 +169878,20 @@ class FileSessionRepository {
     }
   }
   async deleteSession(sessionId) {
-    const historyPath = path23.join(this.sessionDir, `${sessionId}.jsonl`);
+    const historyPath = path26.join(this.sessionDir, `${sessionId}.jsonl`);
     try {
-      await fs23.unlink(historyPath);
+      await fs25.unlink(historyPath);
     } catch (e) {}
     if (this.legacySessionDir) {
       try {
-        await fs23.unlink(path23.join(this.legacySessionDir, `${sessionId}.jsonl`));
+        await fs25.unlink(path26.join(this.legacySessionDir, `${sessionId}.jsonl`));
       } catch {}
     }
   }
   async renameSession(oldSessionId, newSessionId) {
-    const oldPath = path23.join(this.sessionDir, `${oldSessionId}.jsonl`);
-    const newPath = path23.join(this.sessionDir, `${newSessionId}.jsonl`);
-    await fs23.rename(oldPath, newPath);
+    const oldPath = path26.join(this.sessionDir, `${oldSessionId}.jsonl`);
+    const newPath = path26.join(this.sessionDir, `${newSessionId}.jsonl`);
+    await fs25.rename(oldPath, newPath);
   }
 }
 var init_file_session_repository = __esm(() => {
@@ -174394,21 +175525,53 @@ __export(exports_local_operations, {
   localOperations: () => localOperations,
   setActiveScopeDir: () => setActiveScopeDir
 });
-import { exec as exec4, spawn as spawn3 } from "node:child_process";
-import fs24 from "node:fs/promises";
-import path24 from "node:path";
+import { exec as exec4, spawn as spawn4 } from "node:child_process";
+import nodeFs from "node:fs";
+import fs26 from "node:fs/promises";
+import path27 from "node:path";
 import { promisify as promisify4 } from "node:util";
 function setActiveScopeDir(dir) {
   activeScopeDir = dir;
 }
 function getScopedCwd() {
   if (activeScopeDir) {
-    return path24.resolve(process.cwd(), activeScopeDir);
+    return path27.resolve(process.cwd(), activeScopeDir);
   }
   return process.cwd();
 }
-var import_fast_glob, execAsync2, localBashOps, activeScopeDir, SERVER_READY_REGEX, DEFAULT_BG_TIMEOUT_MS = 20000, DEFAULT_SERVER_READY_DELAY_MS = 2500, localOperations;
+function isTypeScriptProject(workspaceDir) {
+  return nodeFs.existsSync(path27.join(workspaceDir, "tsconfig.json")) || nodeFs.existsSync(path27.join(workspaceDir, "package.json"));
+}
+async function getOrLaunchLspClient(customWorkspaceDir) {
+  const workspaceDir = customWorkspaceDir || getScopedCwd();
+  if (activeLspClient && activeLspWorkspace === workspaceDir) {
+    return activeLspClient;
+  }
+  if (!isTypeScriptProject(workspaceDir)) {
+    return null;
+  }
+  if (activeLspClient) {
+    try {
+      await activeLspClient.shutdown();
+    } catch {}
+    activeLspClient = null;
+    activeLspWorkspace = null;
+  }
+  const client = new LspClient({ workspaceRoot: workspaceDir });
+  activeLspClient = client;
+  activeLspWorkspace = workspaceDir;
+  try {
+    await client.start();
+  } catch {
+    activeLspClient = null;
+    activeLspWorkspace = null;
+    return null;
+  }
+  return activeLspClient;
+}
+var import_fast_glob, execAsync2, localBashOps, activeScopeDir, SERVER_READY_REGEX, DEFAULT_BG_TIMEOUT_MS = 20000, DEFAULT_SERVER_READY_DELAY_MS = 2500, localOperations, activeLspClient = null, activeLspWorkspace = null;
 var init_local_operations = __esm(() => {
+  init_src5();
   init_src();
   init_src4();
   init_task_manager();
@@ -174424,7 +175587,7 @@ var init_local_operations = __esm(() => {
         const fallbackTimeoutMs = actualOptions.waitMsBeforeAsync ?? DEFAULT_BG_TIMEOUT_MS;
         const serverDelayMs = actualOptions.serverReadyDelayMs ?? DEFAULT_SERVER_READY_DELAY_MS;
         return new Promise((resolve, reject) => {
-          const child = spawn3(command, {
+          const child = spawn4(command, {
             cwd: targetCwd,
             detached: process.platform !== "win32",
             env: actualOptions.env ?? process.env,
@@ -174554,19 +175717,19 @@ Failed to start process: ${err?.message || err}
     fs: {
       readFile: async (filepath) => {
         const root = getScopedCwd();
-        const absolutePath = path24.isAbsolute(filepath) ? filepath : path24.resolve(root, filepath);
-        return fs24.readFile(absolutePath, "utf8");
+        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
+        return fs26.readFile(absolutePath, "utf8");
       },
       writeFile: async (filepath, content) => {
         const root = getScopedCwd();
-        const absolutePath = path24.isAbsolute(filepath) ? filepath : path24.resolve(root, filepath);
-        await fs24.mkdir(path24.dirname(absolutePath), { recursive: true });
-        await fs24.writeFile(absolutePath, content, "utf8");
+        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
+        await fs26.mkdir(path27.dirname(absolutePath), { recursive: true });
+        await fs26.writeFile(absolutePath, content, "utf8");
       },
       readdir: async (dirPath) => {
         const root = getScopedCwd();
-        const absolutePath = path24.isAbsolute(dirPath) ? dirPath : path24.resolve(root, dirPath);
-        const entries = await fs24.readdir(absolutePath, { withFileTypes: true });
+        const absolutePath = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
+        const entries = await fs26.readdir(absolutePath, { withFileTypes: true });
         const ignores = getWorkspaceIgnores(root);
         return entries.filter((entry) => !isPathIgnored(entry.name, ignores)).map((entry) => {
           const type = entry.isDirectory() ? "DIR " : "FILE";
@@ -174575,14 +175738,14 @@ Failed to start process: ${err?.message || err}
       },
       mkdir: async (dirPath, options) => {
         const root = getScopedCwd();
-        const absolutePath = path24.isAbsolute(dirPath) ? dirPath : path24.resolve(root, dirPath);
-        await fs24.mkdir(absolutePath, options);
+        const absolutePath = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
+        await fs26.mkdir(absolutePath, options);
       },
       exists: async (filepath) => {
         const root = getScopedCwd();
-        const absolutePath = path24.isAbsolute(filepath) ? filepath : path24.resolve(root, filepath);
+        const absolutePath = path27.isAbsolute(filepath) ? filepath : path27.resolve(root, filepath);
         try {
-          await fs24.access(absolutePath);
+          await fs26.access(absolutePath);
           return true;
         } catch {
           return false;
@@ -174592,7 +175755,7 @@ Failed to start process: ${err?.message || err}
     search: {
       find: async (dirPath, query) => {
         const root = getScopedCwd();
-        const targetDir = path24.isAbsolute(dirPath) ? dirPath : path24.resolve(root, dirPath);
+        const targetDir = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
         const ignores = getWorkspaceIgnores(root);
         const files = await import_fast_glob.default([query], {
           cwd: targetDir,
@@ -174604,10 +175767,11 @@ Failed to start process: ${err?.message || err}
       },
       grep: async (dirPath, query) => {
         const root = getScopedCwd();
-        const targetDir = path24.isAbsolute(dirPath) ? dirPath : path24.resolve(root, dirPath);
+        const targetDir = path27.isAbsolute(dirPath) ? dirPath : path27.resolve(root, dirPath);
         const ignores = getWorkspaceIgnores(root);
         try {
-          const cmd = `git grep -nI "${query}" ${targetDir} || grep -rnI --exclude-dir=node_modules --exclude-dir=.git "${query}" ${targetDir}`;
+          const escapedQuery = query.replace(/"/g, "\\\"");
+          const cmd = `git grep -nI "${escapedQuery}" -- ${targetDir} || grep -rnI --exclude-dir=node_modules --exclude-dir=.git "${escapedQuery}" ${targetDir}`;
           const { stdout } = await execAsync2(cmd);
           if (!stdout)
             return "";
@@ -174616,8 +175780,9 @@ Failed to start process: ${err?.message || err}
           const filtered = lines.filter((line) => {
             if (!line.trim())
               return false;
-            const filePath = line.split(":")[0];
-            return !isPathIgnored(filePath, ignores);
+            const rawPath = line.split(":")[0];
+            const relPath = path27.isAbsolute(rawPath) ? path27.relative(root, rawPath) : rawPath;
+            return !isPathIgnored(relPath, ignores);
           });
           return filtered.join(`
 `);
@@ -174658,8 +175823,56 @@ Failed to start process: ${err?.message || err}
           return { text: "", error: error.message };
         }
       }
+    },
+    diagnostics: {
+      getDiagnostics: async (filePath) => {
+        const client = await getOrLaunchLspClient();
+        if (!client)
+          return [];
+        return client.getDiagnostics(filePath);
+      }
+    },
+    lsp: {
+      getDefinition: async (filePath, line, column) => {
+        const client = await getOrLaunchLspClient();
+        if (!client)
+          return [];
+        return client.getDefinition(filePath, line, column);
+      },
+      getReferences: async (filePath, line, column) => {
+        const client = await getOrLaunchLspClient();
+        if (!client)
+          return [];
+        return client.getReferences(filePath, line, column);
+      },
+      getOutline: async (filePath) => {
+        const client = await getOrLaunchLspClient();
+        if (!client)
+          return [];
+        return client.getOutline(filePath);
+      },
+      getDiagnostics: async (filePath) => {
+        const client = await getOrLaunchLspClient();
+        if (!client)
+          return [];
+        return client.getDiagnostics(filePath);
+      },
+      shutdown: async () => {
+        if (activeLspClient) {
+          await activeLspClient.shutdown();
+          activeLspClient = null;
+          activeLspWorkspace = null;
+        }
+      }
     }
   };
+  process.on("exit", () => {
+    if (activeLspClient) {
+      try {
+        activeLspClient.shutdown();
+      } catch {}
+    }
+  });
 });
 
 // src/utils/provider-factory.ts
@@ -179011,7 +180224,7 @@ var init_wrap_ansi = __esm(() => {
 // ../../node_modules/.bun/terminal-size@4.0.1/node_modules/terminal-size/index.js
 import process3 from "node:process";
 import { execFileSync } from "node:child_process";
-import fs25 from "node:fs";
+import fs27 from "node:fs";
 import tty from "node:tty";
 function terminalSize() {
   const { env, stdout, stderr } = process3;
@@ -179059,7 +180272,7 @@ var defaultColumns = 80, defaultRows = 24, exec6 = (command, arguments_, { shell
     return true;
   }
   try {
-    const statContents = fs25.readFileSync("/proc/self/stat", "utf8");
+    const statContents = fs27.readFileSync("/proc/self/stat", "utf8");
     const closingParenthesisIndex = statContents.lastIndexOf(") ");
     if (closingParenthesisIndex === -1) {
       return false;
@@ -179079,8 +180292,8 @@ var defaultColumns = 80, defaultRows = 24, exec6 = (command, arguments_, { shell
   }
 }, devTty = () => {
   try {
-    const flags = process3.platform === "darwin" ? fs25.constants.O_EVTONLY | fs25.constants.O_NONBLOCK : fs25.constants.O_NONBLOCK;
-    const { columns, rows } = tty.WriteStream(fs25.openSync("/dev/tty", flags));
+    const flags = process3.platform === "darwin" ? fs27.constants.O_EVTONLY | fs27.constants.O_NONBLOCK : fs27.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs27.openSync("/dev/tty", flags));
     return { columns, rows };
   } catch {}
 }, tput = () => {
@@ -211282,7 +212495,7 @@ var init_Text = __esm(() => {
 });
 
 // ../../node_modules/.bun/ink@7.1.0+90ffd46201e3176f/node_modules/ink/build/components/ErrorOverview.js
-import * as fs26 from "node:fs";
+import * as fs28 from "node:fs";
 import { cwd } from "node:process";
 function ErrorOverview({ error }) {
   const stack = error.stack ? error.stack.split(`
@@ -211292,8 +212505,8 @@ function ErrorOverview({ error }) {
   let excerpt;
   let lineWidth = 0;
   const stackLineCounts = new Map;
-  if (filePath && origin?.line && fs26.existsSync(filePath)) {
-    const sourceCode = fs26.readFileSync(filePath, "utf8");
+  if (filePath && origin?.line && fs28.existsSync(filePath)) {
+    const sourceCode = fs28.readFileSync(filePath, "utf8");
     excerpt = dist_default4(sourceCode, origin.line);
     if (excerpt) {
       for (const { line } of excerpt) {
@@ -212724,7 +213937,7 @@ var init_render_to_string = __esm(async () => {
 });
 
 // ../../node_modules/.bun/ink@7.1.0+90ffd46201e3176f/node_modules/ink/build/components/Static.js
-function Static13(props) {
+function Static15(props) {
   const { items, children: render, style: customStyle } = props;
   const [index, setIndex] = import_react17.useState(0);
   const itemsToRender = import_react17.useMemo(() => {
@@ -213967,9 +215180,9 @@ var init_paste_manager = __esm(() => {
 });
 
 // ../../packages/tui/src/utils/prompt-history.ts
-import fs27 from "node:fs";
+import fs29 from "node:fs";
 import os15 from "node:os";
-import path25 from "node:path";
+import path28 from "node:path";
 
 class PromptHistory {
   historyPath;
@@ -213981,16 +215194,16 @@ class PromptHistory {
       this.historyPath = customPath;
     } else {
       const home = process.env.HOME || process.env.USERPROFILE || os15.homedir();
-      const canonicalPath = path25.join(home, ".december", "history");
-      const legacyPath = path25.join(home, ".config", "december", "history");
-      this.historyPath = fs27.existsSync(canonicalPath) || !fs27.existsSync(legacyPath) ? canonicalPath : legacyPath;
+      const canonicalPath = path28.join(home, ".december", "history");
+      const legacyPath = path28.join(home, ".config", "december", "history");
+      this.historyPath = fs29.existsSync(canonicalPath) || !fs29.existsSync(legacyPath) ? canonicalPath : legacyPath;
     }
     this.load();
   }
   load() {
     try {
-      if (fs27.existsSync(this.historyPath)) {
-        const raw = fs27.readFileSync(this.historyPath, "utf8");
+      if (fs29.existsSync(this.historyPath)) {
+        const raw = fs29.readFileSync(this.historyPath, "utf8");
         this.entries = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
       }
     } catch {
@@ -214006,11 +215219,11 @@ class PromptHistory {
     this.cursor = this.entries.length;
     this.currentDraft = "";
     try {
-      const dir = path25.dirname(this.historyPath);
-      if (!fs27.existsSync(dir)) {
-        fs27.mkdirSync(dir, { recursive: true });
+      const dir = path28.dirname(this.historyPath);
+      if (!fs29.existsSync(dir)) {
+        fs29.mkdirSync(dir, { recursive: true });
       }
-      fs27.appendFileSync(this.historyPath, trimmed + `
+      fs29.appendFileSync(this.historyPath, trimmed + `
 `, "utf8");
     } catch {}
   }
@@ -214074,16 +215287,16 @@ var init_clipboard = () => {};
 
 // ../../packages/tui/src/utils/handoff.ts
 import { exec as exec7 } from "node:child_process";
-import fs28 from "node:fs";
-import path26 from "node:path";
+import fs30 from "node:fs";
+import path29 from "node:path";
 import { promisify as promisify5 } from "node:util";
 function getHandoffExcludes(baseDir = process.cwd()) {
   const excludes = [...MANDATORY_HANDOFF_EXCLUDES];
   const readIgnoreFile = (fileName) => {
-    const filePath = path26.join(baseDir, fileName);
+    const filePath = path29.join(baseDir, fileName);
     try {
-      if (fs28.existsSync(filePath)) {
-        const lines = fs28.readFileSync(filePath, "utf8").split(`
+      if (fs30.existsSync(filePath)) {
+        const lines = fs30.readFileSync(filePath, "utf8").split(`
 `);
         for (const line of lines) {
           const trimmed = line.trim();
@@ -214152,9 +215365,9 @@ var init_handoff = __esm(() => {
 });
 
 // ../../packages/tui/src/components/command-menu/commands.tsx
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 import os17 from "node:os";
-import path27 from "node:path";
+import path30 from "node:path";
 var COMMANDS;
 var init_commands2 = __esm(() => {
   init_clipboard();
@@ -214258,13 +215471,13 @@ var init_commands2 = __esm(() => {
         const archivePath = ".december-handoff.tar.gz";
         try {
           const home = process.env.HOME || process.env.USERPROFILE || os17.homedir();
-          const canonicalConfigPath = path27.join(home, ".december", "config.json");
-          const legacyConfigPath = path27.join(home, ".config", "december", "config.json");
-          const configPath = fs29.existsSync(canonicalConfigPath) || !fs29.existsSync(legacyConfigPath) ? canonicalConfigPath : legacyConfigPath;
+          const canonicalConfigPath = path30.join(home, ".december", "config.json");
+          const legacyConfigPath = path30.join(home, ".config", "december", "config.json");
+          const configPath = fs31.existsSync(canonicalConfigPath) || !fs31.existsSync(legacyConfigPath) ? canonicalConfigPath : legacyConfigPath;
           let config = {};
           try {
-            if (fs29.existsSync(configPath)) {
-              config = JSON.parse(fs29.readFileSync(configPath, "utf8"));
+            if (fs31.existsSync(configPath)) {
+              config = JSON.parse(fs31.readFileSync(configPath, "utf8"));
             }
           } catch {}
           if (!config.decemberToken) {
@@ -214299,7 +215512,7 @@ var init_commands2 = __esm(() => {
             headers: { Authorization: `Bearer ${config.decemberToken}` }
           });
           if (!urlRes.ok) {
-            await fs29.promises.unlink(archivePath).catch(() => {});
+            await fs31.promises.unlink(archivePath).catch(() => {});
             if (urlRes.status === 401) {
               ctx.toast.show({
                 variant: "error",
@@ -214320,7 +215533,7 @@ var init_commands2 = __esm(() => {
           const urlJson = await urlRes.json();
           const { uploadUrl, objectKey } = urlJson.data || urlJson;
           ctx.toast.show({ variant: "info", message: "Uploading to MinIO..." });
-          const fileData = await fs29.promises.readFile(archivePath);
+          const fileData = await fs31.promises.readFile(archivePath);
           const uploadRes = await fetch(uploadUrl, {
             method: "PUT",
             body: fileData
@@ -214344,11 +215557,11 @@ var init_commands2 = __esm(() => {
             const errJson = await sessionRes.json().catch(() => ({}));
             throw new Error(errJson.message || await sessionRes.text());
           }
-          await fs29.promises.unlink(archivePath).catch(() => {});
+          await fs31.promises.unlink(archivePath).catch(() => {});
           ctx.toast.show({ variant: "success", message: "Handoff complete! Exiting in 3s." });
           setTimeout(() => ctx.exit(), 3000);
         } catch (e) {
-          await fs29.promises.unlink(archivePath).catch(() => {});
+          await fs31.promises.unlink(archivePath).catch(() => {});
           ctx.toast.show({ variant: "error", message: `Handoff failed: ${e.message}` });
         }
       }
@@ -215746,6 +216959,8 @@ var init_input_bar = __esm(async () => {
             showExitConfirm ? /* @__PURE__ */ jsx_runtime8.jsx(Box_default, {
               width: "100%",
               justifyContent: "space-between",
+              height: 1,
+              overflow: "hidden",
               children: /* @__PURE__ */ jsx_runtime8.jsx(Box_default, {
                 gap: 2,
                 alignItems: "center",
@@ -215762,6 +216977,7 @@ var init_input_bar = __esm(async () => {
                     ]
                   }) : /* @__PURE__ */ jsx_runtime8.jsx(Text3, {
                     color: THEME.colors.muted,
+                    wrap: "truncate",
                     children: "· Press Ctrl+C again to exit"
                   })
                 })
@@ -215769,6 +216985,8 @@ var init_input_bar = __esm(async () => {
             }) : /* @__PURE__ */ jsx_runtime8.jsxs(Box_default, {
               width: "100%",
               justifyContent: "space-between",
+              height: 1,
+              overflow: "hidden",
               children: [
                 /* @__PURE__ */ jsx_runtime8.jsx(Box_default, {
                   gap: 2,
@@ -215780,6 +216998,7 @@ var init_input_bar = __esm(async () => {
                     children: [
                       /* @__PURE__ */ jsx_runtime8.jsxs(Text3, {
                         color: THEME.colors.muted,
+                        wrap: "truncate",
                         children: [
                           activeModeTag ? /* @__PURE__ */ jsx_runtime8.jsxs(Text3, {
                             color: THEME.colors.brand,
@@ -215793,6 +217012,7 @@ var init_input_bar = __esm(async () => {
                         ]
                       }),
                       totalTasksCount > 0 && /* @__PURE__ */ jsx_runtime8.jsxs(Text3, {
+                        wrap: "truncate",
                         color: runningTasksCount > 0 ? THEME.colors.warning : THEME.colors.muted,
                         children: [
                           "·",
@@ -215819,6 +217039,7 @@ var init_input_bar = __esm(async () => {
                   marginLeft: 2,
                   children: /* @__PURE__ */ jsx_runtime8.jsx(Text3, {
                     color: contextColor,
+                    wrap: "truncate",
                     children: contextLabel
                   })
                 })
@@ -215849,7 +217070,7 @@ var init_scroll_viewport = __esm(async () => {
   }, ref) {
     const viewportRef = import_react43.useRef(null);
     const contentRef = import_react43.useRef(null);
-    const defaultHeight = explicitHeight ?? (typeof process !== "undefined" && process.stdout?.rows ? Math.max(10, process.stdout.rows - 6) : 24);
+    const defaultHeight = explicitHeight ?? (typeof process !== "undefined" && process.stdout?.rows ? Math.max(1, process.stdout.rows - 6) : 24);
     const [viewportHeight, setViewportHeight] = import_react43.useState(defaultHeight);
     const [contentHeight, setContentHeight] = import_react43.useState(0);
     const [internalScrollTop, setInternalScrollTop] = import_react43.useState(0);
@@ -215923,6 +217144,8 @@ var init_scroll_viewport = __esm(async () => {
       const newTop = Math.max(0, currentTop - delta);
       setIsReadingMode(newTop < currentMax);
       setInternalScrollTop(newTop);
+      stateRef.current.isReadingMode = newTop < currentMax;
+      stateRef.current.internalScrollTop = newTop;
       notifyStateChange(newTop);
     }, [notifyStateChange]);
     const handleScrollDown = import_react43.useCallback((delta) => {
@@ -215932,9 +217155,12 @@ var init_scroll_viewport = __esm(async () => {
       if (newTop >= currentMax) {
         setIsReadingMode(false);
         setInternalScrollTop(currentMax);
+        stateRef.current.isReadingMode = false;
+        stateRef.current.internalScrollTop = currentMax;
         notifyStateChange(currentMax);
       } else {
         setInternalScrollTop(newTop);
+        stateRef.current.internalScrollTop = newTop;
         notifyStateChange(newTop);
       }
     }, [notifyStateChange]);
@@ -215942,12 +217168,16 @@ var init_scroll_viewport = __esm(async () => {
       const currentMax = stateRef.current.maxScrollTop;
       setIsReadingMode(currentMax > 0);
       setInternalScrollTop(0);
+      stateRef.current.isReadingMode = currentMax > 0;
+      stateRef.current.internalScrollTop = 0;
       notifyStateChange(0);
     }, [notifyStateChange]);
     const handleScrollToBottom = import_react43.useCallback(() => {
       const currentMax = stateRef.current.maxScrollTop;
       setIsReadingMode(false);
       setInternalScrollTop(currentMax);
+      stateRef.current.isReadingMode = false;
+      stateRef.current.internalScrollTop = currentMax;
       notifyStateChange(currentMax);
     }, [notifyStateChange]);
     import_react43.default.useImperativeHandle(ref, () => ({
@@ -216002,6 +217232,7 @@ var init_scroll_viewport = __esm(async () => {
       height: explicitHeight,
       flexGrow: 1,
       flexShrink: 1,
+      minHeight: 0,
       overflowY: "hidden",
       flexDirection: "column",
       width: "100%",
@@ -216023,7 +217254,7 @@ var init_scroll_viewport = __esm(async () => {
 });
 
 // ../../packages/tui/src/utils/terminal-link.ts
-import path28 from "node:path";
+import path31 from "node:path";
 function terminalLink(text, uri) {
   if (!uri)
     return text;
@@ -216032,7 +217263,7 @@ function terminalLink(text, uri) {
 function fileLink(displayPath, targetPath, line, col) {
   if (!targetPath)
     return displayPath;
-  const absPath = path28.isAbsolute(targetPath) ? targetPath : path28.resolve(process.cwd(), targetPath);
+  const absPath = path31.isAbsolute(targetPath) ? targetPath : path31.resolve(process.cwd(), targetPath);
   const lineFragment = line ? `#L${line}${col ? `:${col}` : ""}` : "";
   const uri = `file://${absPath}${lineFragment}`;
   return terminalLink(displayPath, uri);
@@ -216041,9 +217272,9 @@ function toRelativePath(filePath, cwd = process.cwd()) {
   if (!filePath)
     return "";
   const trimmed = filePath.trim();
-  if (!path28.isAbsolute(trimmed))
+  if (!path31.isAbsolute(trimmed))
     return trimmed;
-  const rel = path28.relative(cwd, trimmed);
+  const rel = path31.relative(cwd, trimmed);
   if (!rel || rel.startsWith("..")) {
     return trimmed;
   }
@@ -216097,7 +217328,10 @@ var import_react44, jsx_runtime10, DiffGutterView;
 var init_diff_gutter = __esm(async () => {
   init_theme();
   init_terminal_link();
-  await init_build2();
+  await __promiseAll([
+    init_build2(),
+    init_use_terminal_columns()
+  ]);
   import_react44 = __toESM(require_react(), 1);
   jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
   DiffGutterView = import_react44.default.memo(function DiffGutterView({
@@ -216116,8 +217350,12 @@ var init_diff_gutter = __esm(async () => {
     const isTruncated = isExpanded && parsedLines.length > maxVisibleLines;
     const maxLineNum = Math.max(...parsedLines.map((l) => Math.max(l.oldLineNumber || 0, l.newLineNumber || 0)), 1);
     const gutterWidth = Math.max(2, String(maxLineNum).length);
-    const displayPath = filePath ? filePath.replace(/^\.\//, "") : "";
-    const linkedPath = displayPath ? fileLink(displayPath, displayPath, startLine) : "";
+    const columns = useTerminalColumns();
+    const maxPathLen = Math.max(30, columns - 45);
+    const cleanPath = filePath ? filePath.replace(/^\.\//, "") : "";
+    const displayPath = cleanPath ? toRelativePath(cleanPath) : "";
+    const truncatedDisplay = displayPath.length > maxPathLen ? displayPath.substring(0, maxPathLen - 3) + "..." : displayPath;
+    const linkedPath = displayPath ? fileLink(truncatedDisplay, filePath || displayPath, startLine) : "";
     return /* @__PURE__ */ jsx_runtime10.jsxs(Box_default, {
       flexDirection: "column",
       marginY: 0,
@@ -216127,14 +217365,18 @@ var init_diff_gutter = __esm(async () => {
           gap: 1,
           alignItems: "center",
           children: [
-            /* @__PURE__ */ jsx_runtime10.jsx(Text3, {
-              color: THEME.colors.warning,
-              children: `${THEME.glyphs.status} `
-            }),
-            /* @__PURE__ */ jsx_runtime10.jsx(Text3, {
-              color: THEME.colors.warning,
-              bold: true,
-              children: actionLabel
+            /* @__PURE__ */ jsx_runtime10.jsxs(Text3, {
+              children: [
+                /* @__PURE__ */ jsx_runtime10.jsx(Text3, {
+                  color: THEME.colors.warning,
+                  children: `${THEME.glyphs.status} `
+                }),
+                /* @__PURE__ */ jsx_runtime10.jsx(Text3, {
+                  color: THEME.colors.warning,
+                  bold: true,
+                  children: actionLabel
+                })
+              ]
             }),
             displayPath && /* @__PURE__ */ jsx_runtime10.jsx(Text3, {
               color: THEME.colors.text,
@@ -216161,6 +217403,7 @@ var init_diff_gutter = __esm(async () => {
             }),
             /* @__PURE__ */ jsx_runtime10.jsxs(Text3, {
               color: THEME.colors.muted,
+              wrap: "truncate",
               children: [
                 "(",
                 isExpanded ? "ctrl+o to collapse" : "ctrl+o to view",
@@ -261585,17 +262828,19 @@ function CollapsibleThought({
   });
 }
 function StyledCommand({ command, truncate = true }) {
+  const columns = useTerminalColumns();
+  const maxArgLength = Math.max(40, columns - 38);
   const match = command.match(/^([A-Za-z_]+)\(([\s\S]*)\)$/);
   if (match) {
     const args = (match[2] || "").replace(/\r?\n/g, " ");
     const toolName = match[1];
     let displayArgs = args;
-    if (truncate && displayArgs.length > 80) {
-      displayArgs = displayArgs.substring(0, 80) + "...";
-    }
     if ((toolName === "read_file" || toolName === "view_file" || toolName === "Read") && args && !args.includes(" ")) {
-      const rel = toRelativePath(displayArgs);
-      displayArgs = fileLink(rel, args);
+      const rel = toRelativePath(args);
+      const truncatedRel = truncate && rel.length > maxArgLength ? rel.substring(0, maxArgLength - 3) + "..." : rel;
+      displayArgs = fileLink(truncatedRel, args);
+    } else if (truncate && displayArgs.length > maxArgLength) {
+      displayArgs = displayArgs.substring(0, maxArgLength - 3) + "...";
     }
     const cmdColor = THEME.colors.warning;
     return /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
@@ -261621,8 +262866,8 @@ function StyledCommand({ command, truncate = true }) {
     });
   }
   let displayCmd = command.replace(/\r?\n/g, " ");
-  if (truncate && displayCmd.length > 80) {
-    displayCmd = displayCmd.substring(0, 80) + "...";
+  if (truncate && displayCmd.length > maxArgLength) {
+    displayCmd = displayCmd.substring(0, maxArgLength - 3) + "...";
   }
   return /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
     color: THEME.colors.text,
@@ -261633,17 +262878,19 @@ function StyledRunningCommand({
   command,
   truncate = true
 }) {
+  const columns = useTerminalColumns();
+  const maxArgLength = Math.max(40, columns - 38);
   const match = command.match(/^([A-Za-z_]+)\(([\s\S]*)\)$/);
   if (match) {
     const args = (match[2] || "").replace(/\r?\n/g, " ");
     const toolName = match[1];
     let displayArgs = args;
-    if (truncate && displayArgs.length > 80) {
-      displayArgs = displayArgs.substring(0, 80) + "...";
-    }
     if ((toolName === "read_file" || toolName === "view_file" || toolName === "Read") && args && !args.includes(" ")) {
-      const rel = toRelativePath(displayArgs);
-      displayArgs = fileLink(rel, args);
+      const rel = toRelativePath(args);
+      const truncatedRel = truncate && rel.length > maxArgLength ? rel.substring(0, maxArgLength - 3) + "..." : rel;
+      displayArgs = fileLink(truncatedRel, args);
+    } else if (truncate && displayArgs.length > maxArgLength) {
+      displayArgs = displayArgs.substring(0, maxArgLength - 3) + "...";
     }
     const cmdColor = THEME.colors.warning;
     return /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
@@ -261665,8 +262912,8 @@ function StyledRunningCommand({
     });
   }
   let displayCmd = command.replace(/\r?\n/g, " ");
-  if (truncate && displayCmd.length > 80) {
-    displayCmd = displayCmd.substring(0, 80) + "...";
+  if (truncate && displayCmd.length > maxArgLength) {
+    displayCmd = displayCmd.substring(0, maxArgLength - 3) + "...";
   }
   return /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
     color: THEME.colors.text,
@@ -261696,6 +262943,7 @@ function CollapsibleCommandOutput({
           }),
           lines.length > 0 && /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
             color: THEME.colors.muted,
+            wrap: "truncate",
             children: [
               "(",
               isExpanded ? "ctrl+o to collapse" : "ctrl+o to expand",
@@ -261762,22 +263010,56 @@ function getReadBlockPath(block) {
   const rel = toRelativePath(rawPath);
   return { display: rel || rawPath, target: rawPath };
 }
+function formatConsolidatedReadArgs(paths, maxArgLength) {
+  const count = paths.length;
+  if (count === 0)
+    return "";
+  if (count === 1) {
+    const p0 = paths[0];
+    const label = p0.display.length > maxArgLength ? p0.display.substring(0, Math.max(10, maxArgLength - 3)) + "..." : p0.display;
+    return fileLink(label, p0.target);
+  }
+  if (count === 2) {
+    const p0 = paths[0];
+    const p1 = paths[1];
+    if (p0.display.length + 2 + p1.display.length <= maxArgLength) {
+      return `${fileLink(p0.display, p0.target)}, ${fileLink(p1.display, p1.target)}`;
+    }
+    const remainingForP1 = maxArgLength - (p0.display.length + 2);
+    if (remainingForP1 >= 8) {
+      const truncatedP1 = p1.display.substring(0, remainingForP1 - 3) + "...";
+      return `${fileLink(p0.display, p0.target)}, ${fileLink(truncatedP1, p1.target)}`;
+    }
+    const truncatedP0 = p0.display.length > maxArgLength - 6 ? p0.display.substring(0, Math.max(10, maxArgLength - 9)) + "..." : p0.display;
+    return `${fileLink(truncatedP0, p0.target)}, ...`;
+  }
+  const p0 = paths[0];
+  const p1 = paths[1];
+  const suffixTwo = `, +${count - 2} more`;
+  if (p0.display.length + 2 + p1.display.length + suffixTwo.length <= maxArgLength) {
+    return `${fileLink(p0.display, p0.target)}, ${fileLink(p1.display, p1.target)}${suffixTwo}`;
+  }
+  const remainingForP1 = maxArgLength - (p0.display.length + 2 + suffixTwo.length);
+  if (remainingForP1 >= 8) {
+    const truncatedP1 = p1.display.substring(0, remainingForP1 - 3) + "...";
+    return `${fileLink(p0.display, p0.target)}, ${fileLink(truncatedP1, p1.target)}${suffixTwo}`;
+  }
+  const suffixOne = `, +${count - 1} more`;
+  const remainingForP0 = maxArgLength - suffixOne.length;
+  const label0 = p0.display.length > remainingForP0 ? p0.display.substring(0, Math.max(10, remainingForP0 - 3)) + "..." : p0.display;
+  return `${fileLink(label0, p0.target)}${suffixOne}`;
+}
 function ConsolidatedReadsView({
   blocks,
   forceExpanded,
   isLastBlock
 }) {
   const isExpanded = forceExpanded ?? false;
+  const columns = useTerminalColumns();
+  const maxArgLength = Math.max(40, columns - 38);
   const paths = blocks.map(getReadBlockPath);
   const count = paths.length;
-  let inlineArgs = "";
-  if (count === 2) {
-    inlineArgs = `${fileLink(paths[0].display, paths[0].target)}, ${fileLink(paths[1].display, paths[1].target)}`;
-  } else if (count > 2) {
-    inlineArgs = `${fileLink(paths[0].display, paths[0].target)}, ${fileLink(paths[1].display, paths[1].target)}, +${count - 2} more`;
-  } else if (count === 1) {
-    inlineArgs = fileLink(paths[0].display, paths[0].target);
-  }
+  const inlineArgs = formatConsolidatedReadArgs(paths, maxArgLength);
   const cmdColor = THEME.colors.warning;
   const isRunning = blocks.some((b) => b.status === "running");
   if (isRunning) {
@@ -261822,11 +263104,19 @@ function ConsolidatedReadsView({
               alignItems: "center",
               gap: 1,
               children: [
-                fileRunning ? /* @__PURE__ */ jsx_runtime17.jsx(Spinner2, {}) : /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
-                  color: cmdColor,
-                  children: `${THEME.glyphs.status} `
+                fileRunning ? /* @__PURE__ */ jsx_runtime17.jsx(Spinner2, {}) : /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
+                  children: [
+                    /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
+                      color: cmdColor,
+                      children: `${THEME.glyphs.status} `
+                    }),
+                    /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
+                      color: THEME.colors.muted,
+                      children: fileLink(p.display, p.target)
+                    })
+                  ]
                 }),
-                /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
+                fileRunning && /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
                   color: THEME.colors.muted,
                   children: fileLink(p.display, p.target)
                 })
@@ -261868,6 +263158,7 @@ function ConsolidatedReadsView({
           }),
           /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
             color: THEME.colors.muted,
+            wrap: "truncate",
             children: [
               "(",
               isExpanded ? "ctrl+o to collapse" : "ctrl+o to expand",
@@ -261951,6 +263242,7 @@ var init_bot_message = __esm(async () => {
   init_terminal_link();
   await __promiseAll([
     init_build2(),
+    init_use_terminal_columns(),
     init_diff_gutter(),
     init_inline_tip(),
     init_spinner(),
@@ -262300,14 +263592,18 @@ ${r}`;
               gap: 1,
               alignItems: "center",
               children: [
-                /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
-                  color: THEME.colors.warning,
-                  children: `${THEME.glyphs.status} `
-                }),
-                /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
-                  color: THEME.colors.warning,
-                  bold: true,
-                  children: actionLabel
+                /* @__PURE__ */ jsx_runtime17.jsxs(Text3, {
+                  children: [
+                    /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
+                      color: THEME.colors.warning,
+                      children: `${THEME.glyphs.status} `
+                    }),
+                    /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
+                      color: THEME.colors.warning,
+                      bold: true,
+                      children: actionLabel
+                    })
+                  ]
                 }),
                 /* @__PURE__ */ jsx_runtime17.jsx(Text3, {
                   color: THEME.colors.muted,
@@ -262346,27 +263642,27 @@ ${r}`;
 });
 
 // ../../packages/tui/src/components/header.tsx
-import fs30 from "node:fs";
+import fs32 from "node:fs";
 import { homedir } from "node:os";
-import path29 from "node:path";
+import path32 from "node:path";
 function getGitBranch(workspaceRoot = process.cwd()) {
   if (cachedBranch !== undefined) {
     return cachedBranch;
   }
   try {
-    const gitPath = path29.resolve(workspaceRoot, ".git");
-    if (fs30.existsSync(gitPath)) {
-      const stat = fs30.statSync(gitPath);
-      let headPath = path29.resolve(gitPath, "HEAD");
+    const gitPath = path32.resolve(workspaceRoot, ".git");
+    if (fs32.existsSync(gitPath)) {
+      const stat = fs32.statSync(gitPath);
+      let headPath = path32.resolve(gitPath, "HEAD");
       if (stat.isFile()) {
-        const content = fs30.readFileSync(gitPath, "utf-8").trim();
+        const content = fs32.readFileSync(gitPath, "utf-8").trim();
         if (content.startsWith("gitdir:")) {
           const gitDir = content.slice(7).trim();
-          headPath = path29.resolve(workspaceRoot, gitDir, "HEAD");
+          headPath = path32.resolve(workspaceRoot, gitDir, "HEAD");
         }
       }
-      if (fs30.existsSync(headPath)) {
-        const headContent = fs30.readFileSync(headPath, "utf-8").trim();
+      if (fs32.existsSync(headPath)) {
+        const headContent = fs32.readFileSync(headPath, "utf-8").trim();
         if (headContent.startsWith("ref: refs/heads/")) {
           cachedBranch = headContent.replace("ref: refs/heads/", "").trim();
           return cachedBranch;
@@ -262640,11 +263936,11 @@ var init_message_list = __esm(async () => {
       flexDirection: "column",
       width: "100%",
       children: [
-        staticMessages.length > 0 && /* @__PURE__ */ jsx_runtime20.jsx(Static13, {
+        staticMessages.length > 0 && /* @__PURE__ */ jsx_runtime20.jsx(Static15, {
           items: staticMessages,
           style: { width: "100%" },
           children: (msg, index) => renderSingleMessage(msg, index, staticMessages, cliVersion, latestVersion, userEmail, expandCommands, announcement)
-        }, `${staticKey}-${expandCommands}`),
+        }, staticKey),
         activeMessages.map((msg, index) => renderSingleMessage(msg, staticMessages.length + index, [...staticMessages, ...activeMessages], cliVersion, latestVersion, userEmail, expandCommands, announcement))
       ]
     });
@@ -267729,17 +269025,17 @@ var init_global_shortcuts = __esm(async () => {
 
 // ../../packages/tui/src/utils/pager.ts
 import * as cp3 from "node:child_process";
-import fs31 from "node:fs";
+import fs33 from "node:fs";
 import os18 from "node:os";
-import path30 from "node:path";
+import path33 from "node:path";
 function openPlanInPager(planText, title = "december-plan") {
   if (Boolean(process.env.BUN_TEST) || Boolean(process.env.VITEST)) {
     return Promise.resolve();
   }
   return new Promise((resolve) => {
     try {
-      const tmpFile = path30.join(os18.tmpdir(), `${title}-${Date.now()}.md`);
-      fs31.writeFileSync(tmpFile, planText, "utf8");
+      const tmpFile = path33.join(os18.tmpdir(), `${title}-${Date.now()}.md`);
+      fs33.writeFileSync(tmpFile, planText, "utf8");
       const pager = process.env.PAGER || process.env.EDITOR || (os18.platform() === "win32" ? "notepad" : "less -R");
       const child = cp3.spawn(pager, [tmpFile], {
         stdio: "inherit",
@@ -267747,7 +269043,7 @@ function openPlanInPager(planText, title = "december-plan") {
       });
       child.on("exit", () => {
         try {
-          fs31.unlinkSync(tmpFile);
+          fs33.unlinkSync(tmpFile);
         } catch {}
         resolve();
       });
@@ -267823,6 +269119,19 @@ function ChatApp({
       }
     };
   }, []);
+  import_react69.useEffect(() => {
+    if (!process.stdout?.isTTY || isInline)
+      return;
+    const handleResize = () => {
+      try {
+        process.stdout.write("\x1B[2J\x1B[H");
+      } catch {}
+    };
+    process.stdout.on("resize", handleResize);
+    return () => {
+      process.stdout.off("resize", handleResize);
+    };
+  }, [isInline]);
   use_input_default((input, key) => {
     if (key.ctrl && input === "c") {
       handleInterrupt();
@@ -268304,8 +269613,8 @@ var init_store = __esm(() => {
 
 // src/store/interceptors.ts
 import { execSync as execSync2 } from "node:child_process";
-import fs32 from "node:fs/promises";
-import path31 from "node:path";
+import fs34 from "node:fs/promises";
+import path34 from "node:path";
 async function computeToolCallDiff(toolCall) {
   if (toolCall.input?.diff) {
     return toolCall.input.diff;
@@ -268314,11 +269623,11 @@ async function computeToolCallDiff(toolCall) {
   if (!targetPath)
     return;
   const cwd = process.cwd();
-  const resolved = path31.resolve(cwd, targetPath);
-  const relative = path31.relative(cwd, resolved);
+  const resolved = path34.resolve(cwd, targetPath);
+  const relative = path34.relative(cwd, resolved);
   let oldContent = "";
   try {
-    oldContent = await fs32.readFile(resolved, "utf-8");
+    oldContent = await fs34.readFile(resolved, "utf-8");
   } catch {}
   if (toolCall.name === "write_to_file" || toolCall.name === "write") {
     const newContent = toolCall.input?.CodeContent ?? toolCall.input?.content ?? "";
@@ -268382,9 +269691,9 @@ function setupAgentInterceptors(agent, storeState) {
       ];
       if (fileTools.includes(toolCall.name)) {
         const cwd = process.cwd();
-        const resolved = path31.resolve(cwd, targetPath);
-        const relative = path31.relative(cwd, resolved);
-        const isOutside = relative.startsWith("..") || path31.isAbsolute(relative);
+        const resolved = path34.resolve(cwd, targetPath);
+        const relative = path34.relative(cwd, resolved);
+        const isOutside = relative.startsWith("..") || path34.isAbsolute(relative);
         if (!config.nonWorkspaceAccess && isOutside) {
           return {
             block: true,
@@ -268448,8 +269757,8 @@ function setupAgentInterceptors(agent, storeState) {
       const targetPath = toolCall.input?.TargetFile || toolCall.input?.AbsolutePath || toolCall.input?.filePath || toolCall.input?.path;
       if (targetPath) {
         const cwd = process.cwd();
-        const resolved = path31.resolve(cwd, targetPath);
-        const relative = path31.relative(cwd, resolved);
+        const resolved = path34.resolve(cwd, targetPath);
+        const relative = path34.relative(cwd, resolved);
         try {
           execSync2(`git ls-files --error-unmatch "${relative}"`, {
             cwd,
@@ -268476,7 +269785,7 @@ var init_interceptors = __esm(() => {
 });
 
 // src/utils/direct-shell.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 function startDirectCommand(command, options = {}) {
   const { timeoutMs = 20000, serverReadyDelayMs = 2500, onData, onBackground } = options;
   let output = "";
@@ -268486,7 +269795,7 @@ function startDirectCommand(command, options = {}) {
   const isWindows = process.platform === "win32";
   const shellCmd = isWindows ? "cmd.exe" : "/bin/bash";
   const shellArgs = isWindows ? ["/d", "/s", "/c", command] : ["-c", command];
-  const child = spawn5(shellCmd, shellArgs, {
+  const child = spawn6(shellCmd, shellArgs, {
     cwd: process.cwd(),
     env: process.env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -268638,15 +269947,15 @@ var init_direct_shell = __esm(() => {
 });
 
 // src/utils/usage-tracker.ts
-import fs33 from "node:fs/promises";
-import path32 from "node:path";
+import fs35 from "node:fs/promises";
+import path35 from "node:path";
 function getUsageFilePath() {
-  return path32.join(getConfigDir(), "usage.json");
+  return path35.join(getConfigDir(), "usage.json");
 }
 async function loadUsageLedger() {
   const filePath = getUsageFilePath();
   try {
-    const raw = await fs33.readFile(filePath, "utf-8");
+    const raw = await fs35.readFile(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.version === 1 && parsed.days) {
       return parsed;
@@ -268659,8 +269968,8 @@ async function loadUsageLedger() {
 }
 async function saveUsageLedger(ledger) {
   const configDir = getConfigDir();
-  const filePath = path32.join(configDir, "usage.json");
-  const tmpPath = path32.join(configDir, `usage.json.tmp.${Date.now()}`);
+  const filePath = path35.join(configDir, "usage.json");
+  const tmpPath = path35.join(configDir, `usage.json.tmp.${Date.now()}`);
   const cutoffDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   const prunedDays = {};
   for (const [dateKey, dayRecord] of Object.entries(ledger.days)) {
@@ -268670,12 +269979,12 @@ async function saveUsageLedger(ledger) {
   }
   ledger.days = prunedDays;
   try {
-    await fs33.mkdir(configDir, { recursive: true });
-    await fs33.writeFile(tmpPath, JSON.stringify(ledger, null, 2), "utf-8");
-    await fs33.rename(tmpPath, filePath);
+    await fs35.mkdir(configDir, { recursive: true });
+    await fs35.writeFile(tmpPath, JSON.stringify(ledger, null, 2), "utf-8");
+    await fs35.rename(tmpPath, filePath);
   } catch {
     try {
-      await fs33.unlink(tmpPath);
+      await fs35.unlink(tmpPath);
     } catch {}
   }
 }
@@ -268873,7 +270182,7 @@ var init_usage_rates2 = __esm(() => {
 // src/utils/error-parser.ts
 import util5 from "util";
 function isCreditOrBalanceError(combined) {
-  return combined.includes("insufficient balance") || combined.includes("insufficient credits") || combined.includes("insufficient_balance") || combined.includes("insufficient_credits") || combined.includes("insufficient_quota") || combined.includes("balance is insufficient") || combined.includes("balance insufficient") || combined.includes("balance exhausted") || combined.includes("out of credits") || combined.includes("credit balance is too low") || combined.includes("credits exhausted") || combined.includes("requires more credits") || combined.includes("can only afford") || combined.includes("payment required") || combined.includes("quota exceeded") || combined.includes("quota_exhausted") || combined.includes("402") || combined.includes("1008") || combined.includes("20009") || (combined.includes("credits") || combined.includes("balance")) && (combined.includes("insufficient") || combined.includes("exhausted") || combined.includes("empty") || combined.includes("zero") || combined.includes("low") || combined.includes("top up") || combined.includes("recharge") || combined.includes("afford") || combined.includes("add credits"));
+  return combined.includes("insufficient balance") || combined.includes("insufficient credits") || combined.includes("insufficient_balance") || combined.includes("insufficient_credits") || combined.includes("insufficient_quota") || combined.includes("balance is insufficient") || combined.includes("balance insufficient") || combined.includes("balance exhausted") || combined.includes("out of credits") || combined.includes("credit balance is too low") || combined.includes("credits exhausted") || combined.includes("requires more credits") || combined.includes("can only afford") || combined.includes("payment required") || combined.includes("quota exceeded") || combined.includes("quota_exhausted") || combined.includes("budget_exhausted") || combined.includes("budget exhausted") || combined.includes("budget exceeded") || combined.includes("budget_exceeded") || combined.includes("402") || combined.includes("1008") || combined.includes("20009") || (combined.includes("credits") || combined.includes("balance")) && (combined.includes("insufficient") || combined.includes("exhausted") || combined.includes("empty") || combined.includes("zero") || combined.includes("low") || combined.includes("top up") || combined.includes("recharge") || combined.includes("afford") || combined.includes("add credits"));
 }
 function normalizeProviderAlias(provider) {
   if (!provider)
@@ -269257,7 +270566,8 @@ function parseErrorMessage(err, context) {
   }
   const contextStr = `${context?.provider || ""} ${context?.model || ""}`.toLowerCase().trim();
   const lowerStr = (errMsg + " " + (finalResult || "") + (contextStr ? " " + contextStr : "")).toLowerCase();
-  const isRateLimit = lowerStr.includes("429") || lowerStr.includes("quota") || lowerStr.includes("rate limit") || lowerStr.includes("rate_limit") || lowerStr.includes("resource_exhausted") || lowerStr.includes("generativelanguage.googleapis.com");
+  const isBudgetExhausted = lowerStr.includes("budget_exhausted") || lowerStr.includes("budget exhausted") || lowerStr.includes("budget_exceeded") || lowerStr.includes("budget exceeded");
+  const isRateLimit = !isBudgetExhausted && (lowerStr.includes("429") || lowerStr.includes("quota") || lowerStr.includes("rate limit") || lowerStr.includes("rate_limit") || lowerStr.includes("resource_exhausted") || lowerStr.includes("generativelanguage.googleapis.com"));
   if (isRateLimit && !finalResult.includes("Rate limit or quota exhausted")) {
     const rateDetails = resolveRateLimitDetails(lowerStr, context);
     return rateDetails.notice + finalResult;
@@ -269298,7 +270608,8 @@ function parseError(err, context) {
   const contextStr = `${context?.provider || ""} ${context?.model || ""}`.toLowerCase().trim();
   const fullMessage = parseErrorMessage(err, context);
   const combined = `${fullMessage} ${explicitCause || ""} ${contextStr ? " " + contextStr : ""}`.toLowerCase();
-  const isRateLimit = combined.includes("429") || combined.includes("quota") || combined.includes("rate limit") || combined.includes("rate_limit") || combined.includes("resource_exhausted") || combined.includes("generativelanguage.googleapis.com");
+  const isBudgetExhausted = combined.includes("budget_exhausted") || combined.includes("budget exhausted") || combined.includes("budget_exceeded") || combined.includes("budget exceeded");
+  const isRateLimit = !isBudgetExhausted && (combined.includes("429") || combined.includes("quota") || combined.includes("rate limit") || combined.includes("rate_limit") || combined.includes("resource_exhausted") || combined.includes("generativelanguage.googleapis.com"));
   if (isRateLimit) {
     const parts = fullMessage.split(`
 `);
@@ -269940,7 +271251,7 @@ var init_error_parser = __esm(() => {
     {
       id: "auriko",
       name: "Auriko",
-      match: (str) => (str.includes("auriko.ai") || str.includes("api.auriko.ai") || str.includes("auriko")) && (isCreditOrBalanceError(str) || str.includes("credits") || str.includes("402")),
+      match: (str) => (str.includes("auriko.ai") || str.includes("api.auriko.ai") || str.includes("auriko")) && (isCreditOrBalanceError(str) || str.includes("credits") || str.includes("budget") || str.includes("402")),
       notice: `Insufficient credits in your Auriko account. Please check your account at https://www.auriko.ai/dashboard
 `,
       message: "Insufficient credits in your Auriko account.",
@@ -270110,14 +271421,14 @@ function extractJsonArray(rawText) {
 }
 
 // src/utils/project-context.ts
-import fs34 from "node:fs";
-import path33 from "node:path";
+import fs36 from "node:fs";
+import path36 from "node:path";
 function getProjectContext(workspaceDir = process.cwd()) {
   const parts = [];
   try {
-    const pkgPath = path33.join(workspaceDir, "package.json");
-    if (fs34.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs34.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path36.join(workspaceDir, "package.json");
+    if (fs36.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf8"));
       const deps = Object.keys(pkg.dependencies || {}).slice(0, 15).join(", ");
       const devDeps = Object.keys(pkg.devDependencies || {}).slice(0, 10).join(", ");
       parts.push(`Project: ${pkg.name || "Unnamed"}`);
@@ -270126,13 +271437,13 @@ function getProjectContext(workspaceDir = process.cwd()) {
       if (devDeps)
         parts.push(`DevDependencies: ${devDeps}`);
     }
-    const agentsPath = path33.join(workspaceDir, "AGENTS.md");
-    if (fs34.existsSync(agentsPath)) {
-      const content = fs34.readFileSync(agentsPath, "utf8");
+    const agentsPath = path36.join(workspaceDir, "AGENTS.md");
+    if (fs36.existsSync(agentsPath)) {
+      const content = fs36.readFileSync(agentsPath, "utf8");
       parts.push(`Guidelines (from AGENTS.md):
 ${content.slice(0, 500)}`);
     }
-    const entries = fs34.readdirSync(workspaceDir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.isDirectory() ? `${e.name}/` : e.name).slice(0, 20);
+    const entries = fs36.readdirSync(workspaceDir, { withFileTypes: true }).filter((e) => !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.isDirectory() ? `${e.name}/` : e.name).slice(0, 20);
     if (entries.length > 0) {
       parts.push(`Workspace layout: ${entries.join(", ")}`);
     }
@@ -270287,14 +271598,14 @@ async function fetchProviderBalance(provider, apiKey, timeoutMs = 2000) {
 }
 
 // src/utils/formatters.ts
-import path34 from "node:path";
+import path37 from "node:path";
 function toRelativePath2(filePath, cwd = process.cwd()) {
   if (!filePath)
     return "";
   const trimmed = filePath.trim();
-  if (!path34.isAbsolute(trimmed))
+  if (!path37.isAbsolute(trimmed))
     return trimmed;
-  const rel = path34.relative(cwd, trimmed);
+  const rel = path37.relative(cwd, trimmed);
   if (!rel || rel.startsWith("..")) {
     return trimmed;
   }
@@ -271034,7 +272345,7 @@ ${formatSubscriptionCard(bundle, targetModel)}`
         const probeAbortController = new AbortController;
         const probeTimeout = setTimeout(() => {
           probeAbortController.abort(new Error("Connection timed out while verifying API key."));
-        }, 1e4);
+        }, 8000);
         try {
           const stream = testProvider.stream([{ role: "user", content: "Hi" }], undefined, undefined, {
             model: testModel,
@@ -271051,15 +272362,19 @@ ${formatSubscriptionCard(bundle, targetModel)}`
           }
         } catch (probeErr) {
           lastProbeErr = probeErr;
-          const errText = (probeErr?.message || String(probeErr)).toLowerCase();
+          const errText = `${probeErr?.message || ""} ${probeErr?.code || ""} ${probeErr?.error?.code || ""} ${String(probeErr)}`.toLowerCase();
           if (errText.includes("401") || errText.includes("unauthorized") || errText.includes("invalid api key") || errText.includes("incorrect api key")) {
             throw probeErr;
           }
-          if (errText.includes("402") || errText.includes("credits") || errText.includes("payment") || errText.includes("afford") || errText.includes("insufficient_quota")) {
+          if (errText.includes("402") || errText.includes("credits") || errText.includes("payment") || errText.includes("afford") || errText.includes("budget") || errText.includes("balance") || errText.includes("insufficient_quota")) {
             if (!lowCreditErr) {
               lowCreditErr = probeErr;
               lowCreditModel = testModel;
             }
+            break;
+          }
+          if (errText.includes("timed out") || errText.includes("timeout") || probeErr?.name === "AbortError") {
+            break;
           }
         }
       }
@@ -271099,10 +272414,10 @@ ${formatSubscriptionCard(bundle, targetModel)}`
       setApiKey("");
       addToast(MESSAGES.AUTH.API_KEY_SAVED(selectedProvider), "success");
     } catch (err) {
-      const errStr = (err?.message || JSON.stringify(err) || String(err)).toLowerCase();
+      const errStr = `${err?.message || ""} ${err?.code || ""} ${err?.error?.code || ""} ${String(err)}`.toLowerCase();
       const isTimeout = err?.name === "AbortError" || errStr.includes("aborted") || errStr.includes("timed out") || errStr.includes("timeout");
-      const isLowCredit = errStr.includes("402") || errStr.includes("credits") || errStr.includes("payment") || errStr.includes("afford");
-      if (errStr.includes("429") || errStr.includes("quota") || errStr.includes("rate limit") || errStr.includes("404") || errStr.includes("not found") || errStr.includes("503") || errStr.includes("无可用渠道") || errStr.includes("no available channel") || isLowCredit) {
+      const isLowCredit = errStr.includes("402") || errStr.includes("credits") || errStr.includes("payment") || errStr.includes("afford") || errStr.includes("budget") || errStr.includes("balance") || errStr.includes("insufficient_quota");
+      if (errStr.includes("429") || errStr.includes("quota") || errStr.includes("rate limit") || errStr.includes("404") || errStr.includes("not found") || errStr.includes("503") || errStr.includes("无可用渠道") || errStr.includes("no available channel") || errStr.includes("platform_keys_unavailable") || errStr.includes("byok_keys_required") || errStr.includes("tier_opt_in_required") || errStr.includes("no_provider_available") || isLowCredit) {
         await Promise.resolve().then(() => init_models5());
         const finalModel = testModel || getDefaultModelForProvider(selectedProvider);
         const config = await loadConfig();
@@ -271290,7 +272605,6 @@ ${formatSubscriptionCard(bundle, targetModel)}`
     try {
       await agent.loadContext(item.value);
       const resumedMessages = convertAgentMessagesToTuiMessages(agent.messages);
-      console.clear();
       setStaticMessages([{ id: "header", role: "header" }, ...resumedMessages]);
       setStaticKey((k) => k + 1);
       setActiveMessages([]);
@@ -271683,7 +272997,6 @@ function useAgentSession({
   } = state;
   const [expandCommands, setExpandCommands] = import_react71.useState(false);
   const toggleExpandCommands = import_react71.useCallback(() => {
-    console.clear();
     setExpandCommands((prev) => !prev);
   }, []);
   const [detectedSubscriptions, setDetectedSubscriptions] = import_react71.useState({});
@@ -271728,7 +273041,6 @@ function useAgentSession({
         }
         const resumed = convertAgentMessagesToTuiMessages(agent.messages);
         if (resumed.length > 0) {
-          console.clear();
           setStaticMessages([{ id: "header", role: "header" }, ...resumed]);
           setStaticKey((k) => k + 1);
         }
@@ -273696,7 +275008,7 @@ var init_use_agent_session = __esm(async () => {
 
 // src/index.ts
 init_package();
-import path35 from "node:path";
+import path38 from "node:path";
 
 // src/args.ts
 import { parseArgs } from "node:util";
@@ -273834,12 +275146,12 @@ Options:
 }
 // src/constants/release-highlights.json
 var release_highlights_default = {
-  version: "0.4.2",
-  title: "What's New in v0.4.2",
+  version: "0.4.4",
+  title: "What's New in v0.4.4",
   bullets: [
-    "*(tui)* Enable mouse wheel, pageup/down, and arrow scrolling",
-    "*(docs)* Add youtube and x social links to footer and creator navigation schema",
-    "*(tui)* Remove empty line between tool calls and active loader"
+    "*(agent)* Passive workspace memory ingestion and manage_memory tool",
+    "*(agent)* Lsp client integration for definition and reference navigation",
+    "*(tools)* Prefer non-import lines when resolving symbol definition in code_intelligence"
   ],
   url: "https://trydecember.com/docs/changelog"
 };
@@ -274040,7 +275352,7 @@ To define project-specific instructions, create an AGENTS.md file in your projec
       sessionRepository,
       sessionId,
       runtime: "cli",
-      workspaceDir: parsedArgs.scope ? path35.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
+      workspaceDir: parsedArgs.scope ? path38.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
       thinkingLevel: config.thinkingLevel || "auto",
       steeringMode: config.steeringMode || "all",
       followUpMode: config.followUpMode || "all"
@@ -274144,7 +275456,7 @@ Executing Headless Task: "${parsedArgs.prompt}"
     sessionRepository,
     sessionId,
     runtime: "cli",
-    workspaceDir: parsedArgs.scope ? path35.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
+    workspaceDir: parsedArgs.scope ? path38.resolve(process.cwd(), parsedArgs.scope) : process.cwd(),
     thinkingLevel: config.thinkingLevel || "auto",
     steeringMode: config.steeringMode || "all",
     followUpMode: config.followUpMode || "all"