@nomad-e/bluma-cli 0.11.0 → 0.11.2

package/dist/main.js

@@ -28,6 +28,486 @@ var init_devtools = __esm({
   }
 });
 
+// src/app/agent/session_manager/bluma_app_dir.ts
+import path from "path";
+import os from "os";
+function expandHome(p) {
+  if (!p) return p;
+  if (p.startsWith("~")) {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+function getPreferredAppDir() {
+  const fromEnv = process.env.BLUMA_HOME?.trim();
+  if (fromEnv) {
+    return path.resolve(expandHome(fromEnv));
+  }
+  const fixed = path.join(os.homedir(), ".bluma");
+  return path.resolve(expandHome(fixed));
+}
+var init_bluma_app_dir = __esm({
+  "src/app/agent/session_manager/bluma_app_dir.ts"() {
+    "use strict";
+  }
+});
+
+// src/app/agent/memory/memdir/paths.ts
+import { homedir as homedir3 } from "os";
+import { isAbsolute, join as join4, normalize, sep } from "path";
+function isEnvTruthy2(envVar) {
+  if (!envVar) return false;
+  return ["1", "true", "yes", "on"].includes(envVar.toLowerCase().trim());
+}
+function isEnvDefinedFalsy2(envVar) {
+  if (envVar === void 0) return false;
+  return ["0", "false", "no", "off"].includes(envVar.toLowerCase().trim());
+}
+function sanitizeProjectKey(projectPath) {
+  const normalized = normalize(projectPath);
+  return normalized.replace(/[/\\]+/g, "-").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 180) || "project";
+}
+function isAutoMemoryEnabled() {
+  const envVal = process.env.BLUMA_DISABLE_AUTO_MEMORY;
+  if (isEnvTruthy2(envVal)) return false;
+  if (isEnvDefinedFalsy2(envVal)) return true;
+  if (isEnvTruthy2(process.env.BLUMA_SIMPLE)) return false;
+  return true;
+}
+function getMemoryBaseDir() {
+  if (process.env.BLUMA_REMOTE_MEMORY_DIR?.trim()) {
+    return process.env.BLUMA_REMOTE_MEMORY_DIR.trim().replace(/[/\\]+$/, "");
+  }
+  return getPreferredAppDir();
+}
+function validateMemoryPath(raw, expandTilde4) {
+  if (!raw?.trim()) return void 0;
+  let candidate = raw.trim();
+  if (expandTilde4 && (candidate.startsWith("~/") || candidate.startsWith("~\\"))) {
+    candidate = join4(homedir3(), candidate.slice(2));
+  }
+  const normalized = normalize(candidate).replace(/[/\\]+$/, "");
+  if (!isAbsolute(normalized) || normalized.length < 3 || /^[A-Za-z]:$/.test(normalized) || normalized.includes("\0")) {
+    return void 0;
+  }
+  return (normalized + sep).normalize("NFC");
+}
+function getAutoMemPathOverride() {
+  return validateMemoryPath(process.env.BLUMA_MEMORY_PATH_OVERRIDE, false);
+}
+function getAutoMemPath() {
+  const cwd2 = process.cwd();
+  if (cachedAutoMemPath && cachedAutoMemCwd === cwd2) return cachedAutoMemPath;
+  const override = getAutoMemPathOverride();
+  if (override) {
+    cachedAutoMemPath = override;
+    cachedAutoMemCwd = cwd2;
+    return override;
+  }
+  const projectsDir = join4(getMemoryBaseDir(), "projects");
+  const key = sanitizeProjectKey(cwd2);
+  cachedAutoMemPath = (join4(projectsDir, key, AUTO_MEM_DIRNAME) + sep).normalize("NFC");
+  cachedAutoMemCwd = cwd2;
+  return cachedAutoMemPath;
+}
+function isAutoMemPath(absolutePath) {
+  const normalized = normalize(absolutePath);
+  const memRoot = getAutoMemPath();
+  return normalized.startsWith(memRoot) || normalized + sep === memRoot;
+}
+var AUTO_MEM_DIRNAME, cachedAutoMemPath, cachedAutoMemCwd;
+var init_paths = __esm({
+  "src/app/agent/memory/memdir/paths.ts"() {
+    "use strict";
+    init_bluma_app_dir();
+    AUTO_MEM_DIRNAME = "memory";
+  }
+});
+
+// src/app/agent/memory/memdir/memoryTypes.ts
+function parseMemoryType(raw) {
+  if (typeof raw !== "string") return void 0;
+  return MEMORY_TYPES.find((t) => t === raw);
+}
+var MEMORY_TYPES, TYPES_SECTION_INDIVIDUAL, WHAT_NOT_TO_SAVE_SECTION, MEMORY_DRIFT_CAVEAT, WHEN_TO_ACCESS_SECTION, TRUSTING_RECALL_SECTION, MEMORY_FRONTMATTER_EXAMPLE;
+var init_memoryTypes = __esm({
+  "src/app/agent/memory/memdir/memoryTypes.ts"() {
+    "use strict";
+    MEMORY_TYPES = [
+      "user",
+      "feedback",
+      "project",
+      "reference"
+    ];
+    TYPES_SECTION_INDIVIDUAL = [
+      "## Types of memory",
+      "",
+      "There are several discrete types of memory that you can store in your memory system:",
+      "",
+      "<types>",
+      "<type>",
+      "    <name>user</name>",
+      "    <description>Contain information about the user's role, goals, responsibilities, and knowledge. Great user memories help you tailor your future behavior to the user's preferences and perspective. Your goal in reading and writing these memories is to build up an understanding of who the user is and how you can be most helpful to them specifically. For example, you should collaborate with a senior software engineer differently than a student who is coding for the very first time. Keep in mind, that the aim here is to be helpful to the user. Avoid writing memories about the user that could be viewed as a negative judgement or that are not relevant to the work you're trying to accomplish together.</description>",
+      "    <when_to_save>When you learn any details about the user's role, preferences, responsibilities, or knowledge</when_to_save>",
+      "    <how_to_use>When your work should be informed by the user's profile or perspective. For example, if the user is asking you to explain a part of the code, you should answer that question in a way that is tailored to the specific details that they will find most valuable or that helps them build their mental model in relation to domain knowledge they already have.</how_to_use>",
+      "    <examples>",
+      "    user: I'm a data scientist investigating what logging we have in place",
+      "    assistant: [saves user memory: user is a data scientist, currently focused on observability/logging]",
+      "",
+      "    user: I've been writing Go for ten years but this is my first time touching the React side of this repo",
+      "    assistant: [saves user memory: deep Go expertise, new to React and this project's frontend \u2014 frame frontend explanations in terms of backend analogues]",
+      "    </examples>",
+      "</type>",
+      "<type>",
+      "    <name>feedback</name>",
+      "    <description>Guidance the user has given you about how to approach work \u2014 both what to avoid and what to keep doing. These are a very important type of memory to read and write as they allow you to remain coherent and responsive to the way you should approach work in the project. Record from failure AND success: if you only save corrections, you will avoid past mistakes but drift away from approaches the user has already validated, and may grow overly cautious.</description>",
+      `    <when_to_save>Any time the user corrects your approach ("no not that", "don't", "stop doing X") OR confirms a non-obvious approach worked ("yes exactly", "perfect, keep doing that", accepting an unusual choice without pushback). Corrections are easy to notice; confirmations are quieter \u2014 watch for them. In both cases, save what is applicable to future conversations, especially if surprising or not obvious from the code. Include *why* so you can judge edge cases later.</when_to_save>`,
+      "    <how_to_use>Let these memories guide your behavior so that the user does not need to offer the same guidance twice.</how_to_use>",
+      "    <body_structure>Lead with the rule itself, then a **Why:** line (the reason the user gave \u2014 often a past incident or strong preference) and a **How to apply:** line (when/where this guidance kicks in). Knowing *why* lets you judge edge cases instead of blindly following the rule.</body_structure>",
+      "    <examples>",
+      "    user: don't mock the database in these tests \u2014 we got burned last quarter when mocked tests passed but the prod migration failed",
+      "    assistant: [saves feedback memory: integration tests must hit a real database, not mocks. Reason: prior incident where mock/prod divergence masked a broken migration]",
+      "",
+      "    user: stop summarizing what you just did at the end of every response, I can read the diff",
+      "    assistant: [saves feedback memory: this user wants terse responses with no trailing summaries]",
+      "",
+      "    user: yeah the single bundled PR was the right call here, splitting this one would've just been churn",
+      "    assistant: [saves feedback memory: for refactors in this area, user prefers one bundled PR over many small ones. Confirmed after I chose this approach \u2014 a validated judgment call, not a correction]",
+      "    </examples>",
+      "</type>",
+      "<type>",
+      "    <name>project</name>",
+      "    <description>Information that you learn about ongoing work, goals, initiatives, bugs, or incidents within the project that is not otherwise derivable from the code or git history. Project memories help you understand the broader context and motivation behind the work the user is doing within this working directory.</description>",
+      '    <when_to_save>When you learn who is doing what, why, or by when. These states change relatively quickly so try to keep your understanding of this up to date. Always convert relative dates in user messages to absolute dates when saving (e.g., "Thursday" \u2192 "2026-03-05"), so the memory remains interpretable after time passes.</when_to_save>',
+      "    <how_to_use>Use these memories to more fully understand the details and nuance behind the user's request and make better informed suggestions.</how_to_use>",
+      "    <body_structure>Lead with the fact or decision, then a **Why:** line (the motivation \u2014 often a constraint, deadline, or stakeholder ask) and a **How to apply:** line (how this should shape your suggestions). Project memories decay fast, so the why helps future-you judge whether the memory is still load-bearing.</body_structure>",
+      "    <examples>",
+      "    user: we're freezing all non-critical merges after Thursday \u2014 mobile team is cutting a release branch",
+      "    assistant: [saves project memory: merge freeze begins 2026-03-05 for mobile release cut. Flag any non-critical PR work scheduled after that date]",
+      "",
+      "    user: the reason we're ripping out the old auth middleware is that legal flagged it for storing session tokens in a way that doesn't meet the new compliance requirements",
+      "    assistant: [saves project memory: auth middleware rewrite is driven by legal/compliance requirements around session token storage, not tech-debt cleanup \u2014 scope decisions should favor compliance over ergonomics]",
+      "    </examples>",
+      "</type>",
+      "<type>",
+      "    <name>reference</name>",
+      "    <description>Stores pointers to where information can be found in external systems. These memories allow you to remember where to look to find up-to-date information outside of the project directory.</description>",
+      "    <when_to_save>When you learn about resources in external systems and their purpose. For example, that bugs are tracked in a specific project in Linear or that feedback can be found in a specific Slack channel.</when_to_save>",
+      "    <how_to_use>When the user references an external system or information that may be in an external system.</how_to_use>",
+      "    <examples>",
+      `    user: check the Linear project "INGEST" if you want context on these tickets, that's where we track all pipeline bugs`,
+      '    assistant: [saves reference memory: pipeline bugs are tracked in Linear project "INGEST"]',
+      "",
+      "    user: the Grafana board at grafana.internal/d/api-latency is what oncall watches \u2014 if you're touching request handling, that's the thing that'll page someone",
+      "    assistant: [saves reference memory: grafana.internal/d/api-latency is the oncall latency dashboard \u2014 check it when editing request-path code]",
+      "    </examples>",
+      "</type>",
+      "</types>",
+      ""
+    ];
+    WHAT_NOT_TO_SAVE_SECTION = [
+      "## What NOT to save in memory",
+      "",
+      "- Code patterns, conventions, architecture, file paths, or project structure \u2014 these can be derived by reading the current project state.",
+      "- Git history, recent changes, or who-changed-what \u2014 `git log` / `git blame` are authoritative.",
+      "- Debugging solutions or fix recipes \u2014 the fix is in the code; the commit message has the context.",
+      "- Anything already documented in CLAUDE.md files.",
+      "- Ephemeral task details: in-progress work, temporary state, current conversation context.",
+      "",
+      // H2: explicit-save gate. Eval-validated (memory-prompt-iteration case 3,
+      // 0/2 → 3/3): prevents "save this week's PR list" → activity-log noise.
+      "These exclusions apply even when the user explicitly asks you to save. If they ask you to save a PR list or activity summary, ask what was *surprising* or *non-obvious* about it \u2014 that is the part worth keeping."
+    ];
+    MEMORY_DRIFT_CAVEAT = "- Memory records can become stale over time. Use memory as context for what was true at a given point in time. Before answering the user or building assumptions based solely on information in memory records, verify that the memory is still correct and up-to-date by reading the current state of the files or resources. If a recalled memory conflicts with current information, trust what you observe now \u2014 and update or remove the stale memory rather than acting on it.";
+    WHEN_TO_ACCESS_SECTION = [
+      "## When to access memories",
+      "- When memories seem relevant, or the user references prior-conversation work.",
+      "- You MUST access memory when the user explicitly asks you to check, recall, or remember.",
+      "- If the user says to *ignore* or *not use* memory: proceed as if MEMORY.md were empty. Do not apply remembered facts, cite, compare against, or mention memory content.",
+      MEMORY_DRIFT_CAVEAT
+    ];
+    TRUSTING_RECALL_SECTION = [
+      // Header wording matters: "Before recommending" (action cue at the decision
+      // point) tested better than "Trusting what you recall" (abstract). The
+      // appendSystemPrompt variant with this header went 3/3; the abstract header
+      // went 0/3 in-place. Same body text — only the header differed.
+      "## Before recommending from memory",
+      "",
+      "A memory that names a specific function, file, or flag is a claim that it existed *when the memory was written*. It may have been renamed, removed, or never merged. Before recommending it:",
+      "",
+      "- If the memory names a file path: check the file exists.",
+      "- If the memory names a function or flag: grep for it.",
+      "- If the user is about to act on your recommendation (not just asking about history), verify first.",
+      "",
+      '"The memory says X exists" is not the same as "X exists now."',
+      "",
+      "A memory that summarizes repo state (activity logs, architecture snapshots) is frozen in time. If the user asks about *recent* or *current* state, prefer `git log` or reading the code over recalling the snapshot."
+    ];
+    MEMORY_FRONTMATTER_EXAMPLE = [
+      "```markdown",
+      "---",
+      "name: {{memory name}}",
+      "description: {{one-line description \u2014 used to decide relevance in future conversations, so be specific}}",
+      `type: {{${MEMORY_TYPES.join(", ")}}}`,
+      "---",
+      "",
+      "{{memory content \u2014 for feedback/project types, structure as: rule/fact, then **Why:** and **How to apply:** lines}}",
+      "```"
+    ];
+  }
+});
+
+// src/app/agent/memory/memdir/memdir.ts
+import { mkdir as mkdir2, readFile } from "fs/promises";
+import { join as join5 } from "path";
+function truncateEntrypointContent(raw) {
+  const trimmed = raw.trim();
+  const contentLines = trimmed.split("\n");
+  const lineCount = contentLines.length;
+  let wasLineTruncated = false;
+  let body = trimmed;
+  if (lineCount > MAX_ENTRYPOINT_LINES) {
+    body = contentLines.slice(-MAX_ENTRYPOINT_LINES).join("\n");
+    wasLineTruncated = true;
+  }
+  let wasByteTruncated = false;
+  const enc = new TextEncoder();
+  let bytes = enc.encode(body);
+  if (bytes.length > MAX_ENTRYPOINT_BYTES) {
+    const slice = bytes.slice(-MAX_ENTRYPOINT_BYTES);
+    body = new TextDecoder().decode(slice);
+    const nl = body.indexOf("\n");
+    if (nl > 0) body = body.slice(nl + 1);
+    wasByteTruncated = true;
+    bytes = enc.encode(body);
+  }
+  const warnings = [];
+  if (wasLineTruncated) warnings.push(`truncated to last ${MAX_ENTRYPOINT_LINES} lines`);
+  if (wasByteTruncated) warnings.push(`truncated to last ${MAX_ENTRYPOINT_BYTES} bytes`);
+  if (warnings.length) {
+    body = `> ${ENTRYPOINT_NAME} ${warnings.join(" and ")}.
+
+${body}`;
+  }
+  return {
+    content: body,
+    lineCount,
+    byteCount: bytes.length,
+    wasLineTruncated,
+    wasByteTruncated
+  };
+}
+async function ensureMemoryDirExists(memoryDir) {
+  try {
+    await mkdir2(memoryDir, { recursive: true });
+  } catch {
+  }
+}
+function buildSearchingPastContextSection(autoMemDir) {
+  const projectsDir = join5(autoMemDir.replace(/[/\\]+$/, ""), "..", "..");
+  return [
+    "## Searching past context",
+    "",
+    "When looking for past context:",
+    "1. Search topic files in your memory directory:",
+    "```",
+    `grep_search with pattern="<search term>" path="${autoMemDir}" (markdown files)`,
+    "```",
+    "2. Session transcript logs under the project sessions dir (last resort):",
+    "```",
+    `grep_search with pattern="<search term>" path="${projectsDir}"`,
+    "```",
+    "Use narrow search terms (error messages, file paths, function names).",
+    ""
+  ];
+}
+function buildMemoryLines(displayName, memoryDir, extraGuidelines, skipIndex = false) {
+  const howToSave = skipIndex ? [
+    "## How to save memories",
+    "",
+    "Write each memory to its own file (e.g., `user_role.md`, `feedback_testing.md`) using this frontmatter format:",
+    "",
+    ...MEMORY_FRONTMATTER_EXAMPLE,
+    "",
+    "- Keep the name, description, and type fields up to date",
+    "- Organize by topic, not chronologically",
+    "- Update or remove outdated memories",
+    "- Check for an existing memory before creating a duplicate"
+  ] : [
+    "## How to save memories",
+    "",
+    "Saving a memory is a two-step process:",
+    "",
+    "**Step 1** \u2014 write the memory file with frontmatter:",
+    "",
+    ...MEMORY_FRONTMATTER_EXAMPLE,
+    "",
+    `**Step 2** \u2014 add a pointer in \`${ENTRYPOINT_NAME}\`: one line, ~150 chars: \`- [Title](file.md) \u2014 hook\`. Never put memory body in \`${ENTRYPOINT_NAME}\`.`,
+    "",
+    `- \`${ENTRYPOINT_NAME}\` is loaded every turn \u2014 keep the index under ${MAX_ENTRYPOINT_LINES} lines`,
+    "- Update or remove outdated memories",
+    "- No duplicates \u2014 update existing files when possible"
+  ];
+  const lines = [
+    `# ${displayName}`,
+    "",
+    `You have a persistent, file-based memory system at \`${memoryDir}\`. ${DIR_EXISTS_GUIDANCE}`,
+    "",
+    "Build this up over time so future conversations know who the user is, how they prefer to collaborate, and project context not obvious from code alone.",
+    "",
+    "If the user asks you to remember something, save it immediately. If they ask to forget, remove the relevant entry.",
+    "",
+    ...TYPES_SECTION_INDIVIDUAL,
+    ...WHAT_NOT_TO_SAVE_SECTION,
+    "",
+    ...howToSave,
+    "",
+    ...WHEN_TO_ACCESS_SECTION,
+    "",
+    ...TRUSTING_RECALL_SECTION,
+    "",
+    "## Memory vs plan vs tasks",
+    "Use memory for facts useful in *future* conversations. Use plans for alignment on the current implementation. Use tasks for steps in the *current* conversation.",
+    "",
+    ...extraGuidelines ?? [],
+    ""
+  ];
+  lines.push(...buildSearchingPastContextSection(memoryDir));
+  return lines;
+}
+async function loadMemoryPrompt() {
+  if (!isAutoMemoryEnabled()) return null;
+  const autoDir = getAutoMemPath();
+  await ensureMemoryDirExists(autoDir);
+  const lines = buildMemoryLines("auto memory", autoDir);
+  const entrypoint = join5(autoDir, ENTRYPOINT_NAME);
+  try {
+    const entrypointContent = await readFile(entrypoint, "utf-8");
+    if (entrypointContent.trim()) {
+      const t = truncateEntrypointContent(entrypointContent);
+      lines.push(`## ${ENTRYPOINT_NAME}`, "", t.content);
+    } else {
+      lines.push(
+        `## ${ENTRYPOINT_NAME}`,
+        "",
+        `Your ${ENTRYPOINT_NAME} is empty. New memories will appear here as you save them.`
+      );
+    }
+  } catch {
+    lines.push(
+      `## ${ENTRYPOINT_NAME}`,
+      "",
+      `Your ${ENTRYPOINT_NAME} is empty. New memories will appear here as you save them.`
+    );
+  }
+  return lines.join("\n");
+}
+var ENTRYPOINT_NAME, MAX_ENTRYPOINT_LINES, MAX_ENTRYPOINT_BYTES, DIR_EXISTS_GUIDANCE;
+var init_memdir = __esm({
+  "src/app/agent/memory/memdir/memdir.ts"() {
+    "use strict";
+    init_memoryTypes();
+    init_paths();
+    ENTRYPOINT_NAME = "MEMORY.md";
+    MAX_ENTRYPOINT_LINES = 200;
+    MAX_ENTRYPOINT_BYTES = 25e3;
+    DIR_EXISTS_GUIDANCE = "This directory already exists \u2014 write to it directly with file_write (do not run mkdir or check for its existence).";
+  }
+});
+
+// src/app/agent/memory/agent_memory.ts
+import { join as join6, normalize as normalize2, sep as sep2 } from "path";
+function isAgentMemoryPath(absolutePath, cwd2 = process.cwd()) {
+  const normalizedPath = normalize2(absolutePath);
+  const memoryBase = getPreferredAppDir();
+  if (normalizedPath.startsWith(join6(memoryBase, "agent-memory") + sep2)) return true;
+  if (normalizedPath.startsWith(join6(cwd2, ".bluma", "agent-memory") + sep2)) return true;
+  if (process.env.BLUMA_REMOTE_MEMORY_DIR?.trim()) {
+    if (normalizedPath.includes(sep2 + "agent-memory-local" + sep2) && normalizedPath.startsWith(join6(process.env.BLUMA_REMOTE_MEMORY_DIR, "projects") + sep2)) {
+      return true;
+    }
+  } else if (normalizedPath.startsWith(join6(cwd2, ".bluma", "agent-memory-local") + sep2)) {
+    return true;
+  }
+  return false;
+}
+var init_agent_memory = __esm({
+  "src/app/agent/memory/agent_memory.ts"() {
+    "use strict";
+    init_bluma_app_dir();
+    init_memdir();
+  }
+});
+
+// src/app/agent/memory/session_memory_paths.ts
+import { join as join7, normalize as normalize3, sep as sep3 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+function getSessionMemoryDir(sessionId, cwd2 = process.cwd()) {
+  const projectKey = sanitizeProjectKey(cwd2);
+  return (join7(getPreferredAppDir(), "projects", projectKey, sessionId, "session-memory") + sep3).normalize("NFC");
+}
+function getSessionMemoryPath(sessionId, cwd2 = process.cwd()) {
+  return join7(getSessionMemoryDir(sessionId, cwd2), SESSION_MEMORY_SUMMARY);
+}
+function isSessionMemoryPath(absolutePath) {
+  const normalized = normalize3(absolutePath);
+  return normalized.includes(`${sep3}session-memory${sep3}`) && normalized.endsWith(".md");
+}
+async function ensureSessionMemoryDir(sessionId, cwd2 = process.cwd()) {
+  const dir = getSessionMemoryDir(sessionId, cwd2);
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+var SESSION_MEMORY_SUMMARY, DEFAULT_SESSION_MEMORY_TEMPLATE;
+var init_session_memory_paths = __esm({
+  "src/app/agent/memory/session_memory_paths.ts"() {
+    "use strict";
+    init_bluma_app_dir();
+    init_paths();
+    SESSION_MEMORY_SUMMARY = "summary.md";
+    DEFAULT_SESSION_MEMORY_TEMPLATE = `
+# Session Title
+_A short 5-10 word title for this session_
+
+# Current State
+_What is actively being worked on? Pending tasks. Next steps._
+
+# Task specification
+_What did the user ask to build?_
+
+# Files and Functions
+_Important files and why they matter_
+
+# Errors & Corrections
+_Errors fixed, user corrections, approaches that failed_
+
+# Learnings
+_What worked; what to avoid_
+
+# Key results
+_Repeat exact deliverables the user asked for_
+
+# Worklog
+_Terse step-by-step log_
+`.trim();
+  }
+});
+
+// src/app/agent/memory/memory_access.ts
+import { normalize as normalize4 } from "path";
+function isBlumaManagedMemoryPath(absolutePath, cwd2 = process.cwd()) {
+  const p = normalize4(absolutePath);
+  return isAutoMemPath(p) || isAgentMemoryPath(p, cwd2) || isSessionMemoryPath(p);
+}
+var init_memory_access = __esm({
+  "src/app/agent/memory/memory_access.ts"() {
+    "use strict";
+    init_paths();
+    init_agent_memory();
+    init_session_memory_paths();
+  }
+});
+
 // src/app/agent/runtime/sessionPermissionState.ts
 function getSessionPermissionMode(sessionId) {
   return sessionPermissionModes.get(sessionId) ?? "default";
@@ -56,8 +536,8 @@ __export(runtime_config_exports, {
   setRuntimeConfig: () => setRuntimeConfig
 });
 import fs2 from "fs";
-import os from "os";
-import path from "path";
+import os2 from "os";
+import path2 from "path";
 function parseFeatures(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
   const out = {};
@@ -81,10 +561,10 @@ function createDefaultConfig() {
   };
 }
 function getConfigPath() {
-  return path.join(process.env.HOME || os.homedir(), ".bluma", "settings.json");
+  return path2.join(process.env.HOME || os2.homedir(), ".bluma", "settings.json");
 }
 function ensureConfigDir() {
-  fs2.mkdirSync(path.dirname(getConfigPath()), { recursive: true });
+  fs2.mkdirSync(path2.dirname(getConfigPath()), { recursive: true });
 }
 function getRuntimeConfig() {
   try {
@@ -152,8 +632,8 @@ var init_runtime_config = __esm({
 
 // src/app/agent/runtime/permission_rules.ts
 import fs3 from "fs";
-import os2 from "os";
-import path2 from "path";
+import os3 from "os";
+import path3 from "path";
 import { v4 as uuidv4 } from "uuid";
 var PermissionRulesEngine, permissionRulesEngine;
 var init_permission_rules = __esm({
@@ -163,7 +643,7 @@ var init_permission_rules = __esm({
       rules = [];
       rulesFile;
       constructor(rulesFile) {
-        this.rulesFile = rulesFile || path2.join(os2.homedir(), ".bluma", "permission_rules.json");
+        this.rulesFile = rulesFile || path3.join(os3.homedir(), ".bluma", "permission_rules.json");
         this.loadRules();
       }
       /**
@@ -274,17 +754,17 @@ var init_permission_rules = __esm({
 });
 
 // src/app/agent/runtime/sandbox_policy.ts
-import path3 from "path";
-import os3 from "os";
+import path4 from "path";
+import os4 from "os";
 function expandTilde(p) {
-  if (p === "~") return os3.homedir();
-  if (p.startsWith("~/")) return path3.join(os3.homedir(), p.slice(2));
+  if (p === "~") return os4.homedir();
+  if (p.startsWith("~/")) return path4.join(os4.homedir(), p.slice(2));
   return p;
 }
 function getSandboxPolicy() {
   const runtimeConfig = getRuntimeConfig();
   const isSandbox = process.env.BLUMA_SANDBOX === "true" || runtimeConfig.sandboxEnabled === true;
-  const workspaceRoot = isSandbox ? path3.resolve(process.env.BLUMA_SANDBOX_WORKSPACE || process.cwd()) : path3.resolve(process.cwd());
+  const workspaceRoot = isSandbox ? path4.resolve(process.env.BLUMA_SANDBOX_WORKSPACE || process.cwd()) : path4.resolve(process.cwd());
   return {
     mode: isSandbox ? "workspace" : "local",
     isSandbox,
@@ -292,42 +772,44 @@ function getSandboxPolicy() {
   };
 }
 function getArtifactsDirectory(policy = getSandboxPolicy()) {
-  return path3.join(policy.workspaceRoot, ".bluma", "artifacts");
+  return path4.join(policy.workspaceRoot, ".bluma", "artifacts");
 }
 function isPathInsideArtifactsDirectory(resolvedAbsolutePath, policy = getSandboxPolicy()) {
   const artifactsRoot = getArtifactsDirectory(policy);
-  const resolved = path3.resolve(resolvedAbsolutePath);
-  const relative = path3.relative(artifactsRoot, resolved);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const resolved = path4.resolve(resolvedAbsolutePath);
+  const relative = path4.relative(artifactsRoot, resolved);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
 }
 function isPathInsideWorkspace(targetPath, policy = getSandboxPolicy()) {
-  const resolved = path3.resolve(targetPath);
-  const relative = path3.relative(policy.workspaceRoot, resolved);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const resolved = path4.resolve(targetPath);
+  const relative = path4.relative(policy.workspaceRoot, resolved);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
 }
 function redirectTopLevelArtifactsPath(resolvedAbsolute, workspaceRoot) {
-  const wr = path3.resolve(workspaceRoot);
-  const abs = path3.resolve(resolvedAbsolute);
-  const rel = path3.relative(wr, abs);
-  if (rel.startsWith("..") || path3.isAbsolute(rel)) return abs;
-  const segments = rel.split(path3.sep).filter((s) => s.length > 0);
+  const wr = path4.resolve(workspaceRoot);
+  const abs = path4.resolve(resolvedAbsolute);
+  const rel = path4.relative(wr, abs);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) return abs;
+  const segments = rel.split(path4.sep).filter((s) => s.length > 0);
   if (segments.length === 0 || segments[0] !== "artifacts") return abs;
   const tail = segments.slice(1);
-  return tail.length > 0 ? path3.join(wr, ".bluma", "artifacts", ...tail) : path3.join(wr, ".bluma", "artifacts");
+  return tail.length > 0 ? path4.join(wr, ".bluma", "artifacts", ...tail) : path4.join(wr, ".bluma", "artifacts");
 }
 function resolveWorkspacePath(inputPath, policy = getSandboxPolicy()) {
   const expanded = expandTilde(inputPath);
-  const candidate = path3.isAbsolute(expanded) ? path3.resolve(expanded) : path3.resolve(policy.workspaceRoot, expanded);
+  const candidate = path4.isAbsolute(expanded) ? path4.resolve(expanded) : path4.resolve(policy.workspaceRoot, expanded);
   if (policy.isSandbox && !isPathInsideWorkspace(candidate, policy)) {
-    throw new Error(
-      `Path "${inputPath}" escapes the sandbox workspace root ${policy.workspaceRoot}`
-    );
+    if (!isBlumaManagedMemoryPath(candidate)) {
+      throw new Error(
+        `Path "${inputPath}" escapes the sandbox workspace root ${policy.workspaceRoot}`
+      );
+    }
   }
   return redirectTopLevelArtifactsPath(candidate, policy.workspaceRoot);
 }
 function resolveCommandCwd(cwd2, policy = getSandboxPolicy()) {
   const expanded = cwd2 ? expandTilde(cwd2) : void 0;
-  const base = expanded ? path3.resolve(expanded) : policy.workspaceRoot;
+  const base = expanded ? path4.resolve(expanded) : policy.workspaceRoot;
   if (policy.isSandbox && !isPathInsideWorkspace(base, policy)) {
     throw new Error(
       `Command cwd "${base}" escapes the sandbox workspace root ${policy.workspaceRoot}`
@@ -373,6 +855,7 @@ var BLOCKED_COMMAND_PATTERNS, HIGH_RISK_COMMAND_PATTERNS, MODERATE_RISK_COMMAND_
 var init_sandbox_policy = __esm({
   "src/app/agent/runtime/sandbox_policy.ts"() {
     "use strict";
+    init_memory_access();
     init_runtime_config();
     init_permission_rules();
     BLOCKED_COMMAND_PATTERNS = [
@@ -407,10 +890,10 @@ var init_sandbox_policy = __esm({
 
 // src/app/agent/runtime/task_store.ts
 import fs10 from "fs";
-import path9 from "path";
+import path10 from "path";
 function getStorePath() {
   const policy = getSandboxPolicy();
-  return path9.join(policy.workspaceRoot, ".bluma", "task_state.json");
+  return path10.join(policy.workspaceRoot, ".bluma", "task_state.json");
 }
 function getDefaultState() {
   return {
@@ -446,7 +929,7 @@ function ensureLoaded() {
 }
 function persist(state2) {
   const storePath = getStorePath();
-  fs10.mkdirSync(path9.dirname(storePath), { recursive: true });
+  fs10.mkdirSync(path10.dirname(storePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs10.writeFileSync(storePath, JSON.stringify(state2, null, 2), "utf-8");
   cache2 = state2;
@@ -467,10 +950,10 @@ function updateTaskStore(mutator) {
 function calculateTaskStats(tasks) {
   const total = tasks.length;
   const pending = tasks.filter((t) => t.status === "pending").length;
-  const inProgress = tasks.filter((t) => t.status === "in_progress").length;
+  const inProgress2 = tasks.filter((t) => t.status === "in_progress").length;
   const completed = tasks.filter((t) => t.status === "completed").length;
   const progress = total > 0 ? Math.round(completed / total * 100) : 0;
-  return { total, pending, inProgress, completed, progress };
+  return { total, pending, inProgress: inProgress2, completed, progress };
 }
 function buildTaskSnapshot() {
   const state2 = ensureLoaded();
@@ -525,7 +1008,7 @@ __export(CommandStatusTool_exports, {
   runCommandAsync: () => runCommandAsync,
   sendCommandInput: () => sendCommandInput
 });
-import os9 from "os";
+import os10 from "os";
 import { spawn } from "child_process";
 import { v4 as uuidv43 } from "uuid";
 function normalizeCommandId(raw) {
@@ -576,7 +1059,7 @@ async function runCommandAsync(args) {
     const policy = getSandboxPolicy();
     const resolvedCwd = resolveCommandCwd(cwd2, policy);
     const commandId = uuidv43().substring(0, 8);
-    const platform = os9.platform();
+    const platform = os10.platform();
     let shellCmd;
     let shellArgs;
     if (platform === "win32") {
@@ -836,13 +1319,13 @@ __export(session_registry_exports, {
   updateSession: () => updateSession
 });
 import fs16 from "fs";
-import os11 from "os";
-import path17 from "path";
+import os12 from "os";
+import path18 from "path";
 function getRegistryDir() {
-  return path17.join(process.env.HOME || os11.homedir(), ".bluma", "registry");
+  return path18.join(process.env.HOME || os12.homedir(), ".bluma", "registry");
 }
 function getRegistryFile() {
-  return path17.join(getRegistryDir(), "sessions.json");
+  return path18.join(getRegistryDir(), "sessions.json");
 }
 function ensureRegistryDir() {
   fs16.mkdirSync(getRegistryDir(), { recursive: true });
@@ -865,7 +1348,7 @@ function writeRegistry(state2) {
 }
 function getSessionLogPath(sessionId) {
   ensureRegistryDir();
-  return path17.join(getRegistryDir(), `${sessionId}.jsonl`);
+  return path18.join(getRegistryDir(), `${sessionId}.jsonl`);
 }
 function registerSession(entry) {
   const state2 = readRegistry();
@@ -926,16 +1409,16 @@ var init_session_registry = __esm({
 
 // src/app/agent/utils/logger.ts
 import fs17 from "fs";
-import os12 from "os";
-import path18 from "path";
+import os13 from "os";
+import path19 from "path";
 function getLogDir() {
-  const dir = path18.join(process.env.HOME || os12.homedir(), ".bluma", "logs");
+  const dir = path19.join(process.env.HOME || os13.homedir(), ".bluma", "logs");
   fs17.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function getLogFilePath() {
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return path18.join(getLogDir(), `bluma-${today}.log`);
+  return path19.join(getLogDir(), `bluma-${today}.log`);
 }
 var BluMaLogger, logger;
 var init_logger = __esm({
@@ -1067,18 +1550,18 @@ __export(mailbox_registry_exports, {
   sendToMailbox: () => sendToMailbox
 });
 import fs18 from "fs";
-import os13 from "os";
-import path19 from "path";
+import os14 from "os";
+import path20 from "path";
 import { EventEmitter as EventEmitter3 } from "events";
 import { v4 as uuidv45 } from "uuid";
 function getMailboxesDir() {
   if (mailboxesDir) return mailboxesDir;
-  mailboxesDir = path19.join(process.env.HOME || os13.homedir(), ".bluma", "mailboxes");
+  mailboxesDir = path20.join(process.env.HOME || os14.homedir(), ".bluma", "mailboxes");
   fs18.mkdirSync(mailboxesDir, { recursive: true });
   return mailboxesDir;
 }
 function getMailboxPath(sessionId, type) {
-  return path19.join(getMailboxesDir(), `${sessionId}.${type}`);
+  return path20.join(getMailboxesDir(), `${sessionId}.${type}`);
 }
 function sendToMailbox(sessionId, type, message2) {
   return mailbox.sendToMailbox(sessionId, type, message2);
@@ -1179,7 +1662,7 @@ var init_mailbox_registry = __esm({
             }
             const type = file.split(".").pop();
             const sessionId = file.slice(0, -(type.length + 1));
-            const filePath = path19.join(dir, file);
+            const filePath = path20.join(dir, file);
             try {
               const content = fs18.readFileSync(filePath, "utf-8");
               const lines = content.trim().split("\n").filter(Boolean);
@@ -1281,7 +1764,7 @@ var init_mailbox_registry = __esm({
       ensureMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path19.join(dir, `${sessionId}.${type}`);
+          const filePath = path20.join(dir, `${sessionId}.${type}`);
           if (!fs18.existsSync(filePath)) {
             fs18.writeFileSync(filePath, "", "utf-8");
           }
@@ -1293,7 +1776,7 @@ var init_mailbox_registry = __esm({
       removeMailbox(sessionId) {
         const dir = getMailboxesDir();
         for (const type of ["in", "out", "sig"]) {
-          const filePath = path19.join(dir, `${sessionId}.${type}`);
+          const filePath = path20.join(dir, `${sessionId}.${type}`);
           if (fs18.existsSync(filePath)) fs18.unlinkSync(filePath);
         }
         this.queues.delete(sessionId);
@@ -1314,8 +1797,8 @@ __export(AgentCoordinationTool_exports, {
   waitAgent: () => waitAgent
 });
 import fs19 from "fs";
-import os14 from "os";
-import path20 from "path";
+import os15 from "os";
+import path21 from "path";
 import { spawn as spawn3 } from "child_process";
 import { v4 as uuidv46 } from "uuid";
 function readUserContextFromEnv() {
@@ -1429,8 +1912,8 @@ async function spawnAgent(args) {
     spawnLog.error("Payload NOT serializable", { error: e.message });
     throw new BluMaError("WORKER_CONTEXT_NOT_SERIALIZABLE" /* WORKER_CONTEXT_NOT_SERIALIZABLE */, `Worker context is not JSON-serializable: ${e.message}`);
   }
-  const payloadDir = fs19.mkdtempSync(path20.join(os14.tmpdir(), "bluma-worker-"));
-  const payloadPath = path20.join(payloadDir, `${sessionId}.json`);
+  const payloadDir = fs19.mkdtempSync(path21.join(os15.tmpdir(), "bluma-worker-"));
+  const payloadPath = path21.join(payloadDir, `${sessionId}.json`);
   try {
     fs19.writeFileSync(payloadPath, JSON.stringify(payload, null, 2), "utf-8");
     spawnLog.debug("Payload written", { payloadPath });
@@ -2201,11 +2684,11 @@ var NodeFsOperations = {
       if (fd) fs.closeSync(fd);
     }
   },
-  appendFileSync(path56, data, options) {
-    const _ = slowLogging`fs.appendFileSync(${path56}, ${data.length} chars)`;
+  appendFileSync(path57, data, options) {
+    const _ = slowLogging`fs.appendFileSync(${path57}, ${data.length} chars)`;
     if (options?.mode !== void 0) {
       try {
-        const fd = fs.openSync(path56, "ax", options.mode);
+        const fd = fs.openSync(path57, "ax", options.mode);
         try {
           fs.appendFileSync(fd, data);
         } finally {
@@ -2216,35 +2699,35 @@ var NodeFsOperations = {
         if (getErrnoCode(e) !== "EEXIST") throw e;
       }
     }
-    fs.appendFileSync(path56, data);
+    fs.appendFileSync(path57, data);
   },
   copyFileSync(src, dest) {
     const _ = slowLogging`fs.copyFileSync(${src} → ${dest})`;
     fs.copyFileSync(src, dest);
   },
-  unlinkSync(path56) {
-    const _ = slowLogging`fs.unlinkSync(${path56})`;
-    fs.unlinkSync(path56);
+  unlinkSync(path57) {
+    const _ = slowLogging`fs.unlinkSync(${path57})`;
+    fs.unlinkSync(path57);
   },
   renameSync(oldPath, newPath) {
     const _ = slowLogging`fs.renameSync(${oldPath} → ${newPath})`;
     fs.renameSync(oldPath, newPath);
   },
-  linkSync(target, path56) {
-    const _ = slowLogging`fs.linkSync(${target} → ${path56})`;
-    fs.linkSync(target, path56);
+  linkSync(target, path57) {
+    const _ = slowLogging`fs.linkSync(${target} → ${path57})`;
+    fs.linkSync(target, path57);
   },
-  symlinkSync(target, path56, type) {
-    const _ = slowLogging`fs.symlinkSync(${target} → ${path56})`;
-    fs.symlinkSync(target, path56, type);
+  symlinkSync(target, path57, type) {
+    const _ = slowLogging`fs.symlinkSync(${target} → ${path57})`;
+    fs.symlinkSync(target, path57, type);
   },
-  readlinkSync(path56) {
-    const _ = slowLogging`fs.readlinkSync(${path56})`;
-    return fs.readlinkSync(path56);
+  readlinkSync(path57) {
+    const _ = slowLogging`fs.readlinkSync(${path57})`;
+    return fs.readlinkSync(path57);
   },
-  realpathSync(path56) {
-    const _ = slowLogging`fs.realpathSync(${path56})`;
-    return fs.realpathSync(path56).normalize("NFC");
+  realpathSync(path57) {
+    const _ = slowLogging`fs.realpathSync(${path57})`;
+    return fs.realpathSync(path57).normalize("NFC");
   },
   mkdirSync(dirPath, options) {
     const _ = slowLogging`fs.mkdirSync(${dirPath})`;
@@ -2277,12 +2760,12 @@ var NodeFsOperations = {
     const _ = slowLogging`fs.rmdirSync(${dirPath})`;
     fs.rmdirSync(dirPath);
   },
-  rmSync(path56, options) {
-    const _ = slowLogging`fs.rmSync(${path56})`;
-    fs.rmSync(path56, options);
+  rmSync(path57, options) {
+    const _ = slowLogging`fs.rmSync(${path57})`;
+    fs.rmSync(path57, options);
   },
-  createWriteStream(path56) {
-    return fs.createWriteStream(path56);
+  createWriteStream(path57) {
+    return fs.createWriteStream(path57);
   },
   async readFileBytes(fsPath, maxBytes) {
     if (maxBytes === void 0) {
@@ -2389,12 +2872,12 @@ function shouldLogDebugMessage(message2) {
 var hasFormattedOutput = false;
 var debugWriter = null;
 var pendingWrite = Promise.resolve();
-async function appendAsync(needMkdir, dir, path56, content) {
+async function appendAsync(needMkdir, dir, path57, content) {
   if (needMkdir) {
     await mkdir(dir, { recursive: true }).catch(() => {
     });
   }
-  await appendFile(path56, content);
+  await appendFile(path57, content);
   void updateLatestDebugLogSymlink();
 }
 function noop() {
@@ -2404,8 +2887,8 @@ function getDebugWriter() {
     let ensuredDir = null;
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
-        const path56 = getDebugLogPath();
-        const dir = dirname(path56);
+        const path57 = getDebugLogPath();
+        const dir = dirname(path57);
         const needMkdir = ensuredDir !== dir;
         ensuredDir = dir;
         if (isDebugMode()) {
@@ -2415,11 +2898,11 @@ function getDebugWriter() {
             } catch {
             }
           }
-          getFsImplementation().appendFileSync(path56, content);
+          getFsImplementation().appendFileSync(path57, content);
           void updateLatestDebugLogSymlink();
           return;
         }
-        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path56, content)).catch(noop);
+        pendingWrite = pendingWrite.then(appendAsync.bind(null, needMkdir, dir, path57, content)).catch(noop);
       },
       flushIntervalMs: 1e3,
       maxBufferSize: 100,
@@ -4850,14 +5333,14 @@ var measure_text_default = measureText;
 var nodeCache = /* @__PURE__ */ new WeakMap();
 var pendingClears = /* @__PURE__ */ new WeakMap();
 var absoluteNodeRemoved = false;
-function addPendingClear(parent, rect, isAbsolute2) {
+function addPendingClear(parent, rect, isAbsolute3) {
   const existing = pendingClears.get(parent);
   if (existing) {
     existing.push(rect);
   } else {
     pendingClears.set(parent, [rect]);
   }
-  if (isAbsolute2) {
+  if (isAbsolute3) {
     absoluteNodeRemoved = true;
   }
 }
@@ -5130,14 +5613,14 @@ var removeChildNode = (node, removeNode) => {
 function collectRemovedRects(parent, removed, underAbsolute = false) {
   if (removed.nodeName === "#text") return;
   const elem = removed;
-  const isAbsolute2 = underAbsolute || elem.style.position === "absolute";
+  const isAbsolute3 = underAbsolute || elem.style.position === "absolute";
   const cached = nodeCache.get(elem);
   if (cached) {
-    addPendingClear(parent, cached, isAbsolute2);
+    addPendingClear(parent, cached, isAbsolute3);
     nodeCache.delete(elem);
   }
   for (const child of elem.childNodes) {
-    collectRemovedRects(parent, child, isAbsolute2);
+    collectRemovedRects(parent, child, isAbsolute3);
   }
 }
 var setAttribute = (node, key, value) => {
@@ -8606,8 +9089,8 @@ import codeExcerpt from "code-excerpt";
 import { readFileSync as readFileSync2 } from "fs";
 import StackUtils from "stack-utils";
 import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-var cleanupPath = (path56) => {
-  return path56?.replace(`file://${process.cwd()}/`, "");
+var cleanupPath = (path57) => {
+  return path57?.replace(`file://${process.cwd()}/`, "");
 };
 var stackUtils;
 function getStackUtils() {
@@ -10981,18 +11464,18 @@ function renderChildren(node, output, offsetX, offsetY, hasRemovedChild, prevScr
   for (const childNode of node.childNodes) {
     const childElem = childNode;
     const wasDirty = childElem.dirty;
-    const isAbsolute2 = childElem.style.position === "absolute";
+    const isAbsolute3 = childElem.style.position === "absolute";
     renderNodeToOutput(childElem, output, {
       offsetX,
       offsetY,
       prevScreen: hasRemovedChild || seenDirtyChild ? void 0 : prevScreen,
       // Short-circuits on seenDirtyClipped (false in the common case) so
       // the opaque/bg reads don't happen per-child per-frame.
-      skipSelfBlit: seenDirtyClipped && isAbsolute2 && !childElem.style.opaque && childElem.style.backgroundColor === void 0,
+      skipSelfBlit: seenDirtyClipped && isAbsolute3 && !childElem.style.opaque && childElem.style.backgroundColor === void 0,
       inheritedBackgroundColor
     });
     if (wasDirty && !seenDirtyChild) {
-      if (!clipsBothAxes(childElem) || isAbsolute2) {
+      if (!clipsBothAxes(childElem) || isAbsolute3) {
         seenDirtyChild = true;
       } else {
         seenDirtyClipped = true;
@@ -12584,8 +13067,8 @@ var getInstance = (stdout, createInstance) => {
 
 // src/main.ts
 import { EventEmitter as EventEmitter7 } from "events";
-import fs51 from "fs";
-import path55 from "path";
+import fs50 from "fs";
+import path56 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { spawn as spawn6 } from "child_process";
 import { v4 as uuidv412 } from "uuid";
@@ -13479,24 +13962,24 @@ function cancelSlashSubmenu() {
 
 // src/app/agent/agent.ts
 import * as dotenv from "dotenv";
-import path46 from "path";
-import os31 from "os";
+import path47 from "path";
+import os30 from "os";
 
 // src/app/agent/tool_invoker.ts
 import { promises as fs25 } from "fs";
-import path26 from "path";
+import path28 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/agent/tools/EditTool/EditTool.ts
 init_sandbox_policy();
-import path4 from "path";
-import os4 from "os";
+import path5 from "path";
+import os5 from "os";
 import { promises as fs4 } from "fs";
 import { diffLines } from "diff";
 function normalizePath(filePath) {
   try {
     filePath = filePath.trim();
-    if (os4.platform() === "win32") {
+    if (os5.platform() === "win32") {
       const winDriveRegex = /^\/([a-zA-Z])[:/]/;
       const match = filePath.match(winDriveRegex);
       if (match) {
@@ -13506,7 +13989,7 @@ function normalizePath(filePath) {
       }
       filePath = filePath.replace(/\//g, "\\");
     }
-    return path4.normalize(resolveWorkspacePath(filePath));
+    return path5.normalize(resolveWorkspacePath(filePath));
   } catch (e) {
     throw new Error(`Failed to normalize path "${filePath}": ${e.message}`);
   }
@@ -13794,7 +14277,7 @@ async function applyBatchEditsInMemory(edits, readFileState) {
         }
       };
     }
-    if (!norm.startsWith(workspaceRoot) && !path4.isAbsolute(e.file_path)) {
+    if (!norm.startsWith(workspaceRoot) && !path5.isAbsolute(e.file_path)) {
       return {
         ok: false,
         failed: {
@@ -13834,7 +14317,7 @@ async function applyBatchEditsInMemory(edits, readFileState) {
           };
         }
       }
-      const rel = path4.relative(workspaceRoot, norm);
+      const rel = path5.relative(workspaceRoot, norm);
       slots.set(norm, { norm, content, snapshotForDiff: content, rel });
     }
     const slot = slots.get(norm);
@@ -13869,7 +14352,7 @@ function buildBatchDiffAndPaths(slots) {
     const base = slot.snapshotForDiff ?? "";
     const finalC = slot.content ?? "";
     if (base === finalC) continue;
-    const fn = path4.basename(slot.norm);
+    const fn = path5.basename(slot.norm);
     diffChunks.push(createDiff(fn, base, finalC));
   }
   return {
@@ -13883,7 +14366,7 @@ async function runEditBatch(edits, readFileState) {
   if (!r.ok) return r.failed;
   const { slots, totalOcc, editsCount } = r;
   for (const slot of slots.values()) {
-    await fs4.mkdir(path4.dirname(slot.norm), { recursive: true });
+    await fs4.mkdir(path5.dirname(slot.norm), { recursive: true });
     await fs4.writeFile(slot.norm, slot.content ?? "", "utf-8");
   }
   const editResults = [];
@@ -13891,7 +14374,7 @@ async function runEditBatch(edits, readFileState) {
     const base = slot.snapshotForDiff ?? "";
     const finalC = slot.content ?? "";
     if (base === finalC) continue;
-    const fn = path4.basename(slot.norm);
+    const fn = path5.basename(slot.norm);
     editResults.push({
       file_path: slot.norm,
       diff: createDiff(fn, base, finalC),
@@ -13953,7 +14436,7 @@ async function editTool(args, readFileState) {
       };
     }
     const workspaceRoot = resolveWorkspacePath(".");
-    if (!normalizedFilePath.startsWith(workspaceRoot) && !path4.isAbsolute(file_path)) {
+    if (!normalizedFilePath.startsWith(workspaceRoot) && !path5.isAbsolute(file_path)) {
       return {
         success: false,
         error: `Invalid parameters: file_path must be within the current working directory or be an absolute path.`,
@@ -13985,10 +14468,10 @@ async function editTool(args, readFileState) {
         file_path: normalizedFilePath
       };
     }
-    await fs4.mkdir(path4.dirname(normalizedFilePath), { recursive: true });
+    await fs4.mkdir(path5.dirname(normalizedFilePath), { recursive: true });
     await fs4.writeFile(normalizedFilePath, editData.newContent, "utf-8");
-    const relativePath = path4.relative(workspaceRoot, normalizedFilePath);
-    const filename = path4.basename(normalizedFilePath);
+    const relativePath = path5.relative(workspaceRoot, normalizedFilePath);
+    const filename = path5.basename(normalizedFilePath);
     if (editData.isNewFile) {
       const finalDiff = createDiff(filename, "", editData.newContent);
       return {
@@ -14030,7 +14513,7 @@ import { v4 as uuidv42 } from "uuid";
 
 // src/app/agent/runtime/factorai_context.ts
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 function normalizeContext(raw) {
   if (!raw || typeof raw.appId !== "string" || !raw.appId.trim()) {
     return null;
@@ -14064,7 +14547,7 @@ function readJsonFile(filePath) {
   return null;
 }
 function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
-  const manifestPath = path5.join(projectDir, "factorai.sh.json");
+  const manifestPath = path6.join(projectDir, "factorai.sh.json");
   try {
     if (!fs5.existsSync(manifestPath)) {
       return null;
@@ -14076,7 +14559,7 @@ function readFactorAiWorkspaceManifest(projectDir = process.cwd()) {
   }
 }
 function readContextFromWorkspace() {
-  const candidate = path5.join(process.cwd(), "factorai.sh.json");
+  const candidate = path6.join(process.cwd(), "factorai.sh.json");
   const parsed = readJsonFile(candidate);
   if (!parsed) {
     return null;
@@ -14182,7 +14665,7 @@ function buildFactorAiWorkspaceManifest(input) {
 async function writeFactorAiWorkspaceManifest(input) {
   const projectDir = input.projectDir || process.cwd();
   const manifest = buildFactorAiWorkspaceManifest({ ...input, projectDir });
-  const manifestPath = path5.join(projectDir, "factorai.sh.json");
+  const manifestPath = path6.join(projectDir, "factorai.sh.json");
   fs5.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   return { manifestPath, manifest };
@@ -14194,7 +14677,7 @@ init_sandbox_policy();
 // src/app/agent/runtime/sandbox_message_validation.ts
 init_sandbox_policy();
 import fs6 from "fs";
-import path6 from "path";
+import path7 from "path";
 var HTTP_URL_PATTERN = /^https?:\/\//i;
 function normalizeAttachmentPath(entry) {
   if (typeof entry === "string") {
@@ -14274,8 +14757,8 @@ function validateSandboxMessageDeliverables(args, policy = getSandboxPolicy(), o
         details: `Create the deliverable first (file_write \u2192 .bluma/artifacts/...). Missing: ${resolved}`
       };
     }
-    const stat = fs6.statSync(resolved);
-    if (!stat.isFile()) {
+    const stat2 = fs6.statSync(resolved);
+    if (!stat2.isFile()) {
       return {
         ok: false,
         error: "Attachment must be a file",
@@ -14287,7 +14770,7 @@ function validateSandboxMessageDeliverables(args, policy = getSandboxPolicy(), o
       return {
         ok: false,
         error: "Files are delivered only via .bluma/artifacts/",
-        details: `Move or copy the deliverable to ${path6.relative(policy.workspaceRoot, artifactsDir2)}/ and pass that path in attachments[]. Rejected: ${raw}`
+        details: `Move or copy the deliverable to ${path7.relative(policy.workspaceRoot, artifactsDir2)}/ and pass that path in attachments[]. Rejected: ${raw}`
       };
     }
   }
@@ -14377,8 +14860,8 @@ function message(args) {
 
 // src/app/agent/tools/LsTool/LsTool.ts
 import { promises as fs7 } from "fs";
-import path7 from "path";
-import os5 from "os";
+import path8 from "path";
+import os6 from "os";
 import { minimatch } from "minimatch";
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".git",
@@ -14397,7 +14880,7 @@ var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
 ]);
 function expandPath(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path7.join(os5.homedir(), p.slice(2));
+    return path8.join(os6.homedir(), p.slice(2));
   }
   return p;
 }
@@ -14423,9 +14906,9 @@ async function ls(args) {
     max_depth
   } = args;
   try {
-    const basePath = path7.resolve(expandPath(directory_path));
-    const stat = await fs7.stat(basePath).catch(() => null);
-    if (!stat || !stat.isDirectory()) {
+    const basePath = path8.resolve(expandPath(directory_path));
+    const stat2 = await fs7.stat(basePath).catch(() => null);
+    if (!stat2 || !stat2.isDirectory()) {
       throw new Error(`Directory '${directory_path}' not found.`);
     }
     const allIgnorePatterns = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...ignore_patterns]);
@@ -14439,8 +14922,8 @@ async function ls(args) {
       const entries = await fs7.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         const entryName = entry.name;
-        const fullPath = path7.join(currentDir, entryName);
-        const relativePath = path7.relative(basePath, fullPath).split(path7.sep).join("/");
+        const fullPath = path8.join(currentDir, entryName);
+        const relativePath = path8.relative(basePath, fullPath).split(path8.sep).join("/");
         const isHidden = entryName.startsWith(".");
         if (shouldIgnore(entryName, allIgnorePatterns) || isHidden && !show_hidden) {
           continue;
@@ -14449,7 +14932,7 @@ async function ls(args) {
           allDirs.push(relativePath);
           if (recursive) await walk(fullPath, currentDepth + 1);
         } else if (entry.isFile()) {
-          if (!normalizedExtensions || normalizedExtensions.includes(path7.extname(entryName).toLowerCase())) {
+          if (!normalizedExtensions || normalizedExtensions.includes(path8.extname(entryName).toLowerCase())) {
             allFiles.push(relativePath);
           }
         }
@@ -14462,7 +14945,7 @@ async function ls(args) {
     const dirEnd = end_index ?? allDirs.length;
     return {
       success: true,
-      path: basePath.split(path7.sep).join("/"),
+      path: basePath.split(path8.sep).join("/"),
       recursive,
       total_files: allFiles.length,
       total_directories: allDirs.length,
@@ -14485,12 +14968,12 @@ async function ls(args) {
 // src/app/agent/tools/ReadLinesTool/ReadLinesTool.ts
 init_sandbox_policy();
 import { promises as fs8 } from "fs";
-import path8 from "path";
-import os6 from "os";
+import path9 from "path";
+import os7 from "os";
 var DEFAULT_LINE_WINDOW = 2e3;
 function expandPath2(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path8.join(os6.homedir(), p.slice(2));
+    return path9.join(os7.homedir(), p.slice(2));
   }
   return p;
 }
@@ -14508,8 +14991,8 @@ async function readLines(args) {
   }
   try {
     const resolvedPath = resolveWorkspacePath(expandPath2(filepath));
-    const stat = await fs8.stat(resolvedPath).catch(() => null);
-    if (!stat || !stat.isFile()) {
+    const stat2 = await fs8.stat(resolvedPath).catch(() => null);
+    if (!stat2 || !stat2.isFile()) {
       const workspaceRoot = resolveWorkspacePath(".");
       const isInsideWorkspace = resolvedPath.startsWith(workspaceRoot);
       const errorMsg = isInsideWorkspace ? `File '${filepath}' not found or is not a file.` : `File '${filepath}' resolves to '${resolvedPath}' which is outside the workspace root '${workspaceRoot}'. Use relative paths within the workspace.`;
@@ -14775,9 +15258,9 @@ function formatTodoResult(result) {
 
 // src/app/agent/tools/FindByNameTool/FindByNameTool.ts
 init_sandbox_policy();
-import path10 from "path";
+import path11 from "path";
 import { promises as fsPromises } from "fs";
-import os7 from "os";
+import os8 from "os";
 var MAX_RESULTS = 100;
 var MAX_DEPTH_DEFAULT = 10;
 var DEFAULT_IGNORE2 = /* @__PURE__ */ new Set([
@@ -14798,8 +15281,8 @@ var DEFAULT_IGNORE2 = /* @__PURE__ */ new Set([
   "vendor"
 ]);
 function expandTilde2(p) {
-  if (p === "~") return os7.homedir();
-  if (p.startsWith("~/")) return path10.join(os7.homedir(), p.slice(2));
+  if (p === "~") return os8.homedir();
+  if (p.startsWith("~/")) return path11.join(os8.homedir(), p.slice(2));
   return p;
 }
 function globToRegex(glob) {
@@ -14843,7 +15326,7 @@ function shouldIgnore2(name, extraPatterns, includeHidden) {
 }
 function matchesExtensions(filename, extensions) {
   if (!extensions || extensions.length === 0) return true;
-  const ext = path10.extname(filename).toLowerCase();
+  const ext = path11.extname(filename).toLowerCase();
   return extensions.some((e) => {
     const norm = e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`;
     return ext === norm;
@@ -14861,8 +15344,8 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
     if (results.length >= MAX_RESULTS) break;
     const { name } = entry;
     if (shouldIgnore2(name, options.excludePatterns, options.includeHidden)) continue;
-    const fullPath = path10.join(dir, name);
-    const relativePath = path10.relative(baseDir, fullPath).split(path10.sep).join("/");
+    const fullPath = path11.join(dir, name);
+    const relativePath = path11.relative(baseDir, fullPath).split(path11.sep).join("/");
     if (entry.isDirectory()) {
       if (pattern.test(name)) {
         results.push({ path: relativePath, type: "directory" });
@@ -14876,9 +15359,9 @@ async function searchDirectory(dir, pattern, baseDir, options, results) {
       const result = { path: relativePath, type: "file" };
       if (options.includeStats) {
         try {
-          const stat = await fsPromises.stat(fullPath);
-          result.size = stat.size;
-          result.modified = stat.mtime.toISOString();
+          const stat2 = await fsPromises.stat(fullPath);
+          result.size = stat2.size;
+          result.modified = stat2.mtime.toISOString();
         } catch {
         }
       }
@@ -14944,9 +15427,9 @@ async function findByName(args) {
 }
 
 // src/app/agent/tools/GrepSearchTool/GrepSearchTool.ts
-import path11 from "path";
+import path12 from "path";
 import { promises as fsPromises2 } from "fs";
-import os8 from "os";
+import os9 from "os";
 var MAX_RESULTS2 = 200;
 var MAX_MATCHES_PER_FILE = 10;
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -15033,13 +15516,13 @@ var TEXT_BASENAMES = /* @__PURE__ */ new Set([
   "Rakefile"
 ]);
 function expandTilde3(p) {
-  if (p === "~") return os8.homedir();
-  if (p.startsWith("~/")) return path11.join(os8.homedir(), p.slice(2));
+  if (p === "~") return os9.homedir();
+  if (p.startsWith("~/")) return path12.join(os9.homedir(), p.slice(2));
   return p;
 }
 function isTextFile(filepath) {
-  const ext = path11.extname(filepath).toLowerCase();
-  const base = path11.basename(filepath);
+  const ext = path12.extname(filepath).toLowerCase();
+  const base = path12.basename(filepath);
   return TEXT_EXTENSIONS.has(ext) || TEXT_BASENAMES.has(base) || base.startsWith(".") && !ext;
 }
 function shouldIgnore3(name) {
@@ -15072,11 +15555,11 @@ function createSearchPattern(query, isRegex, caseInsensitive) {
 }
 async function searchFile(filepath, baseDir, pattern, contextLines, maxMatchesPerFile) {
   try {
-    const stat = await fsPromises2.stat(filepath);
-    if (stat.size > MAX_FILE_SIZE) return null;
+    const stat2 = await fsPromises2.stat(filepath);
+    if (stat2.size > MAX_FILE_SIZE) return null;
     const content = await fsPromises2.readFile(filepath, "utf-8");
     const lines = content.split("\n");
-    const relativePath = path11.relative(baseDir, filepath).split(path11.sep).join("/");
+    const relativePath = path12.relative(baseDir, filepath).split(path12.sep).join("/");
     const matches = [];
     for (let i = 0; i < lines.length && matches.length < maxMatchesPerFile; i++) {
       const line = lines[i];
@@ -15110,7 +15593,7 @@ async function searchDirectory2(dir, baseDir, pattern, includePatterns, contextL
   for (const entry of entries) {
     if (stats.totalMatches >= maxResults) break;
     if (shouldIgnore3(entry.name)) continue;
-    const fullPath = path11.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory2(fullPath, baseDir, pattern, includePatterns, contextLines, maxResults, maxMatchesPerFile, results, stats);
     } else if (entry.isFile()) {
@@ -15151,9 +15634,9 @@ async function grepSearch(args) {
   });
   if (!query || typeof query !== "string") return empty("query is required");
   if (!searchPath) return empty("path is required");
-  const resolvedPath = path11.resolve(expandTilde3(searchPath));
-  const stat = await fsPromises2.stat(resolvedPath).catch(() => null);
-  if (!stat) return empty(`Path not found: ${resolvedPath}`);
+  const resolvedPath = path12.resolve(expandTilde3(searchPath));
+  const stat2 = await fsPromises2.stat(resolvedPath).catch(() => null);
+  if (!stat2) return empty(`Path not found: ${resolvedPath}`);
   let pattern;
   try {
     pattern = createSearchPattern(query, is_regex, case_insensitive);
@@ -15163,11 +15646,11 @@ async function grepSearch(args) {
   const results = [];
   const stats = { filesSearched: 0, totalMatches: 0 };
   try {
-    if (stat.isDirectory()) {
+    if (stat2.isDirectory()) {
       await searchDirectory2(resolvedPath, resolvedPath, pattern, include_patterns, context_lines, max_results, max_matches_per_file, results, stats);
-    } else if (stat.isFile()) {
+    } else if (stat2.isFile()) {
       stats.filesSearched = 1;
-      const fileResult = await searchFile(resolvedPath, path11.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
+      const fileResult = await searchFile(resolvedPath, path12.dirname(resolvedPath), pattern, context_lines, max_matches_per_file);
       if (fileResult) {
         results.push(fileResult);
         stats.totalMatches = fileResult.match_count;
@@ -15190,7 +15673,7 @@ async function grepSearch(args) {
 }
 
 // src/app/agent/tools/ViewFileOutlineTool/ViewFileOutlineTool.ts
-import path12 from "path";
+import path13 from "path";
 import { promises as fsPromises3 } from "fs";
 var LANGUAGE_MAP = {
   ".ts": "typescript",
@@ -15304,7 +15787,7 @@ var PATTERNS = {
   ]
 };
 function detectLanguage(filepath) {
-  const ext = path12.extname(filepath).toLowerCase();
+  const ext = path13.extname(filepath).toLowerCase();
   return LANGUAGE_MAP[ext] || "unknown";
 }
 function determineItemType(line, language) {
@@ -15400,7 +15883,7 @@ async function viewFileOutline(args) {
         error: "file_path is required and must be a string"
       };
     }
-    const resolvedPath = path12.resolve(file_path);
+    const resolvedPath = path13.resolve(file_path);
     let content;
     try {
       content = await fsPromises3.readFile(resolvedPath, "utf-8");
@@ -15446,21 +15929,21 @@ init_CommandStatusTool();
 // src/app/agent/tools/TaskBoundaryTool/TaskBoundaryTool.ts
 init_sandbox_policy();
 init_task_store();
-import path13 from "path";
+import path14 from "path";
 import { promises as fs11 } from "fs";
 var artifactsDir = null;
 async function getArtifactsDir() {
   if (artifactsDir) return artifactsDir;
   const policy = getSandboxPolicy();
-  const baseDir = path13.join(policy.workspaceRoot, ".bluma", "artifacts");
+  const baseDir = path14.join(policy.workspaceRoot, ".bluma", "artifacts");
   const sessionId = Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
-  artifactsDir = path13.join(baseDir, sessionId);
+  artifactsDir = path14.join(baseDir, sessionId);
   await fs11.mkdir(artifactsDir, { recursive: true });
   return artifactsDir;
 }
 async function updateTaskFile(task) {
   const dir = await getArtifactsDir();
-  const taskFile = path13.join(dir, "task.md");
+  const taskFile = path14.join(dir, "task.md");
   const content = `# ${task.taskName}
 
         **Mode:** ${task.mode}  
@@ -15588,7 +16071,7 @@ async function readArtifact(args) {
       return { success: false, error: "filename is required" };
     }
     const dir = await getArtifactsDir();
-    const filepath = path13.join(dir, filename);
+    const filepath = path14.join(dir, filename);
     const content = await fs11.readFile(filepath, "utf-8");
     return {
       success: true,
@@ -16134,8 +16617,8 @@ ${skill.content}`;
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryTool.ts
 import * as fs12 from "fs";
-import * as path14 from "path";
-import os10 from "os";
+import * as path15 from "path";
+import os11 from "os";
 var PROMPT_DEFAULT_MAX_TOTAL = 1e4;
 var PROMPT_DEFAULT_MAX_NOTES = 25;
 var PROMPT_DEFAULT_PREVIEW = 500;
@@ -16143,13 +16626,13 @@ function readCodingMemoryForPrompt(options) {
   const maxTotal = options?.maxTotalChars ?? PROMPT_DEFAULT_MAX_TOTAL;
   const maxNotes = options?.maxNotes ?? PROMPT_DEFAULT_MAX_NOTES;
   const preview = options?.previewCharsPerNote ?? PROMPT_DEFAULT_PREVIEW;
-  const globalPath = path14.join(os10.homedir(), ".bluma", "coding_memory.json");
-  const legacyPath = path14.join(process.cwd(), ".bluma", "coding_memory.json");
+  const globalPath = path15.join(os11.homedir(), ".bluma", "coding_memory.json");
+  const legacyPath = path15.join(process.cwd(), ".bluma", "coding_memory.json");
   let raw = null;
   try {
     if (fs12.existsSync(globalPath)) {
       raw = fs12.readFileSync(globalPath, "utf-8");
-    } else if (path14.resolve(globalPath) !== path14.resolve(legacyPath) && fs12.existsSync(legacyPath)) {
+    } else if (path15.resolve(globalPath) !== path15.resolve(legacyPath) && fs12.existsSync(legacyPath)) {
       raw = fs12.readFileSync(legacyPath, "utf-8");
     }
   } catch {
@@ -16188,10 +16671,10 @@ var memoryStore = [];
 var nextId = 1;
 var loaded = false;
 function getMemoryFilePath() {
-  return path14.join(os10.homedir(), ".bluma", "coding_memory.json");
+  return path15.join(os11.homedir(), ".bluma", "coding_memory.json");
 }
 function getLegacyMemoryFilePath() {
-  return path14.join(process.cwd(), ".bluma", "coding_memory.json");
+  return path15.join(process.cwd(), ".bluma", "coding_memory.json");
 }
 function loadMemoryFromFile() {
   if (loaded) return;
@@ -16201,7 +16684,7 @@ function loadMemoryFromFile() {
   try {
     const filePath = getMemoryFilePath();
     const legacy = getLegacyMemoryFilePath();
-    const legacyDistinct = path14.resolve(legacy) !== path14.resolve(filePath);
+    const legacyDistinct = path15.resolve(legacy) !== path15.resolve(filePath);
     const readIntoStore = (p) => {
       const raw = fs12.readFileSync(p, "utf-8");
       const parsed = JSON.parse(raw);
@@ -16227,7 +16710,7 @@ function loadMemoryFromFile() {
 function saveMemoryToFile() {
   try {
     const filePath = getMemoryFilePath();
-    const dir = path14.dirname(filePath);
+    const dir = path15.dirname(filePath);
     if (!fs12.existsSync(dir)) {
       fs12.mkdirSync(dir, { recursive: true });
     }
@@ -16849,7 +17332,7 @@ async function notebook_edit(args) {
 init_sandbox_policy();
 import { spawn as spawn2 } from "child_process";
 import * as fs14 from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 import { pathToFileURL } from "url";
 var RpcBuffer = class {
   buf = Buffer.alloc(0);
@@ -16858,9 +17341,9 @@ var RpcBuffer = class {
   }
   takeMessages() {
     const out = [];
-    const sep = Buffer.from("\r\n\r\n");
+    const sep4 = Buffer.from("\r\n\r\n");
     while (true) {
-      const idx = this.buf.indexOf(sep);
+      const idx = this.buf.indexOf(sep4);
       if (idx === -1) break;
       const header = this.buf.slice(0, idx).toString("utf-8");
       const m = header.match(/Content-Length:\s*(\d+)/i);
@@ -16904,7 +17387,7 @@ async function lsp_query(args) {
   }
   const content = fs14.readFileSync(resolved, "utf-8");
   const uri = pathToFileURL(resolved).href;
-  const root = path15.dirname(resolved);
+  const root = path16.dirname(resolved);
   const line0 = Math.max(0, Math.floor(Number(args.line) || 1) - 1);
   const character = Math.max(0, Math.floor(Number(args.character ?? 0)));
   const operation = args.operation === "references" ? "references" : "definition";
@@ -17025,7 +17508,7 @@ async function lsp_query(args) {
 // src/app/agent/tools/FileWriteTool/FileWriteTool.ts
 init_sandbox_policy();
 import { promises as fs15 } from "fs";
-import path16 from "path";
+import path17 from "path";
 async function fileWrite(args) {
   const {
     filepath,
@@ -17043,7 +17526,7 @@ async function fileWrite(args) {
       return { success: false, error: "content is required" };
     }
     const resolvedPath = resolveWorkspacePath(targetPath);
-    const dir = path16.dirname(resolvedPath);
+    const dir = path17.dirname(resolvedPath);
     let existed = false;
     try {
       const st = await fs15.stat(resolvedPath);
@@ -17378,8 +17861,8 @@ async function signalMailbox(args) {
 
 // src/app/agent/tools/ReplTool/ReplTool.ts
 import fs20 from "fs";
-import os15 from "os";
-import path21 from "path";
+import os16 from "os";
+import path22 from "path";
 import { exec } from "child_process";
 import { v4 as uuidv47 } from "uuid";
 import { promisify } from "util";
@@ -17391,19 +17874,19 @@ async function repl(params) {
   let tempFile;
   switch (language) {
     case "python": {
-      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.py`);
+      tempFile = path22.join(os16.tmpdir(), `bluma_repl_${uuidv47()}.py`);
       fs20.writeFileSync(tempFile, code, "utf-8");
       command = `python3 "${tempFile}"`;
       break;
     }
     case "node": {
-      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
+      tempFile = path22.join(os16.tmpdir(), `bluma_repl_${uuidv47()}.mjs`);
       fs20.writeFileSync(tempFile, code, "utf-8");
       command = `node "${tempFile}"`;
       break;
     }
     case "bash": {
-      tempFile = path21.join(os15.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
+      tempFile = path22.join(os16.tmpdir(), `bluma_repl_${uuidv47()}.sh`);
       fs20.writeFileSync(tempFile, `#!/bin/bash
 set -e
 ${code}`, "utf-8");
@@ -17797,7 +18280,7 @@ ${preview}${toRemove.length > 5 ? `
 // src/app/agent/tools/BriefTool/BriefTool.ts
 init_sandbox_policy();
 import * as fs21 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 async function brief(args) {
   const sentAt = (/* @__PURE__ */ new Date()).toISOString();
   if (!args.message || !args.message.trim()) {
@@ -17816,12 +18299,12 @@ async function brief(args) {
     const resolved = [];
     for (const filePath of args.attachments) {
       try {
-        const absolutePath = path22.isAbsolute(filePath) ? filePath : path22.join(resolveWorkspacePath("."), filePath);
+        const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.join(resolveWorkspacePath("."), filePath);
         if (fs21.existsSync(absolutePath)) {
-          const stat = fs21.statSync(absolutePath);
+          const stat2 = fs21.statSync(absolutePath);
           resolved.push({
             path: absolutePath,
-            size: stat.size,
+            size: stat2.size,
             exists: true
           });
         } else {
@@ -17858,13 +18341,13 @@ async function brief(args) {
 
 // src/app/agent/tools/DreamEngineTool/DreamEngineTool.ts
 import * as fs22 from "fs";
-import * as path23 from "path";
-import os16 from "os";
+import * as path24 from "path";
+import os17 from "os";
 function memoryPath() {
-  return path23.join(process.env.HOME || os16.homedir(), ".bluma", "coding_memory.json");
+  return path24.join(process.env.HOME || os17.homedir(), ".bluma", "coding_memory.json");
 }
 function sessionsDir() {
-  return path23.join(process.env.HOME || os16.homedir(), ".bluma", "sessions");
+  return path24.join(process.env.HOME || os17.homedir(), ".bluma", "sessions");
 }
 function normalizeNote(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -17973,7 +18456,7 @@ async function dream(args = {}) {
       const sessionFiles = fs22.readdirSync(sessDir).filter((f) => f.endsWith(".json")).slice(-5);
       for (const sf of sessionFiles) {
         try {
-          const sessionData = JSON.parse(fs22.readFileSync(path23.join(sessDir, sf), "utf-8"));
+          const sessionData = JSON.parse(fs22.readFileSync(path24.join(sessDir, sf), "utf-8"));
           if (sessionData?.summary) {
             consolidatedMemories.push(`Session ${sf}: ${sessionData.summary}`);
           }
@@ -18182,11 +18665,11 @@ async function context_collapse(args = {}) {
 // src/app/agent/tools/CreateNextAppTool/CreateNextAppTool.ts
 init_sandbox_policy();
 import { promises as fs23 } from "fs";
-import path24 from "path";
+import path25 from "path";
 
 // src/app/agent/tools/ShellCommandTool/ShellCommandTool.ts
 init_sandbox_policy();
-import os17 from "os";
+import os18 from "os";
 import { spawn as spawn4 } from "child_process";
 var MAX_OUTPUT_SIZE2 = 3e4;
 var MAX_OUTPUT_LINES = 200;
@@ -18267,7 +18750,7 @@ function shellCommand(args) {
   } = args;
   return new Promise((resolve2) => {
     const startTime = Date.now();
-    const platform = os17.platform();
+    const platform = os18.platform();
     const commandTrimmed = command.trim();
     let resolvedCwd;
     try {
@@ -18982,7 +19465,7 @@ export function cn(...inputs: ClassValue[]) {
 `
 };
 async function createFile(filePath, content, projectName) {
-  const dir = path24.dirname(filePath);
+  const dir = path25.dirname(filePath);
   await fs23.mkdir(dir, { recursive: true });
   const replacedContent = content.replace(/{{NAME}}/g, projectName);
   await fs23.writeFile(filePath, replacedContent, "utf-8");
@@ -19004,7 +19487,7 @@ async function createNextApp(args) {
       };
     }
     const baseDir = directory ? resolveWorkspacePath(directory) : resolveWorkspacePath(".");
-    const projectPath = path24.join(baseDir, name);
+    const projectPath = path25.join(baseDir, name);
     try {
       await fs23.access(projectPath);
       return {
@@ -19018,12 +19501,12 @@ async function createNextApp(args) {
     const filesCreated = [];
     for (const [relativePath, content] of Object.entries(filesToCreate)) {
       if (relativePath === "package.json.full") continue;
-      const fullPath = path24.join(projectPath, relativePath);
+      const fullPath = path25.join(projectPath, relativePath);
       await createFile(fullPath, content, name);
       filesCreated.push(relativePath);
     }
     if (template === "full") {
-      const packageJsonPath = path24.join(projectPath, "package.json");
+      const packageJsonPath = path25.join(projectPath, "package.json");
       const fullPackageJson = FULL_FILES["package.json.full"];
       if (fullPackageJson) {
         await createFile(packageJsonPath, fullPackageJson, name);
@@ -19066,11 +19549,13 @@ async function createNextApp(args) {
 // src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 init_sandbox_policy();
 import { promises as fs24 } from "fs";
-import path25 from "path";
-function shQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-var EXCLUDE_PATTERNS = [
+import path27 from "path";
+
+// src/app/agent/tools/DeployAppTool/createDeployProjectZip.ts
+import { lstat, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import path26 from "path";
+import { minimatch as minimatch2 } from "minimatch";
+var DEPLOY_ZIP_EXCLUDE_PATTERNS = [
   "node_modules",
   ".next",
   ".git",
@@ -19083,62 +19568,116 @@ var EXCLUDE_PATTERNS = [
   ".env*.local",
   "coverage",
   ".vercel",
-  ".turbo"
+  ".turbo",
+  ".tmp"
 ];
-function zipExcludeArg(pattern) {
-  if (pattern.includes("*") || pattern.startsWith(".")) {
-    return pattern;
-  }
-  return `${pattern}/*`;
-}
-async function createProjectZip(projectDir, zipPath) {
-  const excludeFlags = EXCLUDE_PATTERNS.flatMap((pattern) => ["-x", zipExcludeArg(pattern)]);
-  const zipCommand = ["zip", "-r", shQuote(zipPath), ".", ...excludeFlags.map(shQuote)].join(" ");
-  const result = await shellCommand({
-    command: zipCommand,
-    cwd: projectDir,
-    timeout: 120
-    // 2 minutos para zippar
-  });
-  const resultJson = JSON.parse(result);
-  if (resultJson.status !== "success") {
-    throw new Error(`Failed to create ZIP: ${resultJson.stderr}`);
+function pathSegments(relativePosix) {
+  return relativePosix.split("/").filter(Boolean);
+}
+function shouldExcludeFromDeployZip(relativePosix, isDirectory) {
+  const rel = relativePosix.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!rel) return false;
+  const segments = pathSegments(rel);
+  const baseName = path26.posix.basename(rel);
+  for (const pattern of DEPLOY_ZIP_EXCLUDE_PATTERNS) {
+    if (pattern.includes("*")) {
+      if (minimatch2(rel, pattern) || minimatch2(baseName, pattern)) {
+        return true;
+      }
+      continue;
+    }
+    if (segments.includes(pattern)) {
+      return true;
+    }
+    if (!isDirectory && baseName === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+async function collectDeployZipEntries(projectDir, files) {
+  const base = path26.resolve(projectDir);
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path26.join(currentDir, entry.name);
+      const rel = path26.relative(base, fullPath).replace(/\\/g, "/");
+      if (shouldExcludeFromDeployZip(rel, entry.isDirectory())) {
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        try {
+          const st = await lstat(fullPath);
+          if (st.isDirectory()) continue;
+        } catch {
+          continue;
+        }
+      }
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      try {
+        const content = await readFile2(fullPath);
+        files[rel] = new Uint8Array(content);
+      } catch {
+      }
+    }
   }
+  await walk(base);
+}
+async function createDeployProjectZip(projectDir, zipPath) {
+  const files = {};
+  await collectDeployZipEntries(projectDir, files);
+  const fileCount = Object.keys(files).length;
+  if (fileCount === 0) {
+    throw new Error("No files to include in deploy ZIP (check project directory and exclusions)");
+  }
+  const { zipSync } = await import("fflate");
+  const zipData = zipSync(files, { level: 6 });
+  await writeFile(zipPath, zipData);
   return zipPath;
 }
+
+// src/app/agent/tools/DeployAppTool/DeployAppTool.ts
 async function uploadToSeverino(zipPath, severinoUrl, name, apiKey, appId) {
   const deployUrl = `${severinoUrl.replace(/\/$/, "")}/api/v1/deploy`;
-  const curlArgs = [
-    "-sS",
-    "-X",
-    "POST",
-    deployUrl,
-    "-F",
-    `file=@${zipPath}`
-  ];
-  if (name) {
-    curlArgs.push("-F", `name=${name}`);
-  }
-  if (appId) {
-    curlArgs.push("-F", `appId=${appId}`);
-  }
+  const zipBytes = await fs24.readFile(zipPath);
+  const form = new FormData();
+  form.append(
+    "file",
+    new Blob([zipBytes], { type: "application/zip" }),
+    path27.basename(zipPath)
+  );
+  if (name) form.append("name", name);
+  if (appId) form.append("appId", appId);
+  const headers = { Accept: "application/json" };
   if (apiKey) {
-    curlArgs.push("-H", `Authorization: Bearer ${apiKey}`);
-    curlArgs.push("-H", `X-API-Key: ${apiKey}`);
-  }
-  curlArgs.push("-H", "Accept: application/json");
-  const curlCommand = `curl ${curlArgs.map(shQuote).join(" ")}`;
-  const result = await shellCommand({
-    command: curlCommand,
-    timeout: 60
-    // 1 minuto para upload
+    headers.Authorization = `Bearer ${apiKey}`;
+    headers["X-API-Key"] = apiKey;
+  }
+  const httpResponse = await fetch(deployUrl, {
+    method: "POST",
+    body: form,
+    headers,
+    signal: AbortSignal.timeout(12e4)
   });
-  const resultJson = JSON.parse(result);
-  if (resultJson.status !== "success") {
-    throw new Error(`Upload failed: ${resultJson.stderr}`);
+  const responseText = await httpResponse.text();
+  if (!httpResponse.ok) {
+    throw new Error(
+      `Upload failed (${httpResponse.status}): ${responseText.slice(0, 500)}`
+    );
   }
   try {
-    const response = JSON.parse(resultJson.stdout);
+    const response = JSON.parse(responseText);
     if (response.success === false || response.error) {
       const errorMsg = typeof response.error === "string" ? response.error : response.error?.message || "Deploy failed";
       return {
@@ -19225,7 +19764,7 @@ function buildFactorAiManifest(appContext, deployResult, appName) {
 }
 async function writeFactorAiManifest(projectDir, appContext, deployResult, appName) {
   const manifest = buildFactorAiManifest(appContext, deployResult, appName);
-  const manifestPath = path25.join(projectDir, "factorai.sh.json");
+  const manifestPath = path27.join(projectDir, "factorai.sh.json");
   await fs24.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return manifest;
@@ -19253,7 +19792,7 @@ async function deployApp(args) {
         error: `Project directory not found: ${resolvedProjectDir}`
       };
     }
-    const packageJsonPath = path25.join(resolvedProjectDir, "package.json");
+    const packageJsonPath = path27.join(resolvedProjectDir, "package.json");
     try {
       await fs24.access(packageJsonPath);
     } catch {
@@ -19271,12 +19810,12 @@ async function deployApp(args) {
         error: "Not a Next.js project: next not found in dependencies"
       };
     }
-    const appName = name || packageJson.name || path25.basename(resolvedProjectDir);
-    const tempDir = path25.join(resolvedProjectDir, ".tmp");
+    const appName = name || packageJson.name || path27.basename(resolvedProjectDir);
+    const tempDir = path27.join(resolvedProjectDir, ".tmp");
     await fs24.mkdir(tempDir, { recursive: true });
-    const zipPath = path25.join(tempDir, `${appName}-${Date.now()}.zip`);
+    const zipPath = path27.join(tempDir, `${appName}-${Date.now()}.zip`);
     console.log(`[deploy-app] Creating ZIP: ${zipPath}`);
-    await createProjectZip(resolvedProjectDir, zipPath);
+    await createDeployProjectZip(resolvedProjectDir, zipPath);
     const zipStats = await fs24.stat(zipPath);
     const zipSizeMB = zipStats.size / 1024 / 1024;
     if (zipSizeMB > 50) {
@@ -19307,7 +19846,7 @@ async function deployApp(args) {
           appName
         );
         deployResult.factoraiManifest = manifest;
-        deployResult.factoraiManifestPath = path25.join(resolvedProjectDir, "factorai.sh.json");
+        deployResult.factoraiManifestPath = path27.join(resolvedProjectDir, "factorai.sh.json");
       }
       console.log(`[deploy-app] Deploy iniciado: ${deployResult.appId}`);
     }
@@ -20389,11 +20928,11 @@ var ToolInvoker = class {
   async initialize() {
     try {
       const currentFilePath = fileURLToPath(import.meta.url);
-      const currentDirPath = path26.dirname(currentFilePath);
-      const configPath = path26.resolve(currentDirPath, "config", "native_tools.json");
+      const currentDirPath = path28.dirname(currentFilePath);
+      const configPath = path28.resolve(currentDirPath, "config", "native_tools.json");
       const fileContent = await fs25.readFile(configPath, "utf-8");
-      const config2 = JSON.parse(fileContent);
-      this.toolDefinitions = applyMetadataToToolDefinitions(config2.nativeTools);
+      const config3 = JSON.parse(fileContent);
+      this.toolDefinitions = applyMetadataToToolDefinitions(config3.nativeTools);
       const sandboxOnlyTools = applyMetadataToToolDefinitions(getSandboxOnlyNativeToolDefinitions());
       this.toolDefinitions.push(...sandboxOnlyTools);
     } catch (error) {
@@ -20439,8 +20978,8 @@ var ToolInvoker = class {
 
 // src/app/agent/tools/mcp/mcp_client.ts
 import { promises as fs26 } from "fs";
-import path27 from "path";
-import os18 from "os";
+import path29 from "path";
+import os19 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -20467,9 +21006,9 @@ var MCPClient = class {
       });
     }
     const __filename = fileURLToPath2(import.meta.url);
-    const __dirname2 = path27.dirname(__filename);
-    const defaultConfigPath = path27.resolve(__dirname2, "config", "bluma-mcp.json");
-    const userConfigPath = path27.join(os18.homedir(), ".bluma", "bluma-mcp.json");
+    const __dirname2 = path29.dirname(__filename);
+    const defaultConfigPath = path29.resolve(__dirname2, "config", "bluma-mcp.json");
+    const userConfigPath = path29.join(os19.homedir(), ".bluma", "bluma-mcp.json");
     const defaultConfig = await this.loadMcpConfig(defaultConfigPath, "Default");
     const userConfig = await this.loadMcpConfig(userConfigPath, "User");
     const mergedConfig = {
@@ -20519,10 +21058,10 @@ var MCPClient = class {
   /**
    * Conecta-se a um servidor MCP baseado em Stdio, adaptando o comando para o SO atual.
    */
-  async connectToStdioServer(serverName, config2) {
-    let commandToExecute = config2.command;
-    let argsToExecute = config2.args || [];
-    const isWindows = os18.platform() === "win32";
+  async connectToStdioServer(serverName, config3) {
+    let commandToExecute = config3.command;
+    let argsToExecute = config3.args || [];
+    const isWindows = os19.platform() === "win32";
     if (!isWindows && commandToExecute.toLowerCase() === "cmd") {
       if (argsToExecute.length >= 2 && argsToExecute[0].toLowerCase() === "/c") {
         commandToExecute = argsToExecute[1];
@@ -20537,7 +21076,7 @@ var MCPClient = class {
       // Usa o comando adaptado
       args: argsToExecute,
       // Usa os argumentos adaptados
-      env: config2.env
+      env: config3.env
     });
     const mcp = new Client({ name: `bluma-cli-client-for-${serverName}`, version: "1.0.0" });
     await mcp.connect(transport);
@@ -20715,39 +21254,22 @@ PENALTY APPLIED: ${penalty.toFixed(1)} points deducted.
 };
 
 // src/app/agent/bluma/core/bluma.ts
-import path43 from "path";
-import fs40 from "fs";
+import path44 from "path";
+import fs39 from "fs";
 import { v4 as uuidv48 } from "uuid";
 
 // src/app/agent/session_manager/session_manager.ts
-import path31 from "path";
+import path32 from "path";
 import { promises as fs29 } from "fs";
 
 // src/app/agent/session_manager/agent_session_paths.ts
-import path30 from "path";
+init_bluma_app_dir();
+import path31 from "path";
 import { promises as fs28 } from "fs";
 
-// src/app/agent/session_manager/bluma_app_dir.ts
-import path28 from "path";
-import os19 from "os";
-function expandHome(p) {
-  if (!p) return p;
-  if (p.startsWith("~")) {
-    return path28.join(os19.homedir(), p.slice(1));
-  }
-  return p;
-}
-function getPreferredAppDir() {
-  const fromEnv = process.env.BLUMA_HOME?.trim();
-  if (fromEnv) {
-    return path28.resolve(expandHome(fromEnv));
-  }
-  const fixed = path28.join(os19.homedir(), ".bluma");
-  return path28.resolve(expandHome(fixed));
-}
-
 // src/app/agent/session_manager/session_index_db.ts
-import path29 from "path";
+init_bluma_app_dir();
+import path30 from "path";
 import { mkdirSync as mkdirSync3 } from "fs";
 import { promises as fs27 } from "fs";
 import { createRequire } from "module";
@@ -20762,10 +21284,10 @@ function loadSqlite() {
   return nodeRequire("better-sqlite3");
 }
 function getSessionDbPath(appDir = getPreferredAppDir()) {
-  return path29.join(appDir, BLUMA_SESSION_DB_FILE);
+  return path30.join(appDir, BLUMA_SESSION_DB_FILE);
 }
 function normalizeRelativePath(relativePath) {
-  return relativePath.split(path29.sep).join("/");
+  return relativePath.split(path30.sep).join("/");
 }
 async function walkSessionJsonFiles(dir, onFile) {
   let entries;
@@ -20776,7 +21298,7 @@ async function walkSessionJsonFiles(dir, onFile) {
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path29.join(dir, name);
+    const full = path30.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -20786,7 +21308,7 @@ async function walkSessionJsonFiles(dir, onFile) {
 }
 async function loadJsonlEntries(appDir) {
   const map = /* @__PURE__ */ new Map();
-  const indexFile = path29.join(appDir, AGENT_SESSION_PATHS_JSONL);
+  const indexFile = path30.join(appDir, AGENT_SESSION_PATHS_JSONL);
   let raw;
   try {
     raw = await fs27.readFile(indexFile, "utf-8");
@@ -20866,7 +21388,7 @@ async function runMigrationV1(db, appDir) {
   const insertFromPath = async (sessionId, absPath, jsonlUpdatedAt) => {
     let rel;
     try {
-      rel = normalizeRelativePath(path29.relative(appDir, absPath));
+      rel = normalizeRelativePath(path30.relative(appDir, absPath));
     } catch {
       return;
     }
@@ -20881,7 +21403,7 @@ async function runMigrationV1(db, appDir) {
     });
   };
   for (const [sessionId, entry] of jsonl) {
-    const full = path29.join(appDir, entry.relativePath.replace(/\//g, path29.sep));
+    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
     try {
       await fs27.access(full);
       await insertFromPath(sessionId, full, entry.updatedAt);
@@ -20895,11 +21417,11 @@ async function runMigrationV1(db, appDir) {
       });
     }
   }
-  const sessionsRoot = path29.join(appDir, "sessions");
+  const sessionsRoot = path30.join(appDir, "sessions");
   const existing = db.prepare("SELECT session_id FROM agent_sessions").all();
   const seen = new Set(existing.map((r) => r.session_id));
   await walkSessionJsonFiles(sessionsRoot, async (absPath) => {
-    const sessionId = path29.basename(absPath, ".json");
+    const sessionId = path30.basename(absPath, ".json");
     if (!sessionId || seen.has(sessionId)) return;
     seen.add(sessionId);
     await insertFromPath(sessionId, absPath);
@@ -20934,7 +21456,7 @@ async function ensureSessionIndexDb(appDir = getPreferredAppDir()) {
       }
       const BetterSqlite3 = loadSqlite();
       const dbPath = getSessionDbPath(appDir);
-      mkdirSync3(path29.dirname(dbPath), { recursive: true });
+      mkdirSync3(path30.dirname(dbPath), { recursive: true });
       const db = new BetterSqlite3(dbPath);
       db.pragma("journal_mode = WAL");
       applySchema(db);
@@ -20970,7 +21492,7 @@ async function upsertSessionIndexRow(row, appDir = getPreferredAppDir()) {
 async function getSessionPathFromIndex(sessionId, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
   const row = db.prepare("SELECT relative_path FROM agent_sessions WHERE session_id = ?").get(sessionId);
-  return row?.relative_path?.replace(/\//g, path29.sep) ?? null;
+  return row?.relative_path?.replace(/\//g, path30.sep) ?? null;
 }
 async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir()) {
   const db = await ensureSessionIndexDb(appDir);
@@ -20982,7 +21504,7 @@ async function listSessionsFromIndex(limit = 50, appDir = getPreferredAppDir())
   ).all(limit);
   return rows.map((r) => ({
     sessionId: r.session_id,
-    relativePath: r.relative_path.replace(/\//g, path29.sep),
+    relativePath: r.relative_path.replace(/\//g, path30.sep),
     createdAt: r.created_at,
     updatedAt: r.updated_at,
     preview: r.preview
@@ -20994,7 +21516,7 @@ var AGENT_SESSION_PATHS_JSONL2 = "agent_session_paths.jsonl";
 async function appendAgentSessionPath(sessionId, relativePath) {
   const app = getPreferredAppDir();
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const rel = relativePath.split(path30.sep).join("/");
+  const rel = relativePath.split(path31.sep).join("/");
   await upsertSessionIndexRow({
     sessionId,
     relativePath: rel,
@@ -21004,7 +21526,7 @@ async function appendAgentSessionPath(sessionId, relativePath) {
   });
 }
 async function resolveSessionRelativePathFromJsonl(sessionId) {
-  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   let raw;
   try {
     raw = await fs28.readFile(indexFile, "utf-8");
@@ -21016,7 +21538,7 @@ async function resolveSessionRelativePathFromJsonl(sessionId) {
     try {
       const row = JSON.parse(lines[i]);
       if (row.sessionId === sessionId && typeof row.relativePath === "string") {
-        return row.relativePath.replace(/\//g, path30.sep);
+        return row.relativePath.replace(/\//g, path31.sep);
       }
     } catch {
     }
@@ -21037,7 +21559,7 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
   for (const e of entries) {
     const name = String(e.name);
-    const full = path30.join(dir, name);
+    const full = path31.join(dir, name);
     if (e.isDirectory()) {
       await walkSessionJsonFiles2(full, onFile);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -21046,10 +21568,10 @@ async function walkSessionJsonFiles2(dir, onFile) {
   }
 }
 async function findSessionFileGlobFallback(sessionId) {
-  const sessionsRoot = path30.join(getPreferredAppDir(), "sessions");
+  const sessionsRoot = path31.join(getPreferredAppDir(), "sessions");
   const state2 = { best: null };
   await walkSessionJsonFiles2(sessionsRoot, async (abs) => {
-    if (path30.basename(abs, ".json") !== sessionId) return;
+    if (path31.basename(abs, ".json") !== sessionId) return;
     try {
       const st = await fs28.stat(abs);
       if (!st.isFile()) return;
@@ -21062,7 +21584,7 @@ async function findSessionFileGlobFallback(sessionId) {
   return state2.best !== null ? state2.best.p : null;
 }
 async function loadLatestIndexEntriesBySessionId() {
-  const indexFile = path30.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
+  const indexFile = path31.join(getPreferredAppDir(), AGENT_SESSION_PATHS_JSONL2);
   const map = /* @__PURE__ */ new Map();
   let raw;
   try {
@@ -21102,11 +21624,11 @@ function dateFolderFromRelativePath(relativePath) {
 async function enrichCandidateFromFile(absPath, sessionId, lastMtimeMs, opts) {
   let rel;
   try {
-    rel = path30.relative(getPreferredAppDir(), absPath);
+    rel = path31.relative(getPreferredAppDir(), absPath);
   } catch {
     rel = absPath;
   }
-  const dateFolder = dateFolderFromRelativePath(rel.split(path30.sep).join("/"));
+  const dateFolder = dateFolderFromRelativePath(rel.split(path31.sep).join("/"));
   let preview = opts?.preview ?? "(no messages)";
   let lastActivityMs = lastMtimeMs;
   if (opts?.updatedAtIso) {
@@ -21145,7 +21667,7 @@ async function listAgentSessionsForResume(limit = 50) {
   const fromIndex = await listSessionsFromIndex(limit * 2, appDir);
   const map = /* @__PURE__ */ new Map();
   for (const row of fromIndex) {
-    const full = path30.join(appDir, row.relativePath);
+    const full = path31.join(appDir, row.relativePath);
     try {
       const st = await fs28.stat(full);
       if (!st.isFile()) continue;
@@ -21158,9 +21680,9 @@ async function listAgentSessionsForResume(limit = 50) {
     } catch {
     }
   }
-  const sessionsRoot = path30.join(appDir, "sessions");
+  const sessionsRoot = path31.join(appDir, "sessions");
   await walkSessionJsonFiles2(sessionsRoot, async (absPath) => {
-    const id = path30.basename(absPath, ".json");
+    const id = path31.basename(absPath, ".json");
     if (!id) return;
     try {
       const st = await fs28.stat(absPath);
@@ -21175,7 +21697,7 @@ async function listAgentSessionsForResume(limit = 50) {
   const index = await loadLatestIndexEntriesBySessionId();
   for (const [sessionId, entry] of index) {
     if (map.has(sessionId)) continue;
-    const full = path30.join(appDir, entry.relativePath.replace(/\//g, path30.sep));
+    const full = path31.join(appDir, entry.relativePath.replace(/\//g, path31.sep));
     try {
       const st = await fs28.stat(full);
       if (st.isFile()) {
@@ -21196,6 +21718,8 @@ async function listAgentSessionsForResume(limit = 50) {
 }
 
 // src/app/agent/session_manager/session_manager.ts
+init_bluma_app_dir();
+init_bluma_app_dir();
 var fileLocks = /* @__PURE__ */ new Map();
 async function withFileLock(file, fn) {
   const prev = fileLocks.get(file) || Promise.resolve();
@@ -21234,7 +21758,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   const isWin = process.platform === "win32";
   while (attempt <= maxRetries) {
     try {
-      const dir = path31.dirname(dest);
+      const dir = path32.dirname(dest);
       await fs29.mkdir(dir, { recursive: true }).catch(() => {
       });
       await fs29.rename(src, dest);
@@ -21252,7 +21776,7 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
   try {
     await fs29.access(src);
     const data = await fs29.readFile(src);
-    const dir = path31.dirname(dest);
+    const dir = path32.dirname(dest);
     await fs29.mkdir(dir, { recursive: true }).catch(() => {
     });
     await fs29.writeFile(dest, data);
@@ -21269,13 +21793,13 @@ async function safeRenameWithRetry(src, dest, maxRetries = 6) {
 }
 async function ensureSessionDir() {
   const appDir = getPreferredAppDir();
-  const sessionDir = path31.join(appDir, "sessions");
+  const sessionDir = path32.join(appDir, "sessions");
   await fs29.mkdir(sessionDir, { recursive: true });
   return sessionDir;
 }
 async function resolveAgentSessionFilePath(sessionId) {
   const appDir = getPreferredAppDir();
-  const legacy = path31.join(appDir, "sessions", `${sessionId}.json`);
+  const legacy = path32.join(appDir, "sessions", `${sessionId}.json`);
   try {
     await fs29.access(legacy);
     return legacy;
@@ -21283,7 +21807,7 @@ async function resolveAgentSessionFilePath(sessionId) {
   }
   const rel = await resolveSessionRelativePathFromIndex(sessionId);
   if (rel) {
-    const full = path31.join(appDir, rel);
+    const full = path32.join(appDir, rel);
     try {
       await fs29.access(full);
       return full;
@@ -21319,16 +21843,16 @@ async function loadOrcreateSession(sessionId) {
   const y = String(now2.getFullYear());
   const mo = String(now2.getMonth() + 1).padStart(2, "0");
   const d = String(now2.getDate()).padStart(2, "0");
-  const datedDir = path31.join(sessionsRoot, y, mo, d);
+  const datedDir = path32.join(sessionsRoot, y, mo, d);
   await fs29.mkdir(datedDir, { recursive: true });
-  const sessionFile = path31.join(datedDir, `${sessionId}.json`);
+  const sessionFile = path32.join(datedDir, `${sessionId}.json`);
   const newSessionData = {
     session_id: sessionId,
     created_at: now2.toISOString(),
     conversation_history: []
   };
   await fs29.writeFile(sessionFile, JSON.stringify(newSessionData, null, 2), "utf-8");
-  const relToApp = path31.relative(getPreferredAppDir(), sessionFile);
+  const relToApp = path32.relative(getPreferredAppDir(), sessionFile);
   await appendAgentSessionPath(sessionId, relToApp);
   const emptyMemory = {
     historyAnchor: null,
@@ -21340,7 +21864,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
   await withFileLock(sessionFile, async () => {
     let sessionData;
     try {
-      const dir = path31.dirname(sessionFile);
+      const dir = path32.dirname(sessionFile);
       await fs29.mkdir(dir, { recursive: true });
     } catch {
     }
@@ -21356,7 +21880,7 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
           console.warn(`An unknown error occurred while reading ${sessionFile}. Re-initializing.`, error);
         }
       }
-      const sessionId = path31.basename(sessionFile, ".json");
+      const sessionId = path32.basename(sessionFile, ".json");
       sessionData = {
         session_id: sessionId,
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -21381,12 +21905,12 @@ async function doSaveSessionHistory(sessionFile, history, memory) {
     try {
       await fs29.writeFile(tempSessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
       await safeRenameWithRetry(tempSessionFile, sessionFile);
-      const sessionId = sessionData.session_id ?? path31.basename(sessionFile, ".json");
+      const sessionId = sessionData.session_id ?? path32.basename(sessionFile, ".json");
       const updatedAt = sessionData.last_updated ?? (/* @__PURE__ */ new Date()).toISOString();
       const createdAt = sessionData.created_at ?? updatedAt;
       let relToApp;
       try {
-        relToApp = path31.relative(getPreferredAppDir(), sessionFile);
+        relToApp = path32.relative(getPreferredAppDir(), sessionFile);
       } catch {
         relToApp = sessionFile;
       }
@@ -21437,14 +21961,14 @@ async function saveSessionHistoryNow(sessionFile, history, memory) {
 }
 
 // src/app/agent/core/prompt/prompt_builder.ts
-import os24 from "os";
-import fs36 from "fs";
+import os23 from "os";
+import fs35 from "fs";
 import path38 from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/app/agent/skills/skill_loader.ts
 import fs30 from "fs";
-import path32 from "path";
+import path33 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var SkillLoader = class _SkillLoader {
@@ -21454,8 +21978,8 @@ var SkillLoader = class _SkillLoader {
   cache = /* @__PURE__ */ new Map();
   conflicts = [];
   constructor(projectRoot, bundledDir) {
-    this.projectSkillsDir = path32.join(projectRoot, ".bluma", "skills");
-    this.globalSkillsDir = path32.join(os20.homedir(), ".bluma", "skills");
+    this.projectSkillsDir = path33.join(projectRoot, ".bluma", "skills");
+    this.globalSkillsDir = path33.join(os20.homedir(), ".bluma", "skills");
     this.bundledSkillsDir = bundledDir || _SkillLoader.resolveBundledDir();
   }
   /**
@@ -21464,32 +21988,32 @@ var SkillLoader = class _SkillLoader {
    */
   static resolveBundledDir() {
     if (process.env.JEST_WORKER_ID !== void 0 || process.env.NODE_ENV === "test") {
-      return path32.join(process.cwd(), "dist", "config", "skills");
+      return path33.join(process.cwd(), "dist", "config", "skills");
     }
     const candidates = [];
     const push = (p) => {
-      const abs = path32.resolve(p);
+      const abs = path33.resolve(p);
       if (!candidates.includes(abs)) {
         candidates.push(abs);
       }
     };
     let argvBundled = null;
     try {
-      const bundleDir = path32.dirname(fileURLToPath3(import.meta.url));
-      push(path32.join(bundleDir, "config", "skills"));
+      const bundleDir = path33.dirname(fileURLToPath3(import.meta.url));
+      push(path33.join(bundleDir, "config", "skills"));
     } catch {
     }
     const argv1 = process.argv[1];
     if (argv1 && !argv1.startsWith("-")) {
       try {
         let resolved = argv1;
-        if (path32.isAbsolute(argv1) && fs30.existsSync(argv1)) {
+        if (path33.isAbsolute(argv1) && fs30.existsSync(argv1)) {
           resolved = fs30.realpathSync(argv1);
-        } else if (!path32.isAbsolute(argv1)) {
-          resolved = path32.resolve(process.cwd(), argv1);
+        } else if (!path33.isAbsolute(argv1)) {
+          resolved = path33.resolve(process.cwd(), argv1);
         }
-        const scriptDir = path32.dirname(resolved);
-        argvBundled = path32.join(scriptDir, "config", "skills");
+        const scriptDir = path33.dirname(resolved);
+        argvBundled = path33.join(scriptDir, "config", "skills");
         push(argvBundled);
       } catch {
       }
@@ -21500,12 +22024,12 @@ var SkillLoader = class _SkillLoader {
       }
     }
     try {
-      return path32.join(path32.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
+      return path33.join(path33.dirname(fileURLToPath3(import.meta.url)), "config", "skills");
     } catch {
       if (argvBundled) {
         return argvBundled;
       }
-      return path32.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
+      return path33.join(os20.homedir(), ".bluma", "__bundled_skills_unresolved__");
     }
   }
   /**
@@ -21534,8 +22058,8 @@ var SkillLoader = class _SkillLoader {
         this.conflicts.push({
           name: skill.name,
           userSource: source,
-          userPath: path32.join(dir, skill.name, "SKILL.md"),
-          bundledPath: path32.join(this.bundledSkillsDir, skill.name, "SKILL.md")
+          userPath: path33.join(dir, skill.name, "SKILL.md"),
+          bundledPath: path33.join(this.bundledSkillsDir, skill.name, "SKILL.md")
         });
         continue;
       }
@@ -21546,9 +22070,9 @@ var SkillLoader = class _SkillLoader {
     if (!fs30.existsSync(dir)) return [];
     try {
       return fs30.readdirSync(dir).filter((d) => {
-        const fullPath = path32.join(dir, d);
-        return fs30.statSync(fullPath).isDirectory() && fs30.existsSync(path32.join(fullPath, "SKILL.md"));
-      }).map((d) => this.loadMetadataFromPath(path32.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
+        const fullPath = path33.join(dir, d);
+        return fs30.statSync(fullPath).isDirectory() && fs30.existsSync(path33.join(fullPath, "SKILL.md"));
+      }).map((d) => this.loadMetadataFromPath(path33.join(dir, d, "SKILL.md"), d, source)).filter((m) => m !== null);
     } catch {
       return [];
     }
@@ -21578,9 +22102,9 @@ var SkillLoader = class _SkillLoader {
    */
   load(name) {
     if (this.cache.has(name)) return this.cache.get(name);
-    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    const bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
     const existsBundled = fs30.existsSync(bundledPath);
     const existsProject = fs30.existsSync(projectPath);
     const existsGlobal = fs30.existsSync(globalPath);
@@ -21624,7 +22148,7 @@ var SkillLoader = class _SkillLoader {
     try {
       const raw = fs30.readFileSync(skillPath, "utf-8");
       const parsed = this.parseFrontmatter(raw);
-      const skillDir = path32.dirname(skillPath);
+      const skillDir = path33.dirname(skillPath);
       return {
         name: parsed.name || name,
         description: parsed.description || "",
@@ -21633,8 +22157,8 @@ var SkillLoader = class _SkillLoader {
         version: parsed.version,
         author: parsed.author,
         license: parsed.license,
-        references: this.scanAssets(path32.join(skillDir, "references")),
-        scripts: this.scanAssets(path32.join(skillDir, "scripts"))
+        references: this.scanAssets(path33.join(skillDir, "references")),
+        scripts: this.scanAssets(path33.join(skillDir, "scripts"))
       };
     } catch {
       return null;
@@ -21644,11 +22168,11 @@ var SkillLoader = class _SkillLoader {
     if (!fs30.existsSync(dir)) return [];
     try {
       return fs30.readdirSync(dir).filter((f) => {
-        const fp = path32.join(dir, f);
+        const fp = path33.join(dir, f);
         return fs30.statSync(fp).isFile();
       }).map((f) => ({
         name: f,
-        path: path32.resolve(dir, f)
+        path: path33.resolve(dir, f)
       }));
     } catch {
       return [];
@@ -21705,9 +22229,9 @@ var SkillLoader = class _SkillLoader {
     this.cache.clear();
   }
   exists(name) {
-    const bundledPath = path32.join(this.bundledSkillsDir, name, "SKILL.md");
-    const projectPath = path32.join(this.projectSkillsDir, name, "SKILL.md");
-    const globalPath = path32.join(this.globalSkillsDir, name, "SKILL.md");
+    const bundledPath = path33.join(this.bundledSkillsDir, name, "SKILL.md");
+    const projectPath = path33.join(this.projectSkillsDir, name, "SKILL.md");
+    const globalPath = path33.join(this.globalSkillsDir, name, "SKILL.md");
     return fs30.existsSync(bundledPath) || fs30.existsSync(projectPath) || fs30.existsSync(globalPath);
   }
   /**
@@ -21741,12 +22265,12 @@ var SkillLoader = class _SkillLoader {
 
 // src/app/agent/core/prompt/workspace_snapshot.ts
 import fs32 from "fs";
-import path34 from "path";
+import path35 from "path";
 import { execSync as execSync2 } from "child_process";
 
 // src/app/agent/utils/blumamd.ts
 import fs31 from "fs";
-import path33 from "path";
+import path34 from "path";
 import os21 from "os";
 import { execSync } from "child_process";
 var MEMORY_INSTRUCTION_PROMPT = "Instru\xE7\xF5es de mem\xF3ria do BluMa (BLUMA.md) est\xE3o abaixo. Siga estas instru\xE7\xF5es exatamente como escritas. Estas instru\xE7\xF5es OVERRIDE qualquer comportamento padr\xE3o.";
@@ -21876,12 +22400,12 @@ var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
 function expandIncludePath(includePath, baseDir) {
   const cleanPath = includePath.startsWith("@") ? includePath.slice(1) : includePath;
   if (cleanPath.startsWith("~")) {
-    return path33.join(os21.homedir(), cleanPath.slice(1));
+    return path34.join(os21.homedir(), cleanPath.slice(1));
   }
-  if (path33.isAbsolute(cleanPath)) {
+  if (path34.isAbsolute(cleanPath)) {
     return cleanPath;
   }
-  return path33.resolve(baseDir, cleanPath);
+  return path34.resolve(baseDir, cleanPath);
 }
 function processIncludes(content, baseDir, processedFiles) {
   const lines = content.split("\n");
@@ -21890,12 +22414,12 @@ function processIncludes(content, baseDir, processedFiles) {
     const includeMatch = line.match(/^@\s*([^\s]+)/);
     if (includeMatch) {
       const includePath = expandIncludePath(includeMatch[1], baseDir);
-      const normalizedPath = path33.normalize(includePath);
+      const normalizedPath = path34.normalize(includePath);
       if (processedFiles.has(normalizedPath)) {
         result.push(`<!-- Circular include prevented: ${includeMatch[1]} -->`);
         continue;
       }
-      const ext = path33.extname(includePath).toLowerCase();
+      const ext = path34.extname(includePath).toLowerCase();
       if (!TEXT_FILE_EXTENSIONS.has(ext)) {
         result.push(`<!-- Include skipped (unsupported extension): ${includeMatch[1]} -->`);
         continue;
@@ -21903,7 +22427,7 @@ function processIncludes(content, baseDir, processedFiles) {
       try {
         const includedContent = fs31.readFileSync(includePath, "utf-8");
         processedFiles.add(normalizedPath);
-        const processedContent = processIncludes(includedContent, path33.dirname(includePath), processedFiles);
+        const processedContent = processIncludes(includedContent, path34.dirname(includePath), processedFiles);
         result.push(`
 <!-- BEGIN INCLUDE ${includeMatch[1]} -->
 `);
@@ -21950,8 +22474,8 @@ function parseFrontmatterPaths(paths2) {
 function readMemoryFile(filePath, type, includeBasePath) {
   try {
     const rawContent = fs31.readFileSync(filePath, "utf-8");
-    const baseDir = includeBasePath || path33.dirname(filePath);
-    const processedFiles = /* @__PURE__ */ new Set([path33.normalize(filePath)]);
+    const baseDir = includeBasePath || path34.dirname(filePath);
+    const processedFiles = /* @__PURE__ */ new Set([path34.normalize(filePath)]);
     const { frontmatter, content: withoutFrontmatter } = parseFrontmatter(rawContent);
     const globs = parseFrontmatterPaths(frontmatter.paths);
     const processedContent = processIncludes(withoutFrontmatter, baseDir, processedFiles);
@@ -21973,15 +22497,15 @@ function readMemoryFile(filePath, type, includeBasePath) {
 }
 function findGitRoot(startDir) {
   let current = startDir;
-  while (current !== path33.dirname(current)) {
-    const gitPath = path33.join(current, ".git");
+  while (current !== path34.dirname(current)) {
+    const gitPath = path34.join(current, ".git");
     try {
       if (fs31.existsSync(gitPath)) {
         return current;
       }
     } catch {
     }
-    current = path33.dirname(current);
+    current = path34.dirname(current);
   }
   return null;
 }
@@ -22012,11 +22536,11 @@ function processRulesDirectory(rulesDir, type, processedPaths, conditionalRule =
   try {
     const entries = fs31.readdirSync(rulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = path33.join(rulesDir, entry.name);
+      const entryPath = path34.join(rulesDir, entry.name);
       if (entry.isDirectory()) {
         result.push(...processRulesDirectory(entryPath, type, processedPaths, conditionalRule));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const normalizedPath = path33.normalize(entryPath);
+        const normalizedPath = path34.normalize(entryPath);
         if (processedPaths.has(normalizedPath)) {
           continue;
         }
@@ -22052,13 +22576,13 @@ function loadManagedMemory() {
 function loadUserMemory() {
   const files = [];
   const homeDir = os21.homedir();
-  const userBlumaDir = path33.join(homeDir, ".bluma");
-  const userBlumaMd = path33.join(userBlumaDir, "BLUMA.md");
+  const userBlumaDir = path34.join(homeDir, ".bluma");
+  const userBlumaMd = path34.join(userBlumaDir, "BLUMA.md");
   const userFile = readMemoryFile(userBlumaMd, "User");
   if (userFile && userFile.content.trim()) {
     files.push(userFile);
   }
-  const userRulesDir = path33.join(userBlumaDir, "rules");
+  const userRulesDir = path34.join(userBlumaDir, "rules");
   const processedPaths = /* @__PURE__ */ new Set();
   files.push(...processRulesDirectory(userRulesDir, "User", processedPaths, false));
   return files;
@@ -22070,10 +22594,10 @@ function loadProjectMemory(cwd2) {
   let currentDir = cwd2;
   const MAX_TRAVERSAL_DEPTH = 20;
   let depth = 0;
-  const normalizedGitRoot = path33.resolve(gitRoot);
-  while (currentDir !== path33.dirname(currentDir) && path33.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
+  const normalizedGitRoot = path34.resolve(gitRoot);
+  while (currentDir !== path34.dirname(currentDir) && path34.resolve(currentDir).startsWith(normalizedGitRoot) && depth < MAX_TRAVERSAL_DEPTH) {
     dirs.push(currentDir);
-    currentDir = path33.dirname(currentDir);
+    currentDir = path34.dirname(currentDir);
     depth++;
   }
   if (!dirs.includes(gitRoot)) {
@@ -22081,7 +22605,7 @@ function loadProjectMemory(cwd2) {
   }
   const processedPaths = /* @__PURE__ */ new Set();
   for (const dir of dirs.reverse()) {
-    const projectBlumaMd = path33.join(dir, "BLUMA.md");
+    const projectBlumaMd = path34.join(dir, "BLUMA.md");
     if (!processedPaths.has(projectBlumaMd)) {
       processedPaths.add(projectBlumaMd);
       const projectFile = readMemoryFile(projectBlumaMd, "Project");
@@ -22089,7 +22613,7 @@ function loadProjectMemory(cwd2) {
         files.push(projectFile);
       }
     }
-    const blumaDirBlumaMd = path33.join(dir, ".bluma", "BLUMA.md");
+    const blumaDirBlumaMd = path34.join(dir, ".bluma", "BLUMA.md");
     if (!processedPaths.has(blumaDirBlumaMd)) {
       processedPaths.add(blumaDirBlumaMd);
       const blumaDirFile = readMemoryFile(blumaDirBlumaMd, "Project");
@@ -22097,10 +22621,10 @@ function loadProjectMemory(cwd2) {
         files.push(blumaDirFile);
       }
     }
-    const rulesDir = path33.join(dir, ".bluma", "rules");
+    const rulesDir = path34.join(dir, ".bluma", "rules");
     files.push(...processRulesDirectory(rulesDir, "Project", processedPaths, false));
   }
-  const localBlumaMd = path33.join(cwd2, "BLUMA.local.md");
+  const localBlumaMd = path34.join(cwd2, "BLUMA.local.md");
   if (!processedPaths.has(localBlumaMd)) {
     processedPaths.add(localBlumaMd);
     const localFile = readMemoryFile(localBlumaMd, "Local");
@@ -22130,16 +22654,16 @@ ${formattedContent}` : ""
   };
 }
 function readBlumaMdForPrompt(cwd2 = process.cwd()) {
-  const config2 = loadBlumaMd(cwd2);
-  if (config2.files.length === 0) {
+  const config3 = loadBlumaMd(cwd2);
+  if (config3.files.length === 0) {
     return "(no BLUMA.md files found)";
   }
-  const fileList = config2.files.map((f) => `- ${f.path} (${f.type})`).join("\n");
-  return `${config2.instructionPrompt}
+  const fileList = config3.files.map((f) => `- ${f.path} (${f.type})`).join("\n");
+  return `${config3.instructionPrompt}
 
 ---
 
-Loaded ${config2.files.length} file(s), ${config2.totalCharacters.toLocaleString()} characters:
+Loaded ${config3.files.length} file(s), ${config3.totalCharacters.toLocaleString()} characters:
 ${fileList}`;
 }
 function getGitUserContext(cwd2 = process.cwd()) {
@@ -22201,7 +22725,7 @@ function safeReadFile(filePath, maxChars) {
 }
 function tryReadReadme(cwd2) {
   for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    const c = safeReadFile(path34.join(cwd2, name), LIMITS.readme);
+    const c = safeReadFile(path35.join(cwd2, name), LIMITS.readme);
     if (c) return `(${name})
 ${c}`;
   }
@@ -22209,14 +22733,14 @@ ${c}`;
 }
 function tryReadBluMaMd(cwd2) {
   const paths2 = [
-    path34.join(cwd2, "BluMa.md"),
-    path34.join(cwd2, "BLUMA.md"),
-    path34.join(cwd2, ".bluma", "BluMa.md")
+    path35.join(cwd2, "BluMa.md"),
+    path35.join(cwd2, "BLUMA.md"),
+    path35.join(cwd2, ".bluma", "BluMa.md")
   ];
   for (const p of paths2) {
     const c = safeReadFile(p, LIMITS.blumaMd);
     if (c) {
-      const rel = path34.relative(cwd2, p) || p;
+      const rel = path35.relative(cwd2, p) || p;
       return `(${rel})
 ${c}`;
     }
@@ -22224,7 +22748,7 @@ ${c}`;
   return null;
 }
 function summarizePackageJson(cwd2) {
-  const p = path34.join(cwd2, "package.json");
+  const p = path35.join(cwd2, "package.json");
   try {
     if (!fs32.existsSync(p)) return null;
     const pkg = JSON.parse(fs32.readFileSync(p, "utf8"));
@@ -22318,7 +22842,7 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(pkg);
     parts.push("```\n");
   }
-  const py = safeReadFile(path34.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
+  const py = safeReadFile(path35.join(cwd2, "pyproject.toml"), LIMITS.pyproject);
   if (py) {
     parts.push("### pyproject.toml (excerpt)\n```toml");
     parts.push(py);
@@ -22336,15 +22860,15 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push(bluma);
     parts.push("```\n");
   }
-  const contrib = safeReadFile(path34.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
+  const contrib = safeReadFile(path35.join(cwd2, "CONTRIBUTING.md"), LIMITS.contributing);
   if (contrib) {
     parts.push("### CONTRIBUTING.md (excerpt)\n```markdown");
     parts.push(contrib);
     parts.push("```\n");
   }
-  const chlog = safeReadFile(path34.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
+  const chlog = safeReadFile(path35.join(cwd2, "CHANGELOG.md"), LIMITS.changelog);
   if (!chlog) {
-    const alt = safeReadFile(path34.join(cwd2, "CHANGES.md"), LIMITS.changelog);
+    const alt = safeReadFile(path35.join(cwd2, "CHANGES.md"), LIMITS.changelog);
     if (alt) {
       parts.push("### CHANGES.md (excerpt)\n```markdown");
       parts.push(alt);
@@ -22365,29 +22889,29 @@ function buildWorkspaceSnapshot(cwd2) {
     parts.push("`git status --short`:\n```");
     parts.push(st ?? "(empty or unavailable)");
     parts.push("```\n");
-    const log = gitLines(cwd2, "log -n 14 --oneline --decorate", LIMITS.gitLogLines);
-    if (log) {
+    const log3 = gitLines(cwd2, "log -n 14 --oneline --decorate", LIMITS.gitLogLines);
+    if (log3) {
       parts.push("Recent commits:\n```");
-      parts.push(log);
+      parts.push(log3);
       parts.push("```\n");
     }
-    const stat = gitLines(cwd2, "diff --stat HEAD", LIMITS.diffStatLines);
-    if (stat) {
+    const stat2 = gitLines(cwd2, "diff --stat HEAD", LIMITS.diffStatLines);
+    if (stat2) {
       parts.push("Uncommitted vs `HEAD` (`git diff --stat HEAD`):\n```");
-      parts.push(stat);
+      parts.push(stat2);
       parts.push("```\n");
     }
   } else {
     parts.push("### Git\n(not a git work tree, or `git` unavailable)\n");
   }
-  const tsconfig = safeReadFile(path34.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
+  const tsconfig = safeReadFile(path35.join(cwd2, "tsconfig.json"), LIMITS.tsconfig);
   if (tsconfig) {
     parts.push("### tsconfig.json (excerpt)\n```json");
     parts.push(tsconfig);
     parts.push("```\n");
   }
   for (const name of ["Dockerfile", "dockerfile", "Dockerfile.prod", "Dockerfile.dev"]) {
-    const df = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
+    const df = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
     if (df) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22397,7 +22921,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
-    const dc = safeReadFile(path34.join(cwd2, name), LIMITS.dockerfile);
+    const dc = safeReadFile(path35.join(cwd2, name), LIMITS.dockerfile);
     if (dc) {
       parts.push(`### ${name} (excerpt)
 `);
@@ -22412,7 +22936,7 @@ function buildWorkspaceSnapshot(cwd2) {
     ".circleci/config.yml",
     "Jenkinsfile"
   ]) {
-    const ciFile = path34.join(cwd2, ciPath);
+    const ciFile = path35.join(cwd2, ciPath);
     if (fs32.existsSync(ciFile)) {
       const st = fs32.statSync(ciFile);
       if (st.isDirectory()) {
@@ -22428,7 +22952,7 @@ function buildWorkspaceSnapshot(cwd2) {
       } else {
         const ci = safeReadFile(ciFile, LIMITS.ciConfig);
         if (ci) {
-          parts.push(`### CI config (${path34.basename(ciPath)})
+          parts.push(`### CI config (${path35.basename(ciPath)})
 `);
           parts.push(ci);
           parts.push("\n");
@@ -22437,7 +22961,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const depFile of ["requirements.txt", "Pipfile", "poetry.lock", "Gemfile", "go.sum", "Cargo.lock"]) {
-    const depPath = path34.join(cwd2, depFile);
+    const depPath = path35.join(cwd2, depFile);
     if (fs32.existsSync(depPath)) {
       const depContent = safeReadFile(depPath, 1500);
       if (depContent) {
@@ -22451,7 +22975,7 @@ function buildWorkspaceSnapshot(cwd2) {
     }
   }
   for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
-    const envPath = path34.join(cwd2, envFile);
+    const envPath = path35.join(cwd2, envFile);
     if (fs32.existsSync(envPath)) {
       try {
         const raw = fs32.readFileSync(envPath, "utf-8");
@@ -22479,13 +23003,13 @@ init_runtime_config();
 init_sandbox_policy();
 import fs33 from "fs";
 import os22 from "os";
-import path35 from "path";
+import path36 from "path";
 function getProjectPluginsDir() {
   const policy = getSandboxPolicy();
-  return path35.join(policy.workspaceRoot, ".bluma", "plugins");
+  return path36.join(policy.workspaceRoot, ".bluma", "plugins");
 }
 function getGlobalPluginsDir() {
-  return path35.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
+  return path36.join(process.env.HOME || os22.homedir(), ".bluma", "plugins");
 }
 function getPluginDirs() {
   return {
@@ -22511,8 +23035,8 @@ function readManifest(manifestPath, fallbackName) {
 }
 function findManifestPath(pluginDir) {
   const candidates = [
-    path35.join(pluginDir, ".codex-plugin", "plugin.json"),
-    path35.join(pluginDir, "plugin.json")
+    path36.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path36.join(pluginDir, "plugin.json")
   ];
   for (const candidate of candidates) {
     if (fs33.existsSync(candidate)) {
@@ -22526,7 +23050,7 @@ function listFromDir(baseDir, source) {
     return [];
   }
   return fs33.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-    const pluginDir = path35.join(baseDir, entry.name);
+    const pluginDir = path36.join(baseDir, entry.name);
     const manifestPath = findManifestPath(pluginDir);
     if (!manifestPath) {
       return [];
@@ -22972,7 +23496,7 @@ function buildModelInfoSection(modelId) {
 // src/app/agent/runtime/hook_registry.ts
 init_sandbox_policy();
 import fs34 from "fs";
-import path36 from "path";
+import path37 from "path";
 var DEFAULT_STATE = {
   enabled: true,
   maxEvents: 120,
@@ -22983,7 +23507,7 @@ var cache3 = null;
 var cachePath2 = null;
 function getStatePath() {
   const policy = getSandboxPolicy();
-  return path36.join(policy.workspaceRoot, ".bluma", "hooks.json");
+  return path37.join(policy.workspaceRoot, ".bluma", "hooks.json");
 }
 function getHookStatePath() {
   return getStatePath();
@@ -23029,7 +23553,7 @@ function ensureLoaded2() {
 }
 function persist2(state2) {
   const statePath = getStatePath();
-  fs34.mkdirSync(path36.dirname(statePath), { recursive: true });
+  fs34.mkdirSync(path37.dirname(statePath), { recursive: true });
   state2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs34.writeFileSync(statePath, JSON.stringify(state2, null, 2), "utf-8");
   cache3 = state2;
@@ -23281,41 +23805,43 @@ Usa s\xF3 facts do pedido; campos em falta \u2192 "n\xE3o fornecido" \u2014 nunc
 }
 
 // src/app/agent/core/prompt/auto_memory.ts
-import fs35 from "fs";
-import path37 from "path";
-import os23 from "os";
-var AUTO_MEMORY_FILE = path37.join(os23.homedir(), ".bluma", "auto_memory.md");
-var MAX_AUTO_MEMORY_CHARS = 25e3;
-var MAX_AUTO_MEMORY_LINES = 200;
-function getAutoMemoryForPrompt() {
+init_paths();
+
+// src/app/agent/memory/memdir/memdir_exports.ts
+init_memdir();
+init_paths();
+init_memdir();
+
+// src/app/agent/core/prompt/prompt_builder.ts
+init_memdir();
+
+// src/app/agent/memory/session_memory_context.ts
+init_session_memory_paths();
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+async function loadSessionMemoryForPrompt(sessionId, cwd2 = process.cwd()) {
+  if (!sessionId?.trim()) return "";
+  const path57 = getSessionMemoryPath(sessionId, cwd2);
   try {
-    if (!fs35.existsSync(AUTO_MEMORY_FILE)) {
-      return "";
-    }
-    let content = fs35.readFileSync(AUTO_MEMORY_FILE, "utf-8");
-    if (!content.trim()) {
-      return "";
-    }
-    const lines = content.split("\n");
-    if (lines.length > MAX_AUTO_MEMORY_LINES) {
-      content = lines.slice(-MAX_AUTO_MEMORY_LINES).join("\n");
-    }
-    if (content.length > MAX_AUTO_MEMORY_CHARS) {
-      content = content.slice(-MAX_AUTO_MEMORY_CHARS);
-    }
-    return `<auto_memory>
-Notes the agent wrote during previous conversations:
+    const content = await readFile3(path57, "utf-8");
+    if (!content.trim()) return "";
+    return `<session_memory>
+Notes for this conversation (${path57}):
 
-${content}
-</auto_memory>`;
+${content.trim()}
+</session_memory>`;
   } catch {
     return "";
   }
 }
-function isAutoMemoryEnabled() {
-  const env2 = process.env.BLUMA_AUTO_MEMORY;
-  if (env2 === "false" || env2 === "0") return false;
-  return true;
+async function initSessionMemoryFile(sessionId, cwd2 = process.cwd()) {
+  await ensureSessionMemoryDir(sessionId, cwd2);
+  const path57 = getSessionMemoryPath(sessionId, cwd2);
+  try {
+    await readFile3(path57, "utf-8");
+  } catch {
+    await writeFile2(path57, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+`, "utf-8");
+  }
 }
 
 // src/app/agent/core/prompt/factorai_sh_prompt.ts
@@ -23446,17 +23972,17 @@ function getGitBranch(dir) {
   }
 }
 function getPackageManager(dir) {
-  if (fs36.existsSync(path38.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs36.existsSync(path38.join(dir, "yarn.lock"))) return "yarn";
-  if (fs36.existsSync(path38.join(dir, "bun.lockb"))) return "bun";
-  if (fs36.existsSync(path38.join(dir, "package-lock.json"))) return "npm";
+  if (fs35.existsSync(path38.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs35.existsSync(path38.join(dir, "yarn.lock"))) return "yarn";
+  if (fs35.existsSync(path38.join(dir, "bun.lockb"))) return "bun";
+  if (fs35.existsSync(path38.join(dir, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function getProjectType(dir) {
   try {
-    const files = fs36.readdirSync(dir);
+    const files = fs35.readdirSync(dir);
     if (files.includes("package.json")) {
-      const pkg = JSON.parse(fs36.readFileSync(path38.join(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs35.readFileSync(path38.join(dir, "package.json"), "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.next) return "Next.js";
       if (deps.react) return "React";
@@ -23477,8 +24003,8 @@ function getProjectType(dir) {
 function getTestFramework(dir) {
   try {
     const pkgPath = path38.join(dir, "package.json");
-    if (fs36.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
+    if (fs35.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps.jest) return "jest";
       if (deps.vitest) return "vitest";
@@ -23487,7 +24013,7 @@ function getTestFramework(dir) {
       if (deps["@playwright/test"]) return "playwright";
       if (deps.cypress) return "cypress";
     }
-    if (fs36.existsSync(path38.join(dir, "pytest.ini")) || fs36.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
+    if (fs35.existsSync(path38.join(dir, "pytest.ini")) || fs35.existsSync(path38.join(dir, "conftest.py"))) return "pytest";
     return "unknown";
   } catch {
     return "unknown";
@@ -23496,8 +24022,8 @@ function getTestFramework(dir) {
 function getTestCommand(dir) {
   try {
     const pkgPath = path38.join(dir, "package.json");
-    if (fs36.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs36.readFileSync(pkgPath, "utf-8"));
+    if (fs35.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs35.readFileSync(pkgPath, "utf-8"));
       if (pkg.scripts?.test) return "npm test";
       if (pkg.scripts?.["test:unit"]) return "npm run test:unit";
     }
@@ -23513,7 +24039,7 @@ function getTestCommand(dir) {
 function isGitRepo(dir) {
   try {
     const p = path38.join(dir, ".git");
-    return fs36.existsSync(p) && fs36.lstatSync(p).isDirectory();
+    return fs35.existsSync(p) && fs35.lstatSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -23725,13 +24251,13 @@ async function getUnifiedSystemPrompt(availableSkills, options) {
   const cwd2 = process.cwd();
   const isSandbox = process.env.BLUMA_SANDBOX === "true";
   const env2 = {
-    os_type: os24.type(),
-    os_version: os24.release(),
-    architecture: os24.arch(),
+    os_type: os23.type(),
+    os_version: os23.release(),
+    architecture: os23.arch(),
     workdir: cwd2,
     projectRoot: cwd2,
     shell_type: process.env.SHELL || process.env.COMSPEC || "unknown",
-    username: os24.userInfo().username,
+    username: os23.userInfo().username,
     current_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
     is_git_repo: isGitRepo(cwd2) ? "yes" : "no",
@@ -23839,10 +24365,22 @@ ${blocks.join("\n\n")}
 ${memory || "(empty \u2014 use coding_memory: add | list | search)"}
 </coding_memory_snapshot>`;
   if (isAutoMemoryEnabled()) {
-    const autoMem = getAutoMemoryForPrompt();
-    if (autoMem) prompt += `
+    const memPrompt = await loadMemoryPrompt();
+    if (memPrompt) {
+      prompt += `
+
+<memory_system>
+${memPrompt}
+</memory_system>`;
+    }
+  }
+  const sessionId = options?.sessionId?.trim();
+  if (sessionId) {
+    await initSessionMemoryFile(sessionId, cwd2);
+    const sessionMem = await loadSessionMemoryForPrompt(sessionId, cwd2);
+    if (sessionMem) prompt += `
 
-${autoMem}`;
+${sessionMem}`;
   }
   prompt += `
 
@@ -24414,7 +24952,7 @@ function getContextInputBudgetForModel(_modelName = "") {
 // src/app/agent/core/llm/llm.ts
 init_runtime_config();
 init_sandbox_policy();
-import os25 from "os";
+import os24 from "os";
 import OpenAI from "openai";
 
 // src/app/agent/core/llm/streaming_delta.ts
@@ -24458,7 +24996,7 @@ function defaultBlumaUserContextInput(sessionId, userMessage) {
 }
 function getPreferredMacAddress() {
   try {
-    const ifaces = os25.networkInterfaces();
+    const ifaces = os24.networkInterfaces();
     for (const name of Object.keys(ifaces)) {
       const addrs = ifaces[name];
       if (!addrs) continue;
@@ -24473,7 +25011,7 @@ function getPreferredMacAddress() {
   } catch {
   }
   try {
-    return `host:${os25.hostname()}`;
+    return `host:${os24.hostname()}`;
   } catch {
     return "unknown";
   }
@@ -24483,7 +25021,7 @@ function defaultInteractiveCliUserContextInput(sessionId, userMessage) {
   const machineId = getPreferredMacAddress();
   let userName = null;
   try {
-    userName = os25.userInfo().username || null;
+    userName = os24.userInfo().username || null;
   } catch {
     userName = null;
   }
@@ -24934,8 +25472,8 @@ var LLMService = class {
 };
 
 // src/app/agent/utils/user_message_images.ts
-import fs37 from "fs";
-import os26 from "os";
+import fs36 from "fs";
+import os25 from "os";
 import path39 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp)$/i;
@@ -24952,15 +25490,15 @@ var MIME = {
 function expandUserPath(p) {
   const t = p.trim();
   if (t.startsWith("~")) {
-    return path39.join(os26.homedir(), t.slice(1).replace(/^\//, ""));
+    return path39.join(os25.homedir(), t.slice(1).replace(/^\//, ""));
   }
   return t;
 }
 function isPathAllowed(absResolved, cwd2) {
   const resolved = path39.normalize(path39.resolve(absResolved));
   const cwdR = path39.normalize(path39.resolve(cwd2));
-  const homeR = path39.normalize(path39.resolve(os26.homedir()));
-  const tmpR = path39.normalize(path39.resolve(os26.tmpdir()));
+  const homeR = path39.normalize(path39.resolve(os25.homedir()));
+  const tmpR = path39.normalize(path39.resolve(os25.tmpdir()));
   const underCwd = resolved === cwdR || resolved.startsWith(cwdR + path39.sep);
   const underHome = resolved === homeR || resolved.startsWith(homeR + path39.sep);
   const underTmp = resolved === tmpR || resolved.startsWith(tmpR + path39.sep);
@@ -25014,7 +25552,7 @@ function resolveImagePath(candidate, cwd2) {
   const abs = path39.isAbsolute(expanded) ? path39.normalize(expanded) : path39.normalize(path39.resolve(cwd2, expanded));
   if (!isPathAllowed(abs, cwd2)) return null;
   try {
-    if (!fs37.existsSync(abs) || !fs37.statSync(abs).isFile()) return null;
+    if (!fs36.existsSync(abs) || !fs36.statSync(abs).isFile()) return null;
   } catch {
     return null;
   }
@@ -25038,7 +25576,7 @@ function trySingleLineFileUriOrBareImagePath(line, cwd2) {
   const abs = resolveImagePath(s, cwd2);
   if (!abs) return null;
   try {
-    const st = fs37.statSync(abs);
+    const st = fs36.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25073,7 +25611,7 @@ function tryPasteChunkAsSingleImagePath(chunk, cwd2) {
     return null;
   }
   try {
-    const st = fs37.statSync(abs);
+    const st = fs36.statSync(abs);
     if (!st.isFile() || st.size > MAX_IMAGE_BYTES) {
       return null;
     }
@@ -25102,7 +25640,7 @@ function buildUserMessageContent(raw, cwd2) {
     const abs = resolveImagePath(c, cwd2);
     if (!abs) continue;
     try {
-      const st = fs37.statSync(abs);
+      const st = fs36.statSync(abs);
       if (st.size > MAX_IMAGE_BYTES) continue;
     } catch {
       continue;
@@ -25119,7 +25657,7 @@ function buildUserMessageContent(raw, cwd2) {
   }
   const parts = [{ type: "text", text: textPart }];
   for (const abs of resolvedAbs) {
-    const buf = fs37.readFileSync(abs);
+    const buf = fs36.readFileSync(abs);
     const b64 = buf.toString("base64");
     const mime = mimeFor(abs);
     parts.push({
@@ -25382,11 +25920,11 @@ function effectiveToolAutoApprove(toolCall, sessionId, options) {
 }
 
 // src/app/agent/tools/CodingMemoryTool/CodingMemoryConsolidate.ts
-import * as fs38 from "fs";
+import * as fs37 from "fs";
 import * as path41 from "path";
-import os27 from "os";
+import os26 from "os";
 function memoryPath2() {
-  return path41.join(process.env.HOME || os27.homedir(), ".bluma", "coding_memory.json");
+  return path41.join(process.env.HOME || os26.homedir(), ".bluma", "coding_memory.json");
 }
 function normalizeNote2(note) {
   return note.trim().toLowerCase().replace(/\s+/g, " ");
@@ -25396,18 +25934,18 @@ function uniqTags(a, b) {
 }
 function consolidateCodingMemoryFile() {
   const p = memoryPath2();
-  if (!fs38.existsSync(p)) {
+  if (!fs37.existsSync(p)) {
     return { success: true, removedDuplicates: 0, message: "no coding_memory.json" };
   }
   const bak = `${p}.bak`;
   try {
-    fs38.copyFileSync(p, bak);
+    fs37.copyFileSync(p, bak);
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `backup failed: ${e.message}` };
   }
   let data;
   try {
-    data = JSON.parse(fs38.readFileSync(p, "utf-8"));
+    data = JSON.parse(fs37.readFileSync(p, "utf-8"));
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `invalid json: ${e.message}` };
   }
@@ -25442,7 +25980,7 @@ function consolidateCodingMemoryFile() {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    fs38.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
+    fs37.writeFileSync(p, JSON.stringify(out, null, 2), "utf-8");
   } catch (e) {
     return { success: false, removedDuplicates: 0, message: `write failed: ${e.message}` };
   }
@@ -25947,18 +26485,19 @@ var BluMaToolRunner = class {
 };
 
 // src/app/agent/session_manager/session_archive.ts
+init_bluma_app_dir();
 import path42 from "path";
-import { promises as fs39 } from "fs";
+import { promises as fs38 } from "fs";
 async function archivePrunedConversationMessages(sessionId, messages) {
   if (!sessionId || messages.length === 0) {
     return null;
   }
   const appDir = getPreferredAppDir();
   const dir = path42.join(appDir, "sessions", "archive", sessionId);
-  await fs39.mkdir(dir, { recursive: true });
+  await fs38.mkdir(dir, { recursive: true });
   const archiveFile = path42.join(dir, `${Date.now()}.jsonl`);
   const lines = messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  await fs39.appendFile(archiveFile, lines, "utf-8");
+  await fs38.appendFile(archiveFile, lines, "utf-8");
   return archiveFile;
 }
 
@@ -26702,6 +27241,587 @@ function summarizeHistoryForLog(messages, limit = 8) {
   });
 }
 
+// src/app/agent/memory/background_memory.ts
+init_paths();
+
+// src/app/agent/memory/extract_memories.ts
+init_paths();
+
+// src/app/agent/memory/memdir/memory_scan.ts
+init_memoryTypes();
+import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import { join as join12 } from "path";
+var MAX_MEMORY_FILES = 200;
+var FRONTMATTER_MAX_LINES = 30;
+function parseSimpleFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return {};
+  const out = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line?.trim() === "---") break;
+    const m = line?.match(/^([\w-]+):\s*(.*)$/);
+    if (m) out[m[1]] = m[2].trim();
+  }
+  return out;
+}
+async function collectMdFiles(dir, base, out) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const ent of entries) {
+    const full = join12(dir, ent.name);
+    if (ent.isDirectory()) {
+      await collectMdFiles(full, base, out);
+      continue;
+    }
+    if (!ent.isFile() || !ent.name.endsWith(".md") || ent.name === "MEMORY.md") continue;
+    out.push(full.slice(base.length).replace(/^[/\\]/, ""));
+  }
+}
+async function scanMemoryFiles(memoryDir, _signal) {
+  try {
+    const base = memoryDir.endsWith("/") || memoryDir.endsWith("\\") ? memoryDir : memoryDir + "/";
+    const mdFiles = [];
+    await collectMdFiles(memoryDir, base, mdFiles);
+    const headers = [];
+    for (const relativePath of mdFiles) {
+      const filePath = join12(memoryDir, relativePath);
+      try {
+        const raw = await readFile4(filePath, "utf-8");
+        const head = raw.split("\n").slice(0, FRONTMATTER_MAX_LINES).join("\n");
+        const frontmatter = parseSimpleFrontmatter(head);
+        const st = await stat(filePath);
+        headers.push({
+          filename: relativePath,
+          filePath,
+          mtimeMs: st.mtimeMs,
+          description: frontmatter.description || null,
+          type: parseMemoryType(frontmatter.type)
+        });
+      } catch {
+      }
+    }
+    return headers.sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_MEMORY_FILES);
+  } catch {
+    return [];
+  }
+}
+function formatMemoryManifest(headers) {
+  if (headers.length === 0) return "(no topic memory files yet)";
+  return headers.map((h) => {
+    const type = h.type ? `[${h.type}] ` : "";
+    const desc = h.description ? ` \u2014 ${h.description}` : "";
+    return `- ${type}${h.filename}${desc}`;
+  }).join("\n");
+}
+
+// src/app/agent/memory/extract_memories_prompts.ts
+init_memoryTypes();
+init_memdir();
+function buildExtractAutoOnlyPrompt(newMessageCount, existingMemories) {
+  const manifest = existingMemories.length > 0 ? `
+
+## Existing memory files
+
+${existingMemories}
+
+Update existing files instead of duplicating.` : "";
+  return [
+    `You are the memory extraction subagent. Analyze the last ~${newMessageCount} messages above and update persistent memory.`,
+    "",
+    "Tools allowed: read_file_lines, grep_search, find_by_name, ls_tool, read-only shell_command, file_write and edit_tool only under the auto-memory directory. All other tools are denied.",
+    "",
+    "Turn budget is small: batch read_file_lines in parallel, then batch writes. Do not investigate the codebase beyond the conversation.",
+    manifest,
+    "",
+    "If the user asked to remember or forget something, act on that.",
+    "",
+    ...TYPES_SECTION_INDIVIDUAL,
+    ...WHAT_NOT_TO_SAVE_SECTION,
+    "",
+    "## How to save memories",
+    "",
+    "**Step 1** \u2014 write topic files with frontmatter:",
+    "",
+    ...MEMORY_FRONTMATTER_EXAMPLE,
+    "",
+    `**Step 2** \u2014 add one-line pointers in \`${ENTRYPOINT_NAME}\` (index only, never full memory bodies). Max ${MAX_ENTRYPOINT_LINES} lines in the index.`,
+    "",
+    "- No duplicates \u2014 update existing topic files when possible",
+    "- Organize by topic, not chronologically"
+  ].join("\n");
+}
+
+// src/app/agent/memory/memory_tool_policy.ts
+init_paths();
+import path43 from "path";
+var MEMORY_READ_TOOLS = /* @__PURE__ */ new Set([
+  "read_file_lines",
+  "grep_search",
+  "find_by_name",
+  "ls_tool"
+]);
+var MEMORY_WRITE_TOOLS = /* @__PURE__ */ new Set(["file_write", "edit_tool"]);
+var READ_ONLY_SHELL = /^\s*(ls|find|cat|head|tail|stat|wc|pwd|echo|test|file|grep|rg)\b/i;
+function extractFilePath(args) {
+  const keys = ["filepath", "file_path", "filePath", "path"];
+  for (const k of keys) {
+    const v = args[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return void 0;
+}
+function isReadOnlyShellCommand(command) {
+  if (typeof command !== "string" || !command.trim()) return false;
+  const trimmed = command.trim();
+  if (/\|\s*(bash|sh|zsh)\b/i.test(trimmed)) return false;
+  if (/\brm\b|\bmv\b|\bcp\b.*\s+.*\s+/i.test(trimmed) && !READ_ONLY_SHELL.test(trimmed)) {
+    return false;
+  }
+  return READ_ONLY_SHELL.test(trimmed);
+}
+function createAutoMemToolGate(memoryDir) {
+  const memRoot = memoryDir.endsWith(path43.sep) ? memoryDir : memoryDir + path43.sep;
+  return (toolName, args) => {
+    if (MEMORY_READ_TOOLS.has(toolName)) {
+      return { allowed: true };
+    }
+    if (toolName === "shell_command") {
+      if (isReadOnlyShellCommand(args.command)) {
+        return { allowed: true };
+      }
+      return { allowed: false, reason: "Only read-only shell commands are allowed for memory extraction" };
+    }
+    if (MEMORY_WRITE_TOOLS.has(toolName)) {
+      const fp = extractFilePath(args);
+      if (fp && isAutoMemPath(path43.resolve(fp))) {
+        return { allowed: true };
+      }
+      return { allowed: false, reason: `Writes must stay under ${memRoot}` };
+    }
+    return { allowed: false, reason: "Tool not permitted in memory extraction subagent" };
+  };
+}
+function createSessionMemoryToolGate(sessionMemoryPath) {
+  const resolvedTarget = path43.resolve(sessionMemoryPath);
+  return (toolName, args) => {
+    if (toolName === "read_file_lines") {
+      const fp = extractFilePath(args);
+      if (fp && path43.resolve(fp) === resolvedTarget) {
+        return { allowed: true };
+      }
+      return { allowed: false, reason: "Session memory subagent may only read the session summary file" };
+    }
+    if (toolName === "edit_tool") {
+      const fp = extractFilePath(args);
+      if (fp && path43.resolve(fp) === resolvedTarget) {
+        return { allowed: true };
+      }
+      return { allowed: false, reason: "Session memory subagent may only edit the session summary file" };
+    }
+    return { allowed: false, reason: "Only read_file_lines and edit_tool are allowed for session memory updates" };
+  };
+}
+function hasAutoMemWritesSinceHistory(history, sinceIndex) {
+  for (let i = Math.max(0, sinceIndex); i < history.length; i++) {
+    const msg = history[i];
+    if (msg?.role !== "assistant" || !Array.isArray(msg.tool_calls)) continue;
+    for (const tc of msg.tool_calls) {
+      const name = tc.function?.name;
+      if (!name || !MEMORY_WRITE_TOOLS.has(name)) continue;
+      let args = {};
+      try {
+        const raw = tc.function?.arguments;
+        if (typeof raw === "string") {
+          args = JSON.parse(raw);
+        } else if (raw && typeof raw === "object") {
+          args = raw;
+        }
+      } catch {
+        continue;
+      }
+      const fp = extractFilePath(args);
+      if (fp && isAutoMemPath(path43.resolve(fp))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function countModelVisibleMessagesSince(history, sinceIndex) {
+  let n = 0;
+  for (let i = Math.max(0, sinceIndex); i < history.length; i++) {
+    const r = history[i]?.role;
+    if (r === "user" || r === "assistant") n++;
+  }
+  return n;
+}
+function estimateHistoryTokens(history) {
+  let chars = 0;
+  for (const m of history) {
+    const c = m.content;
+    if (typeof c === "string") chars += c.length;
+    else if (Array.isArray(c)) {
+      for (const part of c) {
+        if (part?.text) chars += part.text.length;
+      }
+    } else if (m.role === "assistant" && Array.isArray(m.tool_calls)) {
+      chars += JSON.stringify(m.tool_calls).length;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+function countToolCallsSince(history, sinceIndex) {
+  let n = 0;
+  for (let i = Math.max(0, sinceIndex); i < history.length; i++) {
+    const msg = history[i];
+    if (msg?.role === "assistant" && Array.isArray(msg.tool_calls)) {
+      n += msg.tool_calls.length;
+    }
+  }
+  return n;
+}
+function lastAssistantTurnHasToolCalls(history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const msg = history[i];
+    if (msg?.role !== "assistant") continue;
+    return Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
+  }
+  return false;
+}
+
+// src/app/agent/memory/memory_subagent.ts
+var SUBAGENT_TOOLS = [
+  "read_file_lines",
+  "grep_search",
+  "find_by_name",
+  "ls_tool",
+  "shell_command",
+  "file_write",
+  "edit_tool"
+];
+function toolResultToContent(result) {
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result, null, 2);
+  } catch {
+    return String(result);
+  }
+}
+async function runMemorySubagent(params) {
+  const {
+    llm,
+    mcpClient,
+    forkHistory,
+    userPrompt,
+    userContext,
+    gate,
+    maxTurns = 5,
+    systemSuffix = ""
+  } = params;
+  const allTools = mcpClient.getAvailableTools();
+  const toolSet = new Set(SUBAGENT_TOOLS);
+  const tools = allTools.filter((t) => toolSet.has(t.function?.name ?? ""));
+  const messages = [
+    ...forkHistory,
+    { role: "user", content: userPrompt }
+  ];
+  const systemNote = "You are a background memory subagent. Complete the memory task and stop. Do not chat with the user." + (systemSuffix ? `
+
+${systemSuffix}` : "");
+  if (messages[0]?.role === "system") {
+    messages[0] = {
+      role: "system",
+      content: `${String(messages[0].content ?? "")}
+
+${systemNote}`
+    };
+  } else {
+    messages.unshift({ role: "system", content: systemNote });
+  }
+  for (let turn = 0; turn < maxTurns; turn++) {
+    const response = await llm.chatCompletion({
+      messages,
+      tools: tools.length > 0 ? tools : void 0,
+      tool_choice: tools.length > 0 ? "auto" : void 0,
+      userContext,
+      temperature: 0.2,
+      parallel_tool_calls: true
+    });
+    const choice = response.choices[0]?.message;
+    if (!choice) break;
+    const toolCalls = choice.tool_calls;
+    if (!toolCalls?.length) {
+      if (choice.content) {
+        messages.push({ role: "assistant", content: choice.content });
+      }
+      break;
+    }
+    messages.push({
+      role: "assistant",
+      content: choice.content ?? "",
+      tool_calls: toolCalls
+    });
+    for (const tc of toolCalls) {
+      const toolName = tc.function?.name ?? "";
+      let args = {};
+      try {
+        args = JSON.parse(tc.function?.arguments ?? "{}");
+      } catch {
+        args = {};
+      }
+      const decision = gate(toolName, args);
+      if (!decision.allowed) {
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: JSON.stringify({ status: "error", error: decision.reason ?? "denied" })
+        });
+        continue;
+      }
+      try {
+        const result = await mcpClient.invoke(toolName, args);
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: toolResultToContent(result)
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        messages.push({
+          role: "tool",
+          tool_call_id: tc.id,
+          content: JSON.stringify({ status: "error", error: msg })
+        });
+      }
+    }
+  }
+}
+
+// src/app/agent/memory/extract_memories.ts
+init_logger();
+var log = logger.child("extract_memories");
+var lastProcessedIndex = 0;
+var inProgress = false;
+var pendingRun = false;
+function buildMemoryUserContext(sessionId, base) {
+  return {
+    ...base,
+    turnId: `extract-mem-${sessionId}-${Date.now()}`,
+    userMessage: "[background memory extraction]"
+  };
+}
+async function runExtraction(deps) {
+  if (!isAutoMemoryEnabled()) return;
+  const { history, sessionId, llm, mcpClient, userContext } = deps;
+  const memoryDir = getAutoMemPath();
+  const newMessageCount = countModelVisibleMessagesSince(history, lastProcessedIndex);
+  if (hasAutoMemWritesSinceHistory(history, lastProcessedIndex)) {
+    log.debug("skip \u2014 main agent already wrote to memdir");
+    lastProcessedIndex = history.length;
+    return;
+  }
+  if (newMessageCount < 1) return;
+  inProgress = true;
+  try {
+    log.debug(`start \u2014 ${newMessageCount} new messages, dir=${memoryDir}`);
+    const manifest = formatMemoryManifest(await scanMemoryFiles(memoryDir));
+    const userPrompt = buildExtractAutoOnlyPrompt(newMessageCount, manifest);
+    await runMemorySubagent({
+      llm,
+      mcpClient,
+      forkHistory: history,
+      userPrompt,
+      userContext: buildMemoryUserContext(sessionId, userContext),
+      gate: createAutoMemToolGate(memoryDir),
+      maxTurns: 5
+    });
+    lastProcessedIndex = history.length;
+    log.debug("finished");
+  } catch (err) {
+    log.warn("failed", { error: err instanceof Error ? err.message : String(err) });
+  } finally {
+    inProgress = false;
+    if (pendingRun) {
+      pendingRun = false;
+      void runExtraction(deps);
+    }
+  }
+}
+function scheduleExtractMemories(deps) {
+  if (!isAutoMemoryEnabled()) return;
+  if (process.env.BLUMA_DISABLE_EXTRACT_MEMORIES === "1") return;
+  if (inProgress) {
+    pendingRun = true;
+    return;
+  }
+  void runExtraction(deps);
+}
+
+// src/app/agent/memory/session_memory_update.ts
+init_session_memory_paths();
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+
+// src/app/agent/memory/session_memory_prompts.ts
+init_session_memory_paths();
+var MAX_SECTION_LENGTH = 2e3;
+function buildSessionMemoryUpdatePrompt(currentNotes, notesPath) {
+  return `IMPORTANT: This message is NOT part of the user conversation. Do NOT mention note-taking in the notes file.
+
+Based on the conversation above (exclude this instruction and static system/BLUMA.md blocks), update the session notes file.
+
+The file ${notesPath} current contents:
+<current_notes_content>
+${currentNotes || DEFAULT_SESSION_MEMORY_TEMPLATE}
+</current_notes_content>
+
+Your ONLY task: use edit_tool on ${notesPath} to update sections, then stop. You may issue multiple edit_tool calls in one assistant message (parallel). Do not call other tools.
+
+RULES:
+- Keep every # section header and every italic _section description_ line exactly as-is
+- Only change content BELOW the italic template lines within each section
+- Do not add or remove sections
+- Update "Current State" with the latest work \u2014 critical for continuity
+- Keep sections under ~${MAX_SECTION_LENGTH} words; be dense and specific (paths, commands, errors)
+- Do not duplicate BLUMA.md content
+
+Use edit_tool with file_path: ${notesPath}
+Stop after edits complete.`;
+}
+
+// src/app/agent/memory/session_memory_state.ts
+var DEFAULT_SESSION_MEMORY_CONFIG = {
+  minimumMessageTokensToInit: 1e4,
+  minimumTokensBetweenUpdate: 5e3,
+  toolCallsBetweenUpdates: 3
+};
+var config = { ...DEFAULT_SESSION_MEMORY_CONFIG };
+var sessionMemoryInitialized = false;
+var tokensAtLastExtraction = 0;
+var lastCursorIndex = 0;
+var extractionInProgress = false;
+function getSessionMemoryConfig() {
+  return config;
+}
+function isSessionMemoryInitialized() {
+  return sessionMemoryInitialized;
+}
+function markSessionMemoryInitialized() {
+  sessionMemoryInitialized = true;
+}
+function recordExtractionTokenCount(tokens) {
+  tokensAtLastExtraction = tokens;
+}
+function getLastCursorIndex() {
+  return lastCursorIndex;
+}
+function setLastCursorIndex(index) {
+  lastCursorIndex = index;
+}
+function markSessionExtractionStarted() {
+  extractionInProgress = true;
+}
+function markSessionExtractionCompleted() {
+  extractionInProgress = false;
+}
+function isSessionExtractionInProgress() {
+  return extractionInProgress;
+}
+function hasMetInitializationThreshold(currentTokens) {
+  return currentTokens >= config.minimumMessageTokensToInit;
+}
+function hasMetUpdateThreshold(currentTokens) {
+  return currentTokens - tokensAtLastExtraction >= config.minimumTokensBetweenUpdate;
+}
+
+// src/app/agent/memory/session_memory_update.ts
+init_logger();
+var log2 = logger.child("session_memory");
+function isSessionMemoryEnabled() {
+  if (process.env.BLUMA_DISABLE_SESSION_MEMORY === "1") return false;
+  return true;
+}
+function shouldUpdateSessionMemory(history) {
+  const tokens = estimateHistoryTokens(history);
+  if (!isSessionMemoryInitialized()) {
+    if (!hasMetInitializationThreshold(tokens)) return false;
+    markSessionMemoryInitialized();
+  }
+  const cfg = getSessionMemoryConfig();
+  const toolCalls = countToolCallsSince(history, getLastCursorIndex());
+  const metTokens = hasMetUpdateThreshold(tokens);
+  const metTools = toolCalls >= cfg.toolCallsBetweenUpdates;
+  const lastTurnHasTools = lastAssistantTurnHasToolCalls(history);
+  return metTokens && metTools || metTokens && !lastTurnHasTools;
+}
+function buildSessionUserContext(sessionId, base) {
+  return {
+    ...base,
+    turnId: `session-mem-${sessionId}-${Date.now()}`,
+    userMessage: "[background session memory update]"
+  };
+}
+async function runSessionMemoryUpdate(deps) {
+  if (!isSessionMemoryEnabled()) return;
+  if (isSessionExtractionInProgress()) return;
+  const { history, sessionId, llm, mcpClient, userContext } = deps;
+  if (!shouldUpdateSessionMemory(history)) return;
+  markSessionExtractionStarted();
+  try {
+    await ensureSessionMemoryDir(sessionId);
+    const memoryPath3 = getSessionMemoryPath(sessionId);
+    let currentMemory = "";
+    try {
+      currentMemory = await readFile5(memoryPath3, "utf-8");
+    } catch {
+      await writeFile3(memoryPath3, `${DEFAULT_SESSION_MEMORY_TEMPLATE}
+`, "utf-8");
+      currentMemory = DEFAULT_SESSION_MEMORY_TEMPLATE;
+    }
+    const userPrompt = buildSessionMemoryUpdatePrompt(currentMemory, memoryPath3);
+    log2.debug(`updating ${memoryPath3}`);
+    await runMemorySubagent({
+      llm,
+      mcpClient,
+      forkHistory: history,
+      userPrompt,
+      userContext: buildSessionUserContext(sessionId, userContext),
+      gate: createSessionMemoryToolGate(memoryPath3),
+      maxTurns: 6
+    });
+    recordExtractionTokenCount(estimateHistoryTokens(history));
+    setLastCursorIndex(history.length);
+    log2.debug("finished");
+  } catch (err) {
+    log2.warn("failed", { error: err instanceof Error ? err.message : String(err) });
+  } finally {
+    markSessionExtractionCompleted();
+  }
+}
+function scheduleSessionMemoryUpdate(deps) {
+  if (!isSessionMemoryEnabled()) return;
+  void runSessionMemoryUpdate(deps);
+}
+
+// src/app/agent/memory/background_memory.ts
+function runBackgroundMemoryAfterTurn(params) {
+  const deps = {
+    history: [...params.history],
+    sessionId: params.sessionId,
+    llm: params.llm,
+    mcpClient: params.mcpClient,
+    userContext: params.userContext
+  };
+  if (isAutoMemoryEnabled()) {
+    scheduleExtractMemories(deps);
+  }
+  scheduleSessionMemoryUpdate(deps);
+}
+
 // src/app/agent/bluma/core/bluma.ts
 var BluMaAgent = class {
   llm;
@@ -26793,13 +27913,13 @@ var BluMaAgent = class {
     if (!this.sessionFile) return;
     try {
       const sessionData = {
-        session_id: path43.basename(this.sessionFile, ".json"),
+        session_id: path44.basename(this.sessionFile, ".json"),
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         conversation_history: this.history,
         last_updated: (/* @__PURE__ */ new Date()).toISOString(),
         ...this.compressor.getSnapshot()
       };
-      fs40.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
+      fs39.writeFileSync(this.sessionFile, JSON.stringify(sessionData, null, 2), "utf-8");
     } catch (error) {
       console.error("[Bluma] Failed to persist session synchronously:", error);
     }
@@ -27005,7 +28125,7 @@ var BluMaAgent = class {
 
 ${editData.error.display}`;
       }
-      const filename = path43.basename(toolArgs.file_path);
+      const filename = path44.basename(toolArgs.file_path);
       return createDiff(filename, editData.currentContent || "", editData.newContent);
     } catch (e) {
       return `An unexpected error occurred while generating the edit preview: ${e.message}`;
@@ -27054,6 +28174,14 @@ ${editData.error.display}`;
   }
   emitTurnCompleted() {
     this.eventBus.emit("backend_message", { type: "done", status: "completed" });
+    const ctx = this.activeTurnContext ?? this.getLlmUserContext();
+    runBackgroundMemoryAfterTurn({
+      history: this.history,
+      sessionId: this.sessionId,
+      llm: this.llm,
+      mcpClient: this.mcpClient,
+      userContext: ctx
+    });
     void this.runAutoDreamIfEnabled();
   }
   async runAutoDreamIfEnabled() {
@@ -27083,7 +28211,7 @@ import { v4 as uuidv411 } from "uuid";
 import { v4 as uuidv410 } from "uuid";
 
 // src/app/agent/subagents/init/init_system_prompt.ts
-import os28 from "os";
+import os27 from "os";
 var SYSTEM_PROMPT2 = `
 
 ### YOU ARE BluMa CLI \u2014 INIT SUBAGENT \u2014 AUTONOMOUS SENIOR SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -27246,12 +28374,12 @@ Rule Summary:
 function getInitPrompt() {
   const now2 = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os28.type(),
-    os_version: os28.release(),
-    architecture: os28.arch(),
+    os_type: os27.type(),
+    os_version: os27.release(),
+    architecture: os27.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os28.userInfo().username || "Unknown",
+    username: os27.userInfo().username || "Unknown",
     current_date: now2.toISOString().split("T")[0],
     // Formato YYYY-MM-DD
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
@@ -27279,7 +28407,7 @@ function getInitPrompt() {
 }
 
 // src/app/agent/subagents/worker_system_prompt.ts
-import os29 from "os";
+import os28 from "os";
 var WORKER_SYSTEM_PROMPT = `
 
 ### YOU ARE BluMa CLI \u2014 WORKER AGENT \u2014 EXPERT SOFTWARE ENGINEER @ NOMADENGENUITY
@@ -27604,12 +28732,12 @@ task_boundary({
 function getWorkerPrompt() {
   const now2 = /* @__PURE__ */ new Date();
   const collectedData = {
-    os_type: os29.type(),
-    os_version: os29.release(),
-    architecture: os29.arch(),
+    os_type: os28.type(),
+    os_version: os28.release(),
+    architecture: os28.arch(),
     workdir: process.cwd(),
     shell_type: process.env.SHELL || process.env.COMSPEC || "Unknown",
-    username: os29.userInfo().username || "Unknown",
+    username: os28.userInfo().username || "Unknown",
     current_date: now2.toISOString().split("T")[0],
     timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "Unknown",
     locale: process.env.LANG || process.env.LC_ALL || "Unknown"
@@ -27653,13 +28781,13 @@ function estimateTokens2(text) {
 function countTokens2(messages) {
   return messages.reduce((total, m) => total + estimateTokens2(m.content || ""), 0);
 }
-async function autoCompactIfNeeded(messages, config2 = DEFAULT_COMPACT_CONFIG, summarizer) {
+async function autoCompactIfNeeded(messages, config3 = DEFAULT_COMPACT_CONFIG, summarizer) {
   const tokenCount = countTokens2(messages);
-  if (tokenCount > config2.autoCompactThreshold) {
-    const compacted = await fullCompact(messages, config2.targetTokenCount, summarizer);
+  if (tokenCount > config3.autoCompactThreshold) {
+    const compacted = await fullCompact(messages, config3.targetTokenCount, summarizer);
     return { messages: compacted, compacted: true };
   }
-  if (tokenCount > config2.microCompactThreshold) {
+  if (tokenCount > config3.microCompactThreshold) {
     const compacted = await microCompact(messages);
     return { messages: compacted, compacted: true };
   }
@@ -27731,16 +28859,16 @@ async function fullCompact(messages, targetTokens, summarizer, llmClient) {
 }
 
 // src/app/agent/core/memory/session_memory.ts
-import fs41 from "fs";
-import os30 from "os";
-import path44 from "path";
+import fs40 from "fs";
+import os29 from "os";
+import path45 from "path";
 import { v4 as uuidv49 } from "uuid";
 var SessionMemoryExtractor = class {
   llmClient;
   memoryFile;
   constructor(options = {}) {
     this.llmClient = options.llmClient;
-    this.memoryFile = options.memoryFile || path44.join(os30.homedir(), ".bluma", "session_memory.json");
+    this.memoryFile = options.memoryFile || path45.join(os29.homedir(), ".bluma", "session_memory.json");
   }
   /**
    * Extract memories from conversation using LLM
@@ -27797,15 +28925,15 @@ ${messages.slice(-50).map((m) => `${m.role}: ${m.content.slice(0, 500)}`).join("
     );
     unique.sort((a, b) => b.accessCount - a.accessCount);
     const trimmed = unique.slice(0, 200);
-    fs41.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
+    fs40.writeFileSync(this.memoryFile, JSON.stringify(trimmed, null, 2));
   }
   /**
    * Load memories from disk
    */
   async loadMemories() {
     try {
-      if (!fs41.existsSync(this.memoryFile)) return [];
-      const data = fs41.readFileSync(this.memoryFile, "utf-8");
+      if (!fs40.existsSync(this.memoryFile)) return [];
+      const data = fs40.readFileSync(this.memoryFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return [];
@@ -28349,14 +29477,14 @@ var RouteManager = class {
     this.subAgents = subAgents;
     this.core = core;
   }
-  registerRoute(path56, handler) {
-    this.routeHandlers.set(path56, handler);
+  registerRoute(path57, handler) {
+    this.routeHandlers.set(path57, handler);
   }
   async handleRoute(payload) {
     const inputText = String(payload.content || "").trim();
     const { userContext, options } = payload;
-    for (const [path56, handler] of this.routeHandlers) {
-      if (inputText === path56 || inputText.startsWith(`${path56} `)) {
+    for (const [path57, handler] of this.routeHandlers) {
+      if (inputText === path57 || inputText.startsWith(`${path57} `)) {
         return handler({ content: inputText, userContext });
       }
     }
@@ -28365,13 +29493,13 @@ var RouteManager = class {
 };
 
 // src/app/agent/runtime/plugin_runtime.ts
-import path45 from "path";
+import path46 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 async function loadPluginsAtStartup() {
   for (const p of listPlugins()) {
     const entry = p.manifest.entry?.trim();
     if (!entry) continue;
-    const abs = path45.resolve(p.root, entry);
+    const abs = path46.resolve(p.root, entry);
     try {
       const href = pathToFileURL2(abs).href;
       const mod = await import(href);
@@ -28392,7 +29520,7 @@ async function loadPluginsAtStartup() {
 }
 
 // src/app/agent/agent.ts
-var globalEnvPath = path46.join(os31.homedir(), ".bluma", ".env");
+var globalEnvPath = path47.join(os30.homedir(), ".bluma", ".env");
 dotenv.config({ path: globalEnvPath });
 var Agent = class {
   sessionId;
@@ -30248,28 +31376,28 @@ function resolveToolPayload(result) {
 
 // src/app/ui/components/FilePathLink.tsx
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-import path48 from "node:path";
+import path49 from "node:path";
 
 // src/app/ui/utils/pathDisplay.ts
-import path47 from "node:path";
-import os32 from "node:os";
+import path48 from "node:path";
+import os31 from "node:os";
 function formatPathForDisplay(pathInput, cwd2 = process.cwd()) {
   let s = String(pathInput ?? "").trim();
   if (s.length > 1) {
     s = s.replace(/[/\\]+$/, "");
   }
   if (!s) return "";
-  const abs = path47.isAbsolute(s) ? path47.normalize(s) : path47.resolve(cwd2, s);
-  const resolvedCwd = path47.resolve(cwd2);
-  const rel = path47.relative(resolvedCwd, abs);
-  if (rel === "" || !rel.startsWith("..") && !path47.isAbsolute(rel)) {
+  const abs = path48.isAbsolute(s) ? path48.normalize(s) : path48.resolve(cwd2, s);
+  const resolvedCwd = path48.resolve(cwd2);
+  const rel = path48.relative(resolvedCwd, abs);
+  if (rel === "" || !rel.startsWith("..") && !path48.isAbsolute(rel)) {
     return rel === "" ? "." : rel;
   }
-  const home = path47.normalize(os32.homedir());
-  if (abs === home || abs.startsWith(home + path47.sep)) {
+  const home = path48.normalize(os31.homedir());
+  if (abs === home || abs.startsWith(home + path48.sep)) {
     return "~" + abs.slice(home.length);
   }
-  return path47.basename(abs);
+  return path48.basename(abs);
 }
 
 // src/app/ui/components/FilePathLink.tsx
@@ -30279,7 +31407,7 @@ function FilePathLink({ filePath, children, cwd: cwd2 = process.cwd(), color })
   if (!raw) {
     return null;
   }
-  const abs = path48.isAbsolute(raw) ? path48.normalize(raw) : path48.resolve(cwd2, raw);
+  const abs = path49.isAbsolute(raw) ? path49.normalize(raw) : path49.resolve(cwd2, raw);
   const href = pathToFileURL3(abs).href;
   const label = formatPathForDisplay(abs, cwd2);
   const text = typeof children === "string" ? children : label;
@@ -32231,12 +33359,12 @@ function patchToUnifiedDiffText(filePath, patch) {
 }
 
 // src/app/ui/utils/readEditContext.ts
-import { promises as fs42 } from "fs";
+import { promises as fs41 } from "fs";
 var CHUNK_SIZE = 64 * 1024;
 var CONTEXT_LINES2 = 3;
 async function openForScan(filePath) {
   try {
-    return await fs42.open(filePath, "r");
+    return await fs41.open(filePath, "r");
   } catch (e) {
     if (e.code === "ENOENT") return null;
     throw e;
@@ -32914,13 +34042,13 @@ function EditToolDiffPanel({
   newString,
   replaceAll = false
 }) {
-  const path56 = filePath.trim() || "unknown file";
+  const path57 = filePath.trim() || "unknown file";
   const hasPreviewArgs = oldString !== void 0 && newString !== void 0;
   const hasDiffText = diffText && diffText.trim().length > 0;
   return /* @__PURE__ */ jsx43(Box_default, { flexDirection: "column", children: hasPreviewArgs ? /* @__PURE__ */ jsx43(Box_default, { marginTop: 0, children: /* @__PURE__ */ jsx43(
     FileEditToolDiff,
     {
-      filePath: path56,
+      filePath: path57,
       oldString,
       newString,
       replaceAll,
@@ -32958,7 +34086,7 @@ function renderToolUseMessage12({ args }) {
   return /* @__PURE__ */ jsx44(Text, { color: BLUMA_TERMINAL.blue, children: p });
 }
 function renderToolHeader12({ args }) {
-  const path56 = args?.file_path ?? ".";
+  const path57 = args?.file_path ?? ".";
   const oldText = typeof args?.old_string === "string" ? args.old_string : "";
   const newText = typeof args?.new_string === "string" ? args.new_string : "";
   const counts = countLineDiff(oldText, newText);
@@ -32968,7 +34096,7 @@ function renderToolHeader12({ args }) {
       action,
       /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
         " ",
-        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path56, color: BLUMA_TERMINAL.dim })
+        /* @__PURE__ */ jsx44(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
       ] })
     ] }),
     /* @__PURE__ */ jsxs27(Text, { dimColor: true, children: [
@@ -33227,13 +34355,13 @@ var ToolResultCardComponent = ({
   maxLines = 5,
   children
 }) => {
-  const config2 = STATUS_CONFIG[status];
+  const config3 = STATUS_CONFIG[status];
   const { lines, truncated } = output ? truncateOutput(output, expanded ? 50 : maxLines) : { lines: [], truncated: false };
   return /* @__PURE__ */ jsxs28(Box_default, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsxs28(Box_default, { children: [
-      /* @__PURE__ */ jsxs28(Text, { color: config2.color, children: [
+      /* @__PURE__ */ jsxs28(Text, { color: config3.color, children: [
         "[",
-        config2.symbol,
+        config3.symbol,
         "]"
       ] }),
       /* @__PURE__ */ jsxs28(Text, { children: [
@@ -33360,11 +34488,11 @@ function userFacingName13() {
 }
 function renderToolUseMessage14({ args }) {
   const q = args?.query ? `"${args.query}"` : "...";
-  const path56 = args?.path || ".";
+  const path57 = args?.path || ".";
   return /* @__PURE__ */ jsxs30(Box_default, { flexDirection: "row", flexWrap: "wrap", alignItems: "flex-end", children: [
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.blue, children: q }),
     /* @__PURE__ */ jsx47(Text, { color: BLUMA_TERMINAL.dim, children: " " }),
-    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path56, color: BLUMA_TERMINAL.dim })
+    /* @__PURE__ */ jsx47(FilePathLink, { filePath: path57, color: BLUMA_TERMINAL.dim })
   ] });
 }
 function renderToolHeader14({ args }) {
@@ -33886,7 +35014,7 @@ var loadSkillTool = createTool({
 });
 
 // src/app/agent/tools/FileWriteTool/UI.tsx
-import fs43 from "fs";
+import fs42 from "fs";
 import { diffLines as diffLines3 } from "diff";
 import { jsx as jsx54, jsxs as jsxs37 } from "react/jsx-runtime";
 function getFilePath(args) {
@@ -33901,7 +35029,7 @@ function getFilePath(args) {
 function readExistingFileText(filePath) {
   if (!filePath) return "";
   try {
-    return fs43.readFileSync(filePath, "utf-8");
+    return fs42.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -36831,8 +37959,8 @@ import {
 
 // src/app/ui/hooks/useAtCompletion.ts
 import { useEffect as useEffect11, useRef as useRef4, useState as useState13 } from "react";
-import fs44 from "fs";
-import path49 from "path";
+import fs43 from "fs";
+import path50 from "path";
 var MAX_RESULTS3 = 50;
 var DEFAULT_RECURSIVE_DEPTH = 2;
 function listPathSuggestions(baseDir, pattern) {
@@ -36840,7 +37968,7 @@ function listPathSuggestions(baseDir, pattern) {
   const patternEndsWithSlash = raw.endsWith("/");
   const relDir = raw.replace(/^\/+|\/+$/g, "");
   const filterPrefix = patternEndsWithSlash ? "" : relDir.split("/").slice(-1)[0] || "";
-  const listDir = path49.resolve(baseDir, relDir || ".");
+  const listDir = path50.resolve(baseDir, relDir || ".");
   const results = [];
   const IGNORED_DIRS = ["node_modules", ".git", ".venv", "dist", "build"];
   const IGNORED_EXTS = [".pyc", ".class", ".o", ".map", ".log", ".tmp"];
@@ -36857,7 +37985,7 @@ function listPathSuggestions(baseDir, pattern) {
   }
   function pushEntry(entryPath, label, isDir) {
     if (results.length >= MAX_RESULTS3) return;
-    const clean = label.split(path49.sep).join("/").replace(/[]+/g, "");
+    const clean = label.split(path50.sep).join("/").replace(/[]+/g, "");
     results.push({ label: clean + (isDir ? "/" : ""), fullPath: entryPath, isDir });
   }
   try {
@@ -36866,11 +37994,11 @@ function listPathSuggestions(baseDir, pattern) {
       while (queue.length && results.length < MAX_RESULTS3) {
         const node = queue.shift();
         try {
-          const entries = fs44.readdirSync(node.dir, { withFileTypes: true });
+          const entries = fs43.readdirSync(node.dir, { withFileTypes: true });
           for (const entry of entries) {
             if (isIgnoredName(entry.name)) continue;
-            const entryAbs = path49.join(node.dir, entry.name);
-            const entryRel = node.rel ? path49.posix.join(node.rel, entry.name) : entry.name;
+            const entryAbs = path50.join(node.dir, entry.name);
+            const entryRel = node.rel ? path50.posix.join(node.rel, entry.name) : entry.name;
             if (entryRel.split("/").includes("node_modules")) continue;
             if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
             pushEntry(entryAbs, entryRel, entry.isDirectory());
@@ -36883,13 +38011,13 @@ function listPathSuggestions(baseDir, pattern) {
         }
       }
     } else {
-      const entries = fs44.readdirSync(listDir, { withFileTypes: true });
+      const entries = fs43.readdirSync(listDir, { withFileTypes: true });
       for (const entry of entries) {
         if (filterPrefix && !entry.name.startsWith(filterPrefix)) continue;
         if (isIgnoredName(entry.name)) continue;
         if (!entry.isDirectory() && isIgnoredFile(entry.name)) continue;
-        const entryAbs = path49.join(listDir, entry.name);
-        const label = relDir ? path49.posix.join(relDir, entry.name) : entry.name;
+        const entryAbs = path50.join(listDir, entry.name);
+        const label = relDir ? path50.posix.join(relDir, entry.name) : entry.name;
         pushEntry(entryAbs, label, entry.isDirectory());
         if (results.length >= MAX_RESULTS3) break;
       }
@@ -37090,16 +38218,16 @@ var SlashSubmenuInlineComponent = ({ menu }) => {
 var SlashSubmenuInline = memo15(SlashSubmenuInlineComponent);
 
 // src/app/ui/utils/clipboardImage.ts
-import fs45 from "fs";
-import os33 from "os";
-import path50 from "path";
+import fs44 from "fs";
+import os32 from "os";
+import path51 from "path";
 import { spawn as spawn5, execFile as execFileCb, execSync as execSync4 } from "child_process";
 import { promisify as promisify2 } from "util";
 
 // src/app/utils/clipboardNative.ts
 import { existsSync as existsSync7 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __dirname;
 function getDirname() {
@@ -37118,11 +38246,11 @@ function resolveNativePath() {
   const dir = getDirname();
   const candidates = [
     // Prod: dist/native/index.js (quando rodando dist/main.js)
-    join8(dir, "..", "native", "index.js"),
+    join13(dir, "..", "native", "index.js"),
     // Dev: native/index.js (quando rodando src/ via ts-node ou similar)
-    join8(dir, "..", "..", "..", "native", "index.js"),
+    join13(dir, "..", "..", "..", "native", "index.js"),
     // Fallback: project root
-    join8(dir, "native", "index.js")
+    join13(dir, "native", "index.js")
   ];
   for (const candidate of candidates) {
     if (existsSync7(candidate)) {
@@ -37219,10 +38347,10 @@ function commandOnPath(cmd) {
   }
 }
 function unixClipboardHelperDirs() {
-  const h = os33.homedir();
+  const h = os32.homedir();
   return [
-    path50.join(h, ".local", "bin"),
-    path50.join(h, "bin"),
+    path51.join(h, ".local", "bin"),
+    path51.join(h, "bin"),
     "/usr/bin",
     "/usr/local/bin",
     "/bin",
@@ -37240,16 +38368,16 @@ function resolveHelperBinary(cmd) {
     return cmd;
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path50.join(dir, cmd);
+    const full = path51.join(dir, cmd);
     try {
-      fs45.accessSync(full, fs45.constants.X_OK);
+      fs44.accessSync(full, fs44.constants.X_OK);
       return full;
     } catch {
     }
   }
   for (const dir of unixClipboardHelperDirs()) {
-    const full = path50.join(dir, cmd);
-    if (fs45.existsSync(full)) {
+    const full = path51.join(dir, cmd);
+    if (fs44.existsSync(full)) {
       return full;
     }
   }
@@ -37290,17 +38418,17 @@ function writeBufferIfImage(baseDir, buf) {
   if (!ext) {
     return null;
   }
-  const out = path50.join(
+  const out = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
-  fs45.writeFileSync(out, buf);
+  fs44.writeFileSync(out, buf);
   return out;
 }
 function unlinkQuiet(p) {
   try {
-    if (fs45.existsSync(p)) {
-      fs45.unlinkSync(p);
+    if (fs44.existsSync(p)) {
+      fs44.unlinkSync(p);
     }
   } catch {
   }
@@ -37317,25 +38445,25 @@ async function tryDarwinClipboardy(baseDir) {
       return null;
     }
     for (const src of tmpPaths) {
-      if (!src || !fs45.existsSync(src)) {
+      if (!src || !fs44.existsSync(src)) {
         continue;
       }
       let st;
       try {
-        st = fs45.statSync(src);
+        st = fs44.statSync(src);
       } catch {
         continue;
       }
       if (st.size < 80 || st.size > CLIPBOARD_MAX_BYTES) {
         continue;
       }
-      const ext = path50.extname(src).toLowerCase();
+      const ext = path51.extname(src).toLowerCase();
       const safeExt = ext && /^\.(png|jpe?g|gif|webp)$/i.test(ext) ? ext : ".png";
-      const out = path50.join(
+      const out = path51.join(
         baseDir,
         `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${safeExt}`
       );
-      fs45.copyFileSync(src, out);
+      fs44.copyFileSync(src, out);
       for (const p of tmpPaths) {
         unlinkQuiet(p);
       }
@@ -37349,14 +38477,14 @@ async function tryDarwinClipboardy(baseDir) {
   return null;
 }
 async function tryWindowsPowerShell(outFile) {
-  const ps = process.env.SystemRoot != null ? path50.join(
+  const ps = process.env.SystemRoot != null ? path51.join(
     process.env.SystemRoot,
     "System32",
     "WindowsPowerShell",
     "v1.0",
     "powershell.exe"
   ) : "powershell.exe";
-  if (!fs45.existsSync(ps)) {
+  if (!fs44.existsSync(ps)) {
     return false;
   }
   const script = "$ErrorActionPreference='Stop';Add-Type -AssemblyName System.Windows.Forms;Add-Type -AssemblyName System.Drawing;$img=[System.Windows.Forms.Clipboard]::GetImage();if($null -eq $img){exit 2};$img.Save($env:BLUMA_CLIP_OUT,[System.Drawing.Imaging.ImageFormat]::Png);exit 0";
@@ -37378,7 +38506,7 @@ async function tryWindowsPowerShell(outFile) {
     return false;
   }
   try {
-    const st = fs45.statSync(outFile);
+    const st = fs44.statSync(outFile);
     return st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES;
   } catch {
     return false;
@@ -37450,8 +38578,8 @@ function parseClipboardTextAsImagePath(raw) {
     s = s.slice(1, -1);
   }
   s = s.trim();
-  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path50.extname(s))) return null;
-  const abs = path50.isAbsolute(s) ? path50.normalize(s) : path50.resolve(process.cwd(), s);
+  if (!CLIPBOARD_PATH_IMAGE_EXT.test(path51.extname(s))) return null;
+  const abs = path51.isAbsolute(s) ? path51.normalize(s) : path51.resolve(process.cwd(), s);
   return abs;
 }
 async function tryClipboardTextAsImageFile(baseDir) {
@@ -37465,19 +38593,19 @@ async function tryClipboardTextAsImageFile(baseDir) {
   const abs = parseClipboardTextAsImagePath(t);
   if (!abs) return null;
   try {
-    if (!fs45.existsSync(abs)) return null;
-    const st = fs45.statSync(abs);
+    if (!fs44.existsSync(abs)) return null;
+    const st = fs44.statSync(abs);
     if (!st.isFile() || st.size > CLIPBOARD_MAX_BYTES || st.size < 20) return null;
   } catch {
     return null;
   }
-  const ext = path50.extname(abs).toLowerCase();
-  const out = path50.join(
+  const ext = path51.extname(abs).toLowerCase();
+  const out = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}${ext}`
   );
   try {
-    fs45.copyFileSync(abs, out);
+    fs44.copyFileSync(abs, out);
     return out;
   } catch {
     return null;
@@ -37487,7 +38615,7 @@ async function tryLinuxShellPipelineSave(baseDir) {
   if (process.platform !== "linux" && process.platform !== "freebsd") {
     return null;
   }
-  const outPath = path50.join(
+  const outPath = path51.join(
     baseDir,
     `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`
   );
@@ -37509,11 +38637,11 @@ printf '%s' "$OUT"
       maxBuffer: 4096
     });
     const written = String(stdout ?? "").trim();
-    if (written !== outPath || !fs45.existsSync(outPath)) {
+    if (written !== outPath || !fs44.existsSync(outPath)) {
       unlinkQuiet(outPath);
       return null;
     }
-    const buf = fs45.readFileSync(outPath);
+    const buf = fs44.readFileSync(outPath);
     unlinkQuiet(outPath);
     return writeBufferIfImage(baseDir, buf);
   } catch {
@@ -37534,8 +38662,8 @@ async function tryNativeClipboardImage() {
   }
   try {
     const result = readClipboardImageNative();
-    if (fs45.existsSync(result.path)) {
-      const st = fs45.statSync(result.path);
+    if (fs44.existsSync(result.path)) {
+      const st = fs44.statSync(result.path);
       if (st.size >= 80 && st.size <= CLIPBOARD_MAX_BYTES) {
         return result.path;
       }
@@ -37545,8 +38673,8 @@ async function tryNativeClipboardImage() {
   return null;
 }
 async function readClipboardImageToTempFile() {
-  const baseDir = path50.join(os33.homedir(), ".cache", "bluma", "clipboard");
-  fs45.mkdirSync(baseDir, { recursive: true });
+  const baseDir = path51.join(os32.homedir(), ".cache", "bluma", "clipboard");
+  fs44.mkdirSync(baseDir, { recursive: true });
   const nativeResult = await tryNativeClipboardImage();
   if (nativeResult) {
     return nativeResult;
@@ -37564,7 +38692,7 @@ async function readClipboardImageToTempFile() {
     }
   }
   if (process.platform === "win32") {
-    const outFile = path50.join(
+    const outFile = path51.join(
       baseDir,
       `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.png`
     );
@@ -37605,7 +38733,7 @@ function expandLargePastePlaceholder(value, pending) {
 }
 
 // src/app/ui/components/InputPrompt.tsx
-import fs46 from "fs";
+import fs45 from "fs";
 import { Fragment as Fragment7, jsx as jsx79, jsxs as jsxs62 } from "react/jsx-runtime";
 var persistedInputState = { text: "", cursorPosition: 0 };
 var StaticCursor = () => /* @__PURE__ */ jsx79(Box_default, { flexDirection: "row", flexWrap: "nowrap", children: /* @__PURE__ */ jsx79(Text, { bold: true, color: BLUMA_TERMINAL.m3OnSurface, children: "\u2588 " }) });
@@ -37772,7 +38900,7 @@ var InputPrompt = memo16(({
           return;
         }
         if (routeText.startsWith("/")) {
-          const isFilePath = map.size > 0 && fs46.existsSync(routeText.split(/\s+/)[0]);
+          const isFilePath = map.size > 0 && fs45.existsSync(routeText.split(/\s+/)[0]);
           if (isFilePath) {
             uiEventBus.emit("user_overlay", {
               kind: "message",
@@ -38659,9 +39787,9 @@ function AgentProgressLine({
   const displayDescription = task.progress?.summary || task.description || "Working...";
   const treeChar = isLast ? "\u2514\u2500" : "\u251C\u2500";
   const bullet = isViewed ? BLACK_CIRCLE2 : "\u25CF";
-  const sep = isRunning ? PLAY_ICON : PAUSE_ICON;
+  const sep4 = isRunning ? PLAY_ICON : PAUSE_ICON;
   const namePart = name ? `${name}: ` : "";
-  const suffixPart = ` ${sep} ${elapsed}${tokenText}${queuedText}`;
+  const suffixPart = ` ${sep4} ${elapsed}${tokenText}${queuedText}`;
   return /* @__PURE__ */ jsxs67(Box_default, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs67(Box_default, { paddingLeft: 3, children: [
       /* @__PURE__ */ jsxs67(Text, { dimColor: true, children: [
@@ -38672,7 +39800,7 @@ function AgentProgressLine({
         namePart,
         displayDescription,
         " ",
-        sep,
+        sep4,
         " ",
         elapsed,
         tokenText,
@@ -40052,8 +41180,9 @@ var renderCode = () => {
 };
 
 // src/app/agent/core/thread/thread_store.ts
-import path51 from "path";
-import { promises as fs47 } from "fs";
+init_bluma_app_dir();
+import path52 from "path";
+import { promises as fs46 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 var INDEX_VERSION = 1;
 var fileLocks2 = /* @__PURE__ */ new Map();
@@ -40078,9 +41207,9 @@ var ThreadStore = class {
   packageVersion;
   constructor() {
     const appDir = getPreferredAppDir();
-    this.threadsDir = path51.join(appDir, "threads");
-    this.archiveDir = path51.join(this.threadsDir, "archive");
-    this.indexPath = path51.join(this.threadsDir, "index.json");
+    this.threadsDir = path52.join(appDir, "threads");
+    this.archiveDir = path52.join(this.threadsDir, "archive");
+    this.indexPath = path52.join(this.threadsDir, "index.json");
     this.packageVersion = process.env.npm_package_version || "0.0.0";
   }
   // ==================== Inicialização ====================
@@ -40088,10 +41217,10 @@ var ThreadStore = class {
    * Inicializa o diretório de threads
    */
   async initialize() {
-    await fs47.mkdir(this.threadsDir, { recursive: true });
-    await fs47.mkdir(this.archiveDir, { recursive: true });
+    await fs46.mkdir(this.threadsDir, { recursive: true });
+    await fs46.mkdir(this.archiveDir, { recursive: true });
     try {
-      await fs47.access(this.indexPath);
+      await fs46.access(this.indexPath);
     } catch {
       await this.saveIndex({ version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
     }
@@ -40120,7 +41249,7 @@ var ThreadStore = class {
   async loadIndex() {
     return withFileLock2(this.indexPath, async () => {
       try {
-        const content = await fs47.readFile(this.indexPath, "utf-8");
+        const content = await fs46.readFile(this.indexPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return { version: INDEX_VERSION, threads: [], lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
@@ -40131,8 +41260,8 @@ var ThreadStore = class {
     return withFileLock2(this.indexPath, async () => {
       index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
       const tempPath = `${this.indexPath}.${Date.now()}.tmp`;
-      await fs47.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
-      await fs47.rename(tempPath, this.indexPath);
+      await fs46.writeFile(tempPath, JSON.stringify(index, null, 2), "utf-8");
+      await fs46.rename(tempPath, this.indexPath);
     });
   }
   // ==================== Git Info ====================
@@ -40202,7 +41331,7 @@ var ThreadStore = class {
       messages: params.initialMessages || []
     };
     const historyPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
+    await fs46.mkdir(path52.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -40257,7 +41386,7 @@ var ThreadStore = class {
       compressedSliceCount: source.history.compressedSliceCount
     };
     const historyPath = this.buildDatedThreadHistoryPath(newThreadId);
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true });
+    await fs46.mkdir(path52.dirname(historyPath), { recursive: true });
     await this.saveHistoryAtPath(historyPath, history);
     const index = await this.loadIndex();
     index.threads.unshift({
@@ -40330,9 +41459,9 @@ var ThreadStore = class {
     const entry = index.threads[entryIndex];
     if (entry.status === "archived") return true;
     const oldPath = entry.historyPath || this.getLegacyHistoryPath(threadId);
-    const newPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
+    const newPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
     try {
-      await fs47.rename(oldPath, newPath);
+      await fs46.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -40353,11 +41482,11 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     if (entry.status === "active") return true;
-    const oldPath = path51.join(this.archiveDir, `${threadId}.jsonl`);
+    const oldPath = path52.join(this.archiveDir, `${threadId}.jsonl`);
     const newPath = this.buildDatedThreadHistoryPath(threadId);
-    await fs47.mkdir(path51.dirname(newPath), { recursive: true });
+    await fs46.mkdir(path52.dirname(newPath), { recursive: true });
     try {
-      await fs47.rename(oldPath, newPath);
+      await fs46.rename(oldPath, newPath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -40378,7 +41507,7 @@ var ThreadStore = class {
     if (entryIndex === -1) return false;
     const entry = index.threads[entryIndex];
     try {
-      await fs47.unlink(entry.historyPath);
+      await fs46.unlink(entry.historyPath);
     } catch {
     }
     index.threads.splice(entryIndex, 1);
@@ -40388,28 +41517,28 @@ var ThreadStore = class {
   }
   // ==================== Histórico ====================
   getLegacyHistoryPath(threadId) {
-    return path51.join(this.threadsDir, `${threadId}.jsonl`);
+    return path52.join(this.threadsDir, `${threadId}.jsonl`);
   }
   /** ~/.bluma/threads/YYYY/MM/DD/<threadId>.jsonl (data local de criação). */
   buildDatedThreadHistoryPath(threadId, at = /* @__PURE__ */ new Date()) {
     const y = String(at.getFullYear());
     const mo = String(at.getMonth() + 1).padStart(2, "0");
     const d = String(at.getDate()).padStart(2, "0");
-    return path51.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
+    return path52.join(this.threadsDir, y, mo, d, `${threadId}.jsonl`);
   }
   async resolveHistoryPath(threadId) {
     const index = await this.loadIndex();
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (entry?.historyPath) {
       try {
-        await fs47.access(entry.historyPath);
+        await fs46.access(entry.historyPath);
         return entry.historyPath;
       } catch {
       }
     }
     const legacy = this.getLegacyHistoryPath(threadId);
     try {
-      await fs47.access(legacy);
+      await fs46.access(legacy);
       return legacy;
     } catch {
       return entry?.historyPath ?? legacy;
@@ -40426,9 +41555,9 @@ var ThreadStore = class {
     for (const msg of history.messages) {
       lines.push(JSON.stringify({ type: "message", ...msg }));
     }
-    await fs47.mkdir(path51.dirname(historyPath), { recursive: true }).catch(() => {
+    await fs46.mkdir(path52.dirname(historyPath), { recursive: true }).catch(() => {
     });
-    await fs47.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs46.writeFile(historyPath, lines.join("\n") + "\n", "utf-8");
   }
   /**
    * Guarda o histórico de uma thread
@@ -40450,7 +41579,7 @@ var ThreadStore = class {
     ].filter((p, i, arr) => Boolean(p) && arr.indexOf(p) === i);
     for (const historyPath of pathsToTry) {
       try {
-        const content = await fs47.readFile(historyPath, "utf-8");
+        const content = await fs46.readFile(historyPath, "utf-8");
         const lines = content.split("\n").filter(Boolean);
         const history = {
           threadId,
@@ -40485,7 +41614,7 @@ var ThreadStore = class {
     const entry = index.threads.find((t) => t.threadId === threadId);
     if (!entry) throw new Error(`Thread not found: ${threadId}`);
     const lines = messages.map((msg) => JSON.stringify({ type: "message", ...msg }));
-    await fs47.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
+    await fs46.appendFile(entry.historyPath, lines.join("\n") + "\n", "utf-8");
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await this.saveIndex(index);
   }
@@ -43358,16 +44487,16 @@ import latestVersion from "latest-version";
 import semverGt from "semver/functions/gt.js";
 import semverValid from "semver/functions/valid.js";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import path52 from "path";
-import fs48 from "fs";
+import path53 from "path";
+import fs47 from "fs";
 var BLUMA_PACKAGE_NAME = "@nomad-e/bluma-cli";
 function findBlumaPackageJson(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    const candidate = path52.join(dir, "package.json");
-    if (fs48.existsSync(candidate)) {
+    const candidate = path53.join(dir, "package.json");
+    if (fs47.existsSync(candidate)) {
       try {
-        const raw = fs48.readFileSync(candidate, "utf8");
+        const raw = fs47.readFileSync(candidate, "utf8");
         const parsed = JSON.parse(raw);
         if (parsed?.name === BLUMA_PACKAGE_NAME && parsed?.version) {
           return { name: parsed.name, version: String(parsed.version) };
@@ -43375,7 +44504,7 @@ function findBlumaPackageJson(startDir) {
       } catch {
       }
     }
-    const parent = path52.dirname(dir);
+    const parent = path53.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -43384,13 +44513,13 @@ function findBlumaPackageJson(startDir) {
 function resolveInstalledBlumaPackage() {
   const tried = /* @__PURE__ */ new Set();
   const tryFrom = (dir) => {
-    const abs = path52.resolve(dir);
+    const abs = path53.resolve(dir);
     if (tried.has(abs)) return null;
     tried.add(abs);
     return findBlumaPackageJson(abs);
   };
   try {
-    const fromBundle = tryFrom(path52.dirname(fileURLToPath6(import.meta.url)));
+    const fromBundle = tryFrom(path53.dirname(fileURLToPath6(import.meta.url)));
     if (fromBundle) return fromBundle;
   } catch {
   }
@@ -43398,12 +44527,12 @@ function resolveInstalledBlumaPackage() {
   if (argv1 && !argv1.startsWith("-")) {
     try {
       let resolved = argv1;
-      if (path52.isAbsolute(argv1) && fs48.existsSync(argv1)) {
-        resolved = fs48.realpathSync(argv1);
+      if (path53.isAbsolute(argv1) && fs47.existsSync(argv1)) {
+        resolved = fs47.realpathSync(argv1);
       } else {
-        resolved = path52.resolve(process.cwd(), argv1);
+        resolved = path53.resolve(process.cwd(), argv1);
       }
-      const fromArgv = tryFrom(path52.dirname(resolved));
+      const fromArgv = tryFrom(path53.dirname(resolved));
       if (fromArgv) return fromArgv;
     } catch {
     }
@@ -44222,16 +45351,16 @@ function usePlanMode() {
 
 // src/app/hooks/useAgentMode.ts
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback9 } from "react";
-import * as fs49 from "fs";
-import * as path53 from "path";
-import { homedir as homedir3 } from "os";
-var SETTINGS_PATH = path53.join(homedir3(), ".bluma", "settings.json");
+import * as fs48 from "fs";
+import * as path54 from "path";
+import { homedir as homedir4 } from "os";
+var SETTINGS_PATH = path54.join(homedir4(), ".bluma", "settings.json");
 function readAgentModeFromFile() {
   try {
-    if (!fs49.existsSync(SETTINGS_PATH)) {
+    if (!fs48.existsSync(SETTINGS_PATH)) {
       return "default";
     }
-    const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
+    const content = fs48.readFileSync(SETTINGS_PATH, "utf-8");
     const settings = JSON.parse(content);
     return settings.agentMode || "default";
   } catch (error) {
@@ -44250,16 +45379,16 @@ function useAgentMode() {
   }, []);
   const updateAgentMode = useCallback9((mode) => {
     try {
-      if (!fs49.existsSync(SETTINGS_PATH)) {
-        fs49.mkdirSync(path53.dirname(SETTINGS_PATH), { recursive: true });
+      if (!fs48.existsSync(SETTINGS_PATH)) {
+        fs48.mkdirSync(path54.dirname(SETTINGS_PATH), { recursive: true });
       }
       let settings = {};
-      if (fs49.existsSync(SETTINGS_PATH)) {
-        const content = fs49.readFileSync(SETTINGS_PATH, "utf-8");
+      if (fs48.existsSync(SETTINGS_PATH)) {
+        const content = fs48.readFileSync(SETTINGS_PATH, "utf-8");
         settings = JSON.parse(content);
       }
       settings.agentMode = mode;
-      fs49.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
+      fs48.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
       setAgentMode(mode);
     } catch (error) {
       console.error("Failed to update agent mode:", error);
@@ -45522,10 +46651,11 @@ import React39 from "react";
 import { memo as memo26, useCallback as useCallback11, useEffect as useEffect23, useMemo as useMemo8, useState as useState25 } from "react";
 
 // src/app/agent/session_manager/session_resume_browser.ts
-import path54 from "path";
-import { promises as fs50 } from "fs";
+init_bluma_app_dir();
+import path55 from "path";
+import { promises as fs49 } from "fs";
 function getSessionsRoot() {
-  return path54.join(getPreferredAppDir(), "sessions");
+  return path55.join(getPreferredAppDir(), "sessions");
 }
 function normalizeSessionsCwd(cwd2) {
   return cwd2.replace(/\\/g, "/").split("/").filter((p) => p && p !== "." && p !== "..").join("/");
@@ -45546,9 +46676,9 @@ async function sessionEntryFromFile(absPath, sessionId) {
   let preview = "(no messages)";
   let lastActivityMs = Date.now();
   try {
-    const st = await fs50.stat(absPath);
+    const st = await fs49.stat(absPath);
     lastActivityMs = st.mtimeMs;
-    const raw = await fs50.readFile(absPath, "utf-8");
+    const raw = await fs49.readFile(absPath, "utf-8");
     const data = JSON.parse(raw);
     preview = previewFromHistory(data.conversation_history);
     const iso = data.last_updated || data.created_at;
@@ -45576,15 +46706,15 @@ function compareDirNames(a, b) {
 async function listSessionBrowserEntries(cwdRel) {
   const cwd2 = normalizeSessionsCwd(cwdRel);
   const root = getSessionsRoot();
-  const absDir = cwd2 ? path54.join(root, ...cwd2.split("/")) : root;
+  const absDir = cwd2 ? path55.join(root, ...cwd2.split("/")) : root;
   const out = [];
   if (cwd2) {
     out.push({ kind: "up", label: ".." });
   }
   let dirents;
   try {
-    await fs50.mkdir(absDir, { recursive: true });
-    dirents = await fs50.readdir(absDir, { withFileTypes: true });
+    await fs49.mkdir(absDir, { recursive: true });
+    dirents = await fs49.readdir(absDir, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -45593,7 +46723,7 @@ async function listSessionBrowserEntries(cwdRel) {
   for (const e of dirents) {
     const name = String(e.name);
     if (name.startsWith(".")) continue;
-    const full = path54.join(absDir, name);
+    const full = path55.join(absDir, name);
     if (e.isDirectory()) {
       dirNames.push(name);
     } else if (e.isFile() && name.endsWith(".json") && !name.includes(".tmp")) {
@@ -45603,7 +46733,7 @@ async function listSessionBrowserEntries(cwdRel) {
   dirNames.sort(compareDirNames);
   const sessions = [];
   for (const { name, full } of sessionFiles) {
-    const sessionId = path54.basename(name, ".json");
+    const sessionId = path55.basename(name, ".json");
     sessions.push(await sessionEntryFromFile(full, sessionId));
   }
   sessions.sort((a, b) => {
@@ -45968,9 +47098,9 @@ async function runAgentMode() {
   try {
     if (inputFileIndex !== -1 && args[inputFileIndex + 1]) {
       const filePath = args[inputFileIndex + 1];
-      rawPayload = fs51.readFileSync(filePath, "utf-8");
+      rawPayload = fs50.readFileSync(filePath, "utf-8");
     } else {
-      rawPayload = fs51.readFileSync(0, "utf-8");
+      rawPayload = fs50.readFileSync(0, "utf-8");
     }
   } catch (err) {
     writeAgentEvent(registrySessionId, {
@@ -46211,9 +47341,9 @@ async function runAgentMode() {
 }
 function readCliPackageVersion() {
   try {
-    const base = path55.dirname(fileURLToPath7(import.meta.url));
-    const pkgPath = path55.join(base, "..", "package.json");
-    const j = JSON.parse(fs51.readFileSync(pkgPath, "utf8"));
+    const base = path56.dirname(fileURLToPath7(import.meta.url));
+    const pkgPath = path56.join(base, "..", "package.json");
+    const j = JSON.parse(fs50.readFileSync(pkgPath, "utf8"));
     return String(j.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -46339,7 +47469,7 @@ function startBackgroundAgent() {
     process.exit(1);
   }
   const filePath = args[inputFileIndex + 1];
-  const rawPayload = fs51.readFileSync(filePath, "utf-8");
+  const rawPayload = fs50.readFileSync(filePath, "utf-8");
   const envelope = JSON.parse(rawPayload);
   const sessionId = envelope.session_id || envelope.message_id || uuidv412();
   registerSession({