@trydecember/cli 0.4.3 → 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.3",
+    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 {
@@ -66472,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) {
@@ -109444,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"
@@ -109456,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"
@@ -111284,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";
   }
@@ -119421,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;
@@ -121274,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(() => {
@@ -162242,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);
 }
@@ -162252,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
@@ -162370,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();
@@ -162393,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,
@@ -162408,7 +162877,9 @@ var init_src4 = __esm(() => {
     FindFilesTool,
     GrepSearchTool,
     AskQuestionTool,
-    SearchToolsTool
+    SearchToolsTool,
+    CodeIntelligenceTool,
+    ManageMemoryTool
   ];
   DEFERRED_TOOLS = [ManageTaskTool, BrowserTool, WebSearchTool];
   defaultDeferredRegistry.register(BrowserTool, {
@@ -162423,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
@@ -162627,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) {
@@ -162645,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) {
@@ -162656,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}`;
@@ -162793,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(() => {
@@ -162802,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;
@@ -163560,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);
@@ -163575,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;
@@ -164700,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(() => {
@@ -164879,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") {
@@ -166387,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 = {
@@ -166419,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;
   });
 }
@@ -166504,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;
@@ -166523,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;
@@ -166536,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;
@@ -166859,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,
@@ -166914,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;
@@ -166928,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)
@@ -166936,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 {
@@ -166947,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 {
@@ -166970,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(() => {
@@ -167753,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,
@@ -167911,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;
@@ -167975,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 });
               }
@@ -168001,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;
@@ -168009,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 });
             }
@@ -168275,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."
+      ]
     }
   };
 });
@@ -168289,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(() => {
@@ -168305,6 +169433,7 @@ var init_src5 = __esm(() => {
   init_telemetry();
   init_skill_subagent();
   init_run_skill_tool();
+  init_lsp_client();
 });
 
 // src/headless-runner.ts
@@ -168582,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;
@@ -168593,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) {
@@ -168632,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;
@@ -168685,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) {
@@ -168699,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;
@@ -168712,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 = "";
@@ -168749,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(() => {
@@ -174396,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();
@@ -174426,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,
@@ -174556,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";
@@ -174577,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;
@@ -174594,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,
@@ -174606,7 +175767,7 @@ 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 escapedQuery = query.replace(/"/g, "\\\"");
@@ -174620,7 +175781,7 @@ Failed to start process: ${err?.message || err}
             if (!line.trim())
               return false;
             const rawPath = line.split(":")[0];
-            const relPath = path24.isAbsolute(rawPath) ? path24.relative(root, rawPath) : rawPath;
+            const relPath = path27.isAbsolute(rawPath) ? path27.relative(root, rawPath) : rawPath;
             return !isPathIgnored(relPath, ignores);
           });
           return filtered.join(`
@@ -174662,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
@@ -179015,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;
@@ -179063,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;
@@ -179083,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 = () => {
@@ -211286,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(`
@@ -211296,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) {
@@ -212728,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(() => {
@@ -213971,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;
@@ -213985,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 {
@@ -214010,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 {}
   }
@@ -214078,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();
@@ -214156,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();
@@ -214262,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) {
@@ -214303,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",
@@ -214324,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
@@ -214348,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}` });
         }
       }
@@ -216045,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;
@@ -216054,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);
@@ -216063,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;
   }
@@ -262433,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;
@@ -262727,7 +263936,7 @@ 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)
@@ -267816,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",
@@ -267834,7 +269043,7 @@ function openPlanInPager(planText, title = "december-plan") {
       });
       child.on("exit", () => {
         try {
-          fs31.unlinkSync(tmpFile);
+          fs33.unlinkSync(tmpFile);
         } catch {}
         resolve();
       });
@@ -268404,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;
@@ -268414,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 ?? "";
@@ -268482,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,
@@ -268548,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,
@@ -268576,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 = "";
@@ -268586,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"],
@@ -268738,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;
@@ -268759,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)) {
@@ -268770,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 {}
   }
 }
@@ -268973,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)
@@ -269357,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;
@@ -269398,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(`
 `);
@@ -270040,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.",
@@ -270210,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"}`);
@@ -270226,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(", ")}`);
     }
@@ -270387,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;
   }
@@ -271134,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,
@@ -271151,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;
           }
         }
       }
@@ -271199,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();
@@ -273793,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";
@@ -273931,12 +275146,12 @@ Options:
 }
 // src/constants/release-highlights.json
 var release_highlights_default = {
-  version: "0.4.3",
-  title: "What's New in v0.4.3",
+  version: "0.4.4",
+  title: "What's New in v0.4.4",
   bullets: [
-    "Remove search mode and add prompt focus text animation",
-    "*(tui)* Eagerly update scroll state ref to support rapid mouse wheel scroll events",
-    "*(tui)* Prevent layout overflow and ghosting on terminal resize and small heights"
+    "*(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"
 };
@@ -274137,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"
@@ -274241,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"