@letta-ai/letta-code 0.23.8 → 0.23.9

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.23.8",
+    version: "0.23.9",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -4751,7 +4751,10 @@ If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, a
     timeout: Number(process.env.LETTA_REQUEST_TIMEOUT_MS) || 10 * 60 * 1000,
     defaultHeaders: {
       "X-Letta-Source": "letta-code",
-      "User-Agent": `letta-code/${package_default.version}`
+      "User-Agent": `letta-code/${package_default.version}`,
+      ...process.env.LETTA_NODE === "1" && {
+        "x-letta-node": "1"
+      }
     },
     ...isTimingsEnabled() && { fetch: createTimingFetch(fetch) }
   });
@@ -9936,6 +9939,17 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "kimi-k2.6",
+        handle: "openrouter/moonshotai/kimi-k2.6",
+        label: "Kimi K2.6",
+        description: "Moonshot AI's next-gen multimodal coding and agent model",
+        isFeatured: true,
+        updateArgs: {
+          context_window: 200000,
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "deepseek-chat-v3.1",
         handle: "openrouter/deepseek/deepseek-chat-v3.1",
@@ -38755,7 +38769,9 @@ __export(exports_memoryGit, {
   getGitRemoteUrl: () => getGitRemoteUrl,
   getAgentRootDir: () => getAgentRootDir,
   formatGitCredentialHelperPath: () => formatGitCredentialHelperPath,
+  commitAndSyncMemoryWrite: () => commitAndSyncMemoryWrite,
   cloneMemoryRepo: () => cloneMemoryRepo,
+  assertMemoryRepoReadyForWrite: () => assertMemoryRepoReadyForWrite,
   addGitMemoryTag: () => addGitMemoryTag,
   PRE_COMMIT_HOOK_SCRIPT: () => PRE_COMMIT_HOOK_SCRIPT,
   GIT_MEMORY_ENABLED_TAG: () => GIT_MEMORY_ENABLED_TAG
@@ -38930,6 +38946,185 @@ function installPreCommitHook(dir) {
   chmodSync(hookPath, 493);
   debugLog("memfs-git", "Installed pre-commit hook");
 }
+function normalizePathspecs(pathspecs) {
+  return Array.from(new Set(pathspecs)).filter((path2) => path2.trim().length > 0);
+}
+function isNonFastForwardPushError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return NON_FAST_FORWARD_PUSH_ERROR_RE.test(message);
+}
+async function prepareMemoryRepoForGitOps(memoryDir, agentId, token) {
+  await maybeUpdateMemoryRemoteOrigin(memoryDir, agentId);
+  await configureLocalCredentialHelper(memoryDir, token);
+  installPreCommitHook(memoryDir);
+}
+async function stageMemoryPaths(memoryDir, pathspecs) {
+  if (pathspecs.length === 0) {
+    return;
+  }
+  await runGit(memoryDir, ["add", "-A", "--", ...pathspecs]);
+}
+async function hasStagedMemoryChanges(memoryDir, pathspecs) {
+  if (pathspecs.length === 0) {
+    return false;
+  }
+  const status = await runGit(memoryDir, [
+    "status",
+    "--porcelain",
+    "--",
+    ...pathspecs
+  ]);
+  return status.stdout.trim().length > 0;
+}
+async function commitMemoryPaths(memoryDir, pathspecs, reason, author) {
+  const normalizedPathspecs = normalizePathspecs(pathspecs);
+  await stageMemoryPaths(memoryDir, normalizedPathspecs);
+  if (!await hasStagedMemoryChanges(memoryDir, normalizedPathspecs)) {
+    return { committed: false };
+  }
+  try {
+    await runGit(memoryDir, [
+      "-c",
+      `user.name=${author.authorName.trim() || author.agentId}`,
+      "-c",
+      `user.email=${author.authorEmail}`,
+      "commit",
+      "-m",
+      reason
+    ]);
+  } catch (error) {
+    await unstageMemoryPaths(memoryDir, normalizedPathspecs);
+    throw error;
+  }
+  const head = await runGit(memoryDir, ["rev-parse", "HEAD"]);
+  return {
+    committed: true,
+    sha: head.stdout.trim()
+  };
+}
+async function unstageMemoryPaths(memoryDir, pathspecs) {
+  if (pathspecs.length === 0) {
+    return;
+  }
+  try {
+    await runGit(memoryDir, ["reset", "HEAD", "--", ...pathspecs]);
+  } catch {}
+}
+async function fetchMemoryRemote(memoryDir, token) {
+  await runGitWithRetry(memoryDir, ["fetch", "origin"], token, {
+    operation: "fetch origin"
+  });
+}
+async function resetMemoryToUpstream(memoryDir, token) {
+  await runGit(memoryDir, ["reset", "--hard", "@{u}"], token);
+}
+function buildMemoryConflictRef(sha) {
+  const timestamp = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+  return `refs/letta-conflicts/${timestamp}-${sha.slice(0, 7)}`;
+}
+async function preserveMemoryCommit(memoryDir, sha) {
+  const ref = buildMemoryConflictRef(sha);
+  await runGit(memoryDir, ["update-ref", ref, sha]);
+  return ref;
+}
+function formatCommittedButPushFailed(sha, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `Memory changes were committed (${sha.slice(0, 7)}) but push failed: ${message}`;
+}
+function formatReplayConflict(sha, rescueRef, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `Memory changes conflicted with newer remote memory and could not be replayed safely. Preserved local commit ${sha.slice(0, 7)} at ${rescueRef}; local branch was reset to upstream. Replay error: ${message}`;
+}
+function formatReplayPushFailure(originalSha, originalRef, replaySha, replayRef, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const replaySummary = replaySha && replayRef ? ` Replayed commit ${replaySha.slice(0, 7)} was preserved at ${replayRef}.` : "";
+  return `Memory changes conflicted with newer remote memory and the replayed update could not be pushed safely. Original commit ${originalSha.slice(0, 7)} was preserved at ${originalRef}.${replaySummary} Local branch was reset to upstream. Push error: ${message}`;
+}
+async function recoverMemoryPushConflict(params, token, initialSha) {
+  const rescueRef = await preserveMemoryCommit(params.memoryDir, initialSha);
+  await fetchMemoryRemote(params.memoryDir, token);
+  await resetMemoryToUpstream(params.memoryDir, token);
+  let replayedPathspecs = [];
+  try {
+    replayedPathspecs = normalizePathspecs(await params.replay?.() ?? []);
+  } catch (error) {
+    await resetMemoryToUpstream(params.memoryDir, token);
+    throw new Error(formatReplayConflict(initialSha, rescueRef, error));
+  }
+  let replayCommit;
+  try {
+    replayCommit = await commitMemoryPaths(params.memoryDir, replayedPathspecs, params.reason, params.author);
+  } catch (error) {
+    await resetMemoryToUpstream(params.memoryDir, token);
+    throw new Error(formatReplayConflict(initialSha, rescueRef, error));
+  }
+  if (!replayCommit.committed) {
+    return {
+      committed: true,
+      replayed: true,
+      replayNoop: true,
+      rescueRef
+    };
+  }
+  try {
+    await runGit(params.memoryDir, ["push"], token);
+  } catch (error) {
+    const replayRef = replayCommit.sha ? await preserveMemoryCommit(params.memoryDir, replayCommit.sha) : undefined;
+    await resetMemoryToUpstream(params.memoryDir, token);
+    throw new Error(formatReplayPushFailure(initialSha, rescueRef, replayCommit.sha, replayRef, error));
+  }
+  return {
+    committed: true,
+    sha: replayCommit.sha,
+    replayed: true,
+    rescueRef
+  };
+}
+async function assertMemoryRepoReadyForWrite(memoryDir) {
+  const status = await runGit(memoryDir, ["status", "--porcelain"]);
+  if (status.stdout.trim().length > 0) {
+    throw new Error("Memory repo has uncommitted changes. Commit, discard, or sync them before using memory tools.");
+  }
+  try {
+    const { stdout } = await runGit(memoryDir, [
+      "rev-list",
+      "--count",
+      "@{u}..HEAD"
+    ]);
+    const aheadCount = parseInt(stdout.trim(), 10);
+    if (aheadCount > 0) {
+      throw new Error("Memory repo has local commits that are not pushed to remote. Sync the repo before using memory tools.");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not pushed to remote")) {
+      throw error;
+    }
+  }
+}
+async function commitAndSyncMemoryWrite(params) {
+  const normalizedPathspecs = normalizePathspecs(params.pathspecs);
+  if (normalizedPathspecs.length === 0) {
+    return { committed: false };
+  }
+  const token = await getAuthToken();
+  await prepareMemoryRepoForGitOps(params.memoryDir, params.author.agentId, token);
+  const commitResult = await commitMemoryPaths(params.memoryDir, normalizedPathspecs, params.reason, params.author);
+  if (!commitResult.committed || !commitResult.sha) {
+    return { committed: false };
+  }
+  try {
+    await runGit(params.memoryDir, ["push"], token);
+  } catch (error) {
+    if (!params.replay || !isNonFastForwardPushError(error)) {
+      throw new Error(formatCommittedButPushFailed(commitResult.sha, error));
+    }
+    return recoverMemoryPushConflict(params, token, commitResult.sha);
+  }
+  return {
+    committed: true,
+    sha: commitResult.sha
+  };
+}
 function isGitRepo(agentId) {
   return existsSync8(join7(getMemoryRepoDir(agentId), ".git"));
 }
@@ -39000,25 +39195,8 @@ Hint: verify remote and auth:
 async function pushMemory(agentId) {
   const token = await getAuthToken();
   const dir = getMemoryRepoDir(agentId);
-  await maybeUpdateMemoryRemoteOrigin(dir, agentId);
-  await configureLocalCredentialHelper(dir, token);
-  try {
-    await runGit(dir, ["push"], token);
-    return;
-  } catch (pushError) {
-    debugWarn("memfs-git", `Push failed, attempting pull --rebase: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-  }
-  try {
-    await runGit(dir, ["pull", "--rebase"], token);
-  } catch (pullError) {
-    debugWarn("memfs-git", `Pull --rebase also failed (remote may be empty): ${pullError instanceof Error ? pullError.message : String(pullError)}`);
-    return;
-  }
-  try {
-    await runGit(dir, ["push"], token);
-  } catch (retryError) {
-    debugWarn("memfs-git", `Push failed after rebase: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
-  }
+  await prepareMemoryRepoForGitOps(dir, agentId, token);
+  await runGit(dir, ["push"], token);
 }
 async function getMemoryGitStatus(agentId) {
   const dir = getMemoryRepoDir(agentId);
@@ -39079,7 +39257,7 @@ async function removeGitMemoryTag(agentId) {
     debugWarn("memfs-git", `Failed to remove git-memory tag: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var execFile, GIT_MEMORY_ENABLED_TAG = "git-memory-enabled", RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, PRE_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
+var execFile, GIT_MEMORY_ENABLED_TAG = "git-memory-enabled", RETRYABLE_GIT_HTTP_ERROR_RE, RETRYABLE_GIT_NETWORK_ERROR_RE, MISSING_CWD_GIT_ERROR_RE, NON_FAST_FORWARD_PUSH_ERROR_RE, PRE_COMMIT_HOOK_SCRIPT = `#!/usr/bin/env bash
 # Validate frontmatter in staged memory .md files
 # Installed by Letta Code CLI
 
@@ -39224,6 +39402,7 @@ var init_memoryGit = __esm(() => {
   RETRYABLE_GIT_HTTP_ERROR_RE = /(?:\bHTTP\s+(?:520|521|522|523|524)\b|The requested URL returned error:\s*(?:520|521|522|523|524))/i;
   RETRYABLE_GIT_NETWORK_ERROR_RE = /(remote end hung up unexpectedly|connection reset by peer|operation timed out|timed out)/i;
   MISSING_CWD_GIT_ERROR_RE = /(Unable to read current working directory: No such file or directory|\buv_cwd\b|\bcwd\b.*\bENOENT\b)/i;
+  NON_FAST_FORWARD_PUSH_ERROR_RE = /(non-fast-forward|fetch first|failed to push some refs|updates were rejected|remote contains work that you do not have locally|tip of your current branch is behind)/i;
 });
 
 // src/agent/personality.ts
@@ -39492,33 +39671,36 @@ function detectPersonalityFromPersonaFile(personaFileContent) {
   }
   return null;
 }
-function isExitCode(error, expectedCode) {
-  if (!error || typeof error !== "object")
-    return false;
-  const code = error.code;
-  return code === expectedCode;
-}
-async function runGit2(cwd2, args) {
-  const result = await execFile2("git", args, {
-    cwd: cwd2,
-    maxBuffer: 10485760,
-    timeout: 60000
-  });
-  return result.stdout?.toString() ?? "";
-}
-async function hasStagedChanges(cwd2, relativePaths) {
-  if (relativePaths.length === 0) {
-    return false;
-  }
+async function getMemoryCommitAuthor(agentId) {
+  let authorName = agentId;
   try {
-    await runGit2(cwd2, ["diff", "--cached", "--quiet", "--", ...relativePaths]);
-    return false;
-  } catch (error) {
-    if (isExitCode(error, 1)) {
-      return true;
+    const client = await getClient();
+    const agent = await client.agents.retrieve(agentId);
+    if (agent.name?.trim()) {
+      authorName = agent.name.trim();
     }
-    throw error;
+  } catch {}
+  return {
+    agentId,
+    authorName,
+    authorEmail: `${agentId}@letta.com`
+  };
+}
+function applyPersonalityFiles(filesToUpdate) {
+  const changedPaths = [];
+  for (const file of filesToUpdate) {
+    const existingContent = existsSync9(file.absolutePath) ? readFileSync6(file.absolutePath, "utf-8") : null;
+    const nextContent = existingContent ? replaceBodyPreservingFrontmatter(existingContent, file.content, {
+      description: file.description
+    }) : buildDefaultMemoryFile(file.templatePromptAssetName, file.content, file.description);
+    if (existingContent !== null && normalizeComparableContent(existingContent) === normalizeComparableContent(nextContent)) {
+      continue;
+    }
+    mkdirSync7(dirname3(file.absolutePath), { recursive: true });
+    writeFileSync5(file.absolutePath, nextContent, "utf-8");
+    changedPaths.push(file.relativePath);
   }
+  return changedPaths;
 }
 async function applyPersonalityToMemory(params) {
   const personality = getPersonalityOption(params.personalityId);
@@ -39552,19 +39734,7 @@ async function applyPersonalityToMemory(params) {
       description: blockDefinitions.human.description
     }
   ];
-  const changedPaths = [];
-  for (const file of filesToUpdate) {
-    const existingContent = existsSync9(file.absolutePath) ? readFileSync6(file.absolutePath, "utf-8") : null;
-    const nextContent = existingContent ? replaceBodyPreservingFrontmatter(existingContent, file.content, {
-      description: file.description
-    }) : buildDefaultMemoryFile(file.templatePromptAssetName, file.content, file.description);
-    if (existingContent !== null && normalizeComparableContent(existingContent) === normalizeComparableContent(nextContent)) {
-      continue;
-    }
-    mkdirSync7(dirname3(file.absolutePath), { recursive: true });
-    writeFileSync5(file.absolutePath, nextContent, "utf-8");
-    changedPaths.push(file.relativePath);
-  }
+  const changedPaths = applyPersonalityFiles(filesToUpdate);
   if (changedPaths.length === 0) {
     return {
       changed: false,
@@ -39573,8 +39743,16 @@ async function applyPersonalityToMemory(params) {
       humanRelativePath
     };
   }
-  await runGit2(repoDir, ["add", "--", ...changedPaths]);
-  if (!await hasStagedChanges(repoDir, changedPaths)) {
+  const commitMessage = params.commitMessage ?? `chore(personality): switch to ${personality.label}`;
+  const author = await getMemoryCommitAuthor(params.agentId);
+  const commitResult = await commitAndSyncMemoryWrite({
+    memoryDir: repoDir,
+    pathspecs: changedPaths,
+    reason: commitMessage,
+    author,
+    replay: async () => applyPersonalityFiles(filesToUpdate)
+  });
+  if (!commitResult.committed) {
     return {
       changed: false,
       personality,
@@ -39582,16 +39760,6 @@ async function applyPersonalityToMemory(params) {
       humanRelativePath
     };
   }
-  const commitMessage = params.commitMessage ?? `chore(personality): switch to ${personality.label}`;
-  await runGit2(repoDir, [
-    "commit",
-    "--only",
-    "-m",
-    commitMessage,
-    "--",
-    ...changedPaths
-  ]);
-  await pushMemory(params.agentId);
   return {
     changed: true,
     personality,
@@ -39603,6 +39771,7 @@ async function applyPersonalityToMemory(params) {
 var execFile2, PRIMARY_PERSONA_RELATIVE_PATH = "system/persona.md", LEGACY_PERSONA_RELATIVE_PATH = "memory/system/persona.md", PRIMARY_HUMAN_RELATIVE_PATH = "system/human.md", LEGACY_HUMAN_RELATIVE_PATH = "memory/system/human.md", PERSONALITY_OPTIONS, DEFAULT_CREATE_AGENT_PERSONALITIES, PERSONALITY_ALIASES, FRONTMATTER_REGEX, EDITABLE_FRONTMATTER_KEYS;
 var init_personality = __esm(() => {
   init_settings_manager();
+  init_client2();
   init_memory();
   init_memoryGit();
   init_promptAssets();
@@ -43368,7 +43537,7 @@ var init_targets = __esm(() => {
 
 // src/cli/helpers/gitContext.ts
 import { execFileSync } from "node:child_process";
-function runGit3(args, cwd2) {
+function runGit2(args, cwd2) {
   try {
     return execFileSync("git", args, {
       cwd: cwd2,
@@ -43401,7 +43570,7 @@ function formatGitUser(name, email) {
 function gatherGitContextSnapshot(options = {}) {
   const cwd2 = options.cwd ?? process.cwd();
   const recentCommitLimit = options.recentCommitLimit ?? 3;
-  if (!runGit3(["rev-parse", "--git-dir"], cwd2)) {
+  if (!runGit2(["rev-parse", "--git-dir"], cwd2)) {
     return {
       isGitRepo: false,
       branch: null,
@@ -43410,16 +43579,16 @@ function gatherGitContextSnapshot(options = {}) {
       gitUser: null
     };
   }
-  const branch = runGit3(["branch", "--show-current"], cwd2);
-  const fullStatus = runGit3(["status", "--short"], cwd2);
+  const branch = runGit2(["branch", "--show-current"], cwd2);
+  const fullStatus = runGit2(["status", "--short"], cwd2);
   const status = typeof fullStatus === "string" && options.statusLineLimit ? truncateLines(fullStatus, options.statusLineLimit) : fullStatus;
-  const recentCommits = options.recentCommitFormat ? runGit3([
+  const recentCommits = options.recentCommitFormat ? runGit2([
     "log",
     `--format=${options.recentCommitFormat}`,
     "-n",
     String(recentCommitLimit)
-  ], cwd2) : runGit3(["log", "--oneline", "-n", String(recentCommitLimit)], cwd2);
-  const userConfig = runGit3(["config", "--get-regexp", "^user\\.(name|email)$"], cwd2);
+  ], cwd2) : runGit2(["log", "--oneline", "-n", String(recentCommitLimit)], cwd2);
+  const userConfig = runGit2(["config", "--get-regexp", "^user\\.(name|email)$"], cwd2);
   let userName = null;
   let userEmail = null;
   if (userConfig) {
@@ -43441,11 +43610,11 @@ function gatherGitContextSnapshot(options = {}) {
   };
 }
 function getGitContext(cwd2) {
-  if (!runGit3(["rev-parse", "--git-dir"], cwd2)) {
+  if (!runGit2(["rev-parse", "--git-dir"], cwd2)) {
     return null;
   }
-  const branch = runGit3(["branch", "--show-current"], cwd2);
-  const branchList = runGit3([
+  const branch = runGit2(["branch", "--show-current"], cwd2);
+  const branchList = runGit2([
     "branch",
     "--sort=-committerdate",
     "--format=%(refname:short)",
@@ -46325,6 +46494,100 @@ var init_hooks = __esm(() => {
   init_types2();
 });
 
+// src/permissions/canonical.ts
+function canonicalToolName(toolName) {
+  if (SHELL_TOOL_NAMES.has(toolName))
+    return "Bash";
+  if (READ_TOOL_NAMES.has(toolName))
+    return "Read";
+  if (WRITE_TOOL_NAMES.has(toolName))
+    return "Write";
+  if (EDIT_TOOL_NAMES.has(toolName))
+    return "Edit";
+  if (GLOB_TOOL_NAMES.has(toolName))
+    return "Glob";
+  if (GREP_TOOL_NAMES.has(toolName))
+    return "Grep";
+  if (LIST_TOOL_NAMES.has(toolName))
+    return "ListDir";
+  if (TASK_TOOL_NAMES.has(toolName))
+    return "Task";
+  return toolName;
+}
+function isShellToolName(toolName) {
+  return canonicalToolName(toolName) === "Bash";
+}
+function isFileToolName(toolName) {
+  return FILE_TOOL_FAMILIES.has(canonicalToolName(toolName));
+}
+function canonicalizePathLike(value) {
+  let normalized = value.replace(/\\/g, "/").trim();
+  if (/^\/+[a-zA-Z]:\//.test(normalized)) {
+    normalized = normalized.replace(/^\/+/, "");
+  }
+  if (/^[a-zA-Z]:\//.test(normalized)) {
+    normalized = `${normalized[0]?.toUpperCase() ?? ""}${normalized.slice(1)}`;
+  }
+  return normalized;
+}
+var SHELL_TOOL_NAMES, READ_TOOL_NAMES, WRITE_TOOL_NAMES, EDIT_TOOL_NAMES, GLOB_TOOL_NAMES, GREP_TOOL_NAMES, LIST_TOOL_NAMES, TASK_TOOL_NAMES, FILE_TOOL_FAMILIES;
+var init_canonical = __esm(() => {
+  SHELL_TOOL_NAMES = new Set([
+    "Bash",
+    "shell",
+    "Shell",
+    "shell_command",
+    "ShellCommand",
+    "run_shell_command",
+    "RunShellCommand"
+  ]);
+  READ_TOOL_NAMES = new Set([
+    "Read",
+    "read_file",
+    "ReadFile",
+    "read_file_gemini",
+    "ReadFileGemini"
+  ]);
+  WRITE_TOOL_NAMES = new Set([
+    "Write",
+    "write_file",
+    "WriteFile",
+    "write_file_gemini",
+    "WriteFileGemini"
+  ]);
+  EDIT_TOOL_NAMES = new Set([
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
+    "replace",
+    "Replace"
+  ]);
+  GLOB_TOOL_NAMES = new Set(["Glob", "glob_gemini", "GlobGemini"]);
+  GREP_TOOL_NAMES = new Set([
+    "Grep",
+    "grep_files",
+    "GrepFiles",
+    "search_file_content",
+    "SearchFileContent"
+  ]);
+  LIST_TOOL_NAMES = new Set([
+    "list_dir",
+    "ListDir",
+    "list_directory",
+    "ListDirectory",
+    "LS"
+  ]);
+  TASK_TOOL_NAMES = new Set(["Task", "task"]);
+  FILE_TOOL_FAMILIES = new Set([
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "ListDir"
+  ]);
+});
+
 // src/utils/directoryLimits.ts
 function parsePositiveIntEnv(value, fallback, min, max) {
   if (!value || value.trim() === "") {
@@ -47133,32 +47396,39 @@ function addRootAndSiblingWorktree(root, acc) {
     acc.add(normalizeScopedPath(resolve4(dirname5(normalizedRoot), "memory-worktrees")));
   }
 }
-function getExplicitEnvRoots(env3) {
-  const orderedRoots = [
-    env3.MEMORY_DIR,
-    env3.LETTA_MEMORY_DIR,
-    env3.PARENT_MEMORY_DIR
-  ].map((value) => value?.trim() ?? "").filter((value) => value.length > 0);
-  const explicitRootSet = new Set;
+function parseScopeList(value) {
+  if (!value)
+    return [];
+  return value.split(/[\s,]+/).map((id) => id.trim()).filter((id) => id.length > 0);
+}
+function getExplicitEnvRoots(env3, homeDir) {
+  const orderedRoots = [env3.MEMORY_DIR, env3.LETTA_MEMORY_DIR].map((value) => value?.trim() ?? "").filter((value) => value.length > 0);
+  const rootSet = new Set;
   for (const root of orderedRoots) {
-    addRootAndSiblingWorktree(root, explicitRootSet);
+    addRootAndSiblingWorktree(root, rootSet);
+  }
+  const scopeIds = new Set([
+    ...parseScopeList(env3.LETTA_MEMORY_SCOPE),
+    ...cliPermissions.getMemoryScope()
+  ]);
+  for (const id of scopeIds) {
+    addRootAndSiblingWorktree(getMemoryFilesystemRoot(id, homeDir), rootSet);
   }
   return {
-    explicitRoots: [...explicitRootSet],
+    roots: [...rootSet],
     primaryRoot: orderedRoots.length > 0 ? normalizeScopedPath(orderedRoots[0]) : null
   };
 }
 function deriveAgentId(env3, explicitAgentId) {
   const explicit = explicitAgentId?.trim();
-  if (explicit) {
+  if (explicit)
     return explicit;
-  }
   const envAgentId = (env3.AGENT_ID || env3.LETTA_AGENT_ID || "").trim();
-  if (envAgentId) {
+  if (envAgentId)
     return envAgentId;
-  }
   try {
-    return getCurrentAgentId().trim();
+    const fromContext = getCurrentAgentId().trim();
+    return fromContext || null;
   } catch {
     return null;
   }
@@ -47188,11 +47458,10 @@ function getFallbackRoots(env3, homeDir, currentAgentId, parentAgentId) {
 function resolveAllowedMemoryRoots(options = {}) {
   const env3 = options.env ?? process.env;
   const homeDir = options.homeDir ?? homedir11();
-  const explicit = getExplicitEnvRoots(env3);
-  if (explicit.explicitRoots.length > 0) {
+  const explicit = getExplicitEnvRoots(env3, homeDir);
+  if (explicit.roots.length > 0) {
     return {
-      roots: explicit.explicitRoots,
-      explicitRoots: explicit.explicitRoots,
+      roots: explicit.roots,
       primaryRoot: explicit.primaryRoot,
       usedFallback: false
     };
@@ -47200,7 +47469,6 @@ function resolveAllowedMemoryRoots(options = {}) {
   const fallback = getFallbackRoots(env3, homeDir, options.currentAgentId, options.parentAgentId);
   return {
     roots: fallback.roots,
-    explicitRoots: [],
     primaryRoot: fallback.primaryRoot,
     usedFallback: fallback.roots.length > 0
   };
@@ -47208,6 +47476,320 @@ function resolveAllowedMemoryRoots(options = {}) {
 var init_memoryScope = __esm(() => {
   init_context();
   init_memoryFilesystem();
+  init_cli();
+});
+
+// src/permissions/shell-command-normalization.ts
+function trimMatchingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
+  }
+  const first = trimmed[0];
+  const last = trimmed[trimmed.length - 1];
+  if ((first === '"' || first === "'") && last === first) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function normalizeExecutableToken(token) {
+  const normalized = trimMatchingQuotes(token).replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  const executable = parts[parts.length - 1] ?? normalized;
+  return executable.toLowerCase();
+}
+function tokenizeShell(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  const flush = () => {
+    if (current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+  for (let i = 0;i < input.length; i += 1) {
+    const ch = input[i];
+    if (ch === undefined) {
+      continue;
+    }
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (ch === "\\" && quote !== "single") {
+      escaping = true;
+      continue;
+    }
+    if (quote === "single") {
+      if (ch === "'") {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (quote === "double") {
+      if (ch === '"') {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      quote = "single";
+      continue;
+    }
+    if (ch === '"') {
+      quote = "double";
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      flush();
+      continue;
+    }
+    current += ch;
+  }
+  if (escaping) {
+    current += "\\";
+  }
+  flush();
+  return tokens;
+}
+function isDashCFlag(token) {
+  return token === "-c" || /^-[a-zA-Z]*c[a-zA-Z]*$/.test(token);
+}
+function extractInnerShellCommand(tokens) {
+  if (tokens.length === 0) {
+    return null;
+  }
+  let index = 0;
+  if (normalizeExecutableToken(tokens[0] ?? "") === "env") {
+    index += 1;
+    while (index < tokens.length) {
+      const token = tokens[index] ?? "";
+      if (!token) {
+        index += 1;
+        continue;
+      }
+      if (/^-[A-Za-z]+$/.test(token)) {
+        index += 1;
+        continue;
+      }
+      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
+        index += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  const executableToken = tokens[index];
+  if (!executableToken) {
+    return null;
+  }
+  if (!SHELL_EXECUTORS.has(normalizeExecutableToken(executableToken))) {
+    return null;
+  }
+  for (let i = index + 1;i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (!token) {
+      continue;
+    }
+    if (!isDashCFlag(token)) {
+      continue;
+    }
+    const innerCommand = tokens[i + 1];
+    if (!innerCommand) {
+      return null;
+    }
+    return trimMatchingQuotes(innerCommand);
+  }
+  return null;
+}
+function unwrapShellLauncherCommand(command) {
+  let current = command.trim();
+  for (let depth = 0;depth < 5; depth += 1) {
+    if (!current) {
+      break;
+    }
+    const tokens = tokenizeShell(current);
+    const inner = extractInnerShellCommand(tokens);
+    if (!inner || inner === current) {
+      break;
+    }
+    current = inner.trim();
+  }
+  return current;
+}
+function normalizeBashRulePayload(payload) {
+  const trimmed = payload.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const hasWildcardSuffix = trimmed.endsWith(":*");
+  const withoutWildcard = hasWildcardSuffix ? trimmed.slice(0, -2).trimEnd() : trimmed;
+  const unwrapped = unwrapShellLauncherCommand(withoutWildcard);
+  const normalized = normalizeGitCommandPrefix(unwrapped);
+  if (hasWildcardSuffix) {
+    return `${normalized}:*`;
+  }
+  return normalized;
+}
+function normalizeGitCommandPrefix(command) {
+  const trimmed = command.trim();
+  if (!trimmed.startsWith("git ")) {
+    return trimmed;
+  }
+  const tokens = tokenizeShell(trimmed);
+  if (tokens[0] !== "git") {
+    return trimmed;
+  }
+  const normalizedTokens = ["git"];
+  let index = 1;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === "-C") {
+      index += 2;
+      continue;
+    }
+    normalizedTokens.push(...tokens.slice(index));
+    return normalizedTokens.join(" ");
+  }
+  return normalizedTokens.join(" ");
+}
+var SHELL_EXECUTORS;
+var init_shell_command_normalization = __esm(() => {
+  SHELL_EXECUTORS = new Set(["bash", "sh", "zsh", "dash", "ksh"]);
+});
+
+// src/permissions/rule-normalization.ts
+function splitRule(rule) {
+  const match = rule.trim().match(/^([^(]+)(?:\(([\s\S]*)\))?$/);
+  if (!match?.[1]) {
+    return { tool: rule.trim(), payload: null };
+  }
+  return {
+    tool: match[1].trim(),
+    payload: match[2] !== undefined ? match[2] : null
+  };
+}
+function normalizePermissionRule(rule) {
+  const { tool, payload } = splitRule(rule);
+  const canonicalTool = canonicalToolName(tool);
+  if (payload === null) {
+    return canonicalTool;
+  }
+  if (isShellToolName(canonicalTool)) {
+    return `Bash(${normalizeBashRulePayload(payload)})`;
+  }
+  if (isFileToolName(canonicalTool)) {
+    return `${canonicalTool}(${canonicalizePathLike(payload)})`;
+  }
+  return `${canonicalTool}(${payload.trim()})`;
+}
+function permissionRulesEquivalent(left, right) {
+  return normalizePermissionRule(left) === normalizePermissionRule(right);
+}
+var init_rule_normalization = __esm(() => {
+  init_canonical();
+  init_shell_command_normalization();
+});
+
+// src/permissions/cli.ts
+var exports_cli = {};
+__export(exports_cli, {
+  cliPermissions: () => cliPermissions
+});
+
+class CliPermissions {
+  allowedTools = [];
+  disallowedTools = [];
+  memoryScope = [];
+  setAllowedTools(toolsString) {
+    this.allowedTools = this.parseToolList(toolsString);
+  }
+  setDisallowedTools(toolsString) {
+    this.disallowedTools = this.parseToolList(toolsString);
+  }
+  setMemoryScope(scopeString) {
+    this.memoryScope = parseScopeList(scopeString);
+  }
+  parseToolList(toolsString) {
+    if (!toolsString)
+      return [];
+    const tools = [];
+    let current = "";
+    let depth = 0;
+    for (let i = 0;i < toolsString.length; i++) {
+      const char = toolsString[i];
+      if (char === "(") {
+        depth++;
+        current += char;
+      } else if (char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        if (current.trim()) {
+          tools.push(this.normalizePattern(current.trim()));
+        }
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      tools.push(this.normalizePattern(current.trim()));
+    }
+    return tools;
+  }
+  normalizePattern(pattern) {
+    const trimmed = pattern.trim();
+    if (trimmed.includes("(")) {
+      return normalizePermissionRule(trimmed);
+    }
+    const canonicalTool = canonicalToolName(trimmed);
+    if (isShellToolName(canonicalTool)) {
+      return "Bash(:*)";
+    }
+    if (isFileToolName(canonicalTool)) {
+      return `${canonicalTool}(**)`;
+    }
+    return canonicalTool;
+  }
+  getAllowedTools() {
+    return [...this.allowedTools];
+  }
+  getDisallowedTools() {
+    return [...this.disallowedTools];
+  }
+  getMemoryScope() {
+    return [...this.memoryScope];
+  }
+  hasMemoryScope() {
+    return this.memoryScope.length > 0;
+  }
+  hasOverrides() {
+    return this.allowedTools.length > 0 || this.disallowedTools.length > 0 || this.memoryScope.length > 0;
+  }
+  clear() {
+    this.allowedTools = [];
+    this.disallowedTools = [];
+    this.memoryScope = [];
+  }
+}
+var cliPermissions;
+var init_cli = __esm(() => {
+  init_canonical();
+  init_memoryScope();
+  init_rule_normalization();
+  cliPermissions = new CliPermissions;
 });
 
 // src/permissions/shellAnalysis.ts
@@ -47533,8 +48115,315 @@ function parseShellAnalysis(command) {
   return parseShellAnalysisSegments(segments);
 }
 
-// src/permissions/readOnlyShell.ts
+// src/permissions/crossAgentGuard.ts
 import { homedir as homedir12 } from "node:os";
+function resolveAllowedAgents(options = {}) {
+  const env3 = options.env ?? process.env;
+  const self = deriveAgentId(env3, options.currentAgentId);
+  const envScope = parseScopeList(env3.LETTA_MEMORY_SCOPE);
+  const cliScope = options.cliMemoryScope ?? cliPermissions.getMemoryScope();
+  const ids = new Set;
+  if (self)
+    ids.add(self);
+  for (const id of envScope)
+    ids.add(id);
+  for (const id of cliScope)
+    ids.add(id);
+  return {
+    ids,
+    sources: {
+      self,
+      env: envScope,
+      cli: [...cliScope]
+    }
+  };
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getAgentsTreeRoot(homeDir) {
+  const normalizedHome = homeDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  return `${normalizedHome}/.letta/agents`;
+}
+function normalizePathForCompare(path3) {
+  const normalized = path3.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalized.length === 0 ? "/" : normalized;
+}
+function classifyAgentsTreePath(path3, homeDir) {
+  const root = getAgentsTreeRoot(homeDir);
+  const normalized = normalizePathForCompare(path3);
+  if (normalized === root) {
+    return { kind: "agents-root" };
+  }
+  if (normalized.startsWith(`${root}/`)) {
+    const rest = normalized.slice(root.length + 1);
+    const slash = rest.indexOf("/");
+    const id = slash === -1 ? rest : rest.slice(0, slash);
+    return { kind: "agent", id };
+  }
+  const prefix = normalized === "/" ? "/" : `${normalized}/`;
+  if (root.startsWith(prefix)) {
+    return { kind: "ancestor" };
+  }
+  return { kind: "outside" };
+}
+function extractApplyPatchPaths(input) {
+  const paths = [];
+  const fileDirectivePattern = /\*\*\* (?:Add|Update|Delete) File:\s*(.+)/g;
+  const moveDirectivePattern = /\*\*\* Move to:\s*(.+)/g;
+  for (const match of input.matchAll(fileDirectivePattern)) {
+    const matchPath = match[1]?.trim();
+    if (matchPath)
+      paths.push(matchPath);
+  }
+  for (const match of input.matchAll(moveDirectivePattern)) {
+    const matchPath = match[1]?.trim();
+    if (matchPath)
+      paths.push(matchPath);
+  }
+  return paths;
+}
+function extractFilePath(toolArgs) {
+  if (typeof toolArgs.file_path === "string" && toolArgs.file_path.length > 0) {
+    return toolArgs.file_path;
+  }
+  if (typeof toolArgs.path === "string" && toolArgs.path.length > 0) {
+    return toolArgs.path;
+  }
+  if (typeof toolArgs.notebook_path === "string" && toolArgs.notebook_path.length > 0) {
+    return toolArgs.notebook_path;
+  }
+  return null;
+}
+function extractMultiEditPaths(toolArgs) {
+  const single = extractFilePath(toolArgs);
+  return single ? [single] : [];
+}
+function extractShellCommand(toolArgs) {
+  const command = toolArgs.command;
+  if (typeof command === "string")
+    return command;
+  if (Array.isArray(command)) {
+    return command.map((c) => String(c)).join(" ");
+  }
+  return null;
+}
+function lookupShellVar(name, env3, homeDir) {
+  if (name === "HOME")
+    return homeDir;
+  const value = env3[name];
+  return typeof value === "string" ? value : undefined;
+}
+function expandShellToken(token, env3, homeDir) {
+  let result = token;
+  if (result.startsWith("~/")) {
+    result = `${homeDir}/${result.slice(2)}`;
+  } else if (result === "~") {
+    result = homeDir;
+  }
+  let unresolved = false;
+  result = result.replace(SHELL_VAR_REGEX, (_match, bracedName, bareName) => {
+    const name = bracedName || bareName;
+    if (!name) {
+      unresolved = true;
+      return "";
+    }
+    const value = lookupShellVar(name, env3, homeDir);
+    if (value === undefined) {
+      unresolved = true;
+      return "";
+    }
+    return value;
+  });
+  return unresolved ? null : result;
+}
+function collectShellAgentTargets(command, env3, homeDir) {
+  const targets = new Map;
+  const segments = splitShellSegments(command) ?? [command];
+  for (const segment of segments) {
+    for (const token of tokenizeShellWords(segment)) {
+      scanToken(token, env3, homeDir, targets);
+    }
+  }
+  return targets;
+}
+function stripAllOuterQuotes(value) {
+  let result = value;
+  while (result.length >= 2 && (result.startsWith('"') && result.endsWith('"') || result.startsWith("'") && result.endsWith("'"))) {
+    result = result.slice(1, -1);
+  }
+  return result;
+}
+function scanToken(rawToken, env3, homeDir, out) {
+  if (!rawToken)
+    return;
+  const assignmentMatch = rawToken.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+  const candidateValue = assignmentMatch ? assignmentMatch[2] ?? "" : rawToken;
+  const candidates = [rawToken, candidateValue].filter((v) => v.length > 0).map((v) => stripAllOuterQuotes(v));
+  for (const value of candidates) {
+    const expanded = expandShellToken(value, env3, homeDir);
+    if (expanded === null)
+      continue;
+    const normalized = normalizeScopedPath(expanded);
+    const classification = classifyAgentsTreePath(normalized, homeDir);
+    if (classification.kind === "agent") {
+      out.set(value, classification.id);
+    } else if (classification.kind === "agents-root") {
+      out.set(value, UNRESOLVED_AGENT_ID);
+    }
+  }
+}
+function scanRawCommandForUnresolvedAgentRefs(rawCommand, allowedAgentIds, env3, homeDir) {
+  const expanded = expandCommandVariables(rawCommand, env3, homeDir);
+  const escapedRoot = escapeRegex2(getAgentsTreeRoot(homeDir));
+  const pattern = new RegExp(`${escapedRoot}(?:/([^/\\s"'\`$(){}\\[\\]|&;,#]*))?`, "g");
+  const unresolved = [];
+  for (const match of expanded.matchAll(pattern)) {
+    const candidate = (match[1] ?? "").trim();
+    if (candidate.length === 0) {
+      unresolved.push(UNRESOLVED_AGENT_ID);
+      continue;
+    }
+    if (!allowedAgentIds.has(candidate)) {
+      unresolved.push(candidate);
+    }
+  }
+  return unresolved;
+}
+function expandCommandVariables(command, env3, homeDir) {
+  let result = command.replace(/(^|[\s="'`:])~\//g, (_match, prefix) => `${prefix}${homeDir}/`);
+  result = result.replace(SHELL_VAR_REGEX, (match, bracedName, bareName) => {
+    const name = bracedName || bareName;
+    if (!name)
+      return match;
+    return lookupShellVar(name, env3, homeDir) ?? match;
+  });
+  return result;
+}
+function isRecursivePathTool(toolName) {
+  if (RECURSIVE_PATH_TOOLS.has(toolName))
+    return true;
+  const canonical = canonicalToolName(toolName);
+  return RECURSIVE_PATH_TOOLS.has(canonical);
+}
+function extractTargetAgentPaths(toolName, toolArgs, workingDirectory, env3 = process.env, homeDir = homedir12()) {
+  const agentIds = new Set;
+  let anyAgentScoped = false;
+  const recursive = isRecursivePathTool(toolName);
+  const addFromPath = (rawPath) => {
+    if (!rawPath || typeof rawPath !== "string")
+      return;
+    const resolvedPath = resolveScopedTargetPath(rawPath, workingDirectory);
+    if (!resolvedPath)
+      return;
+    const classification = classifyAgentsTreePath(resolvedPath, homeDir);
+    switch (classification.kind) {
+      case "outside":
+        return;
+      case "agents-root":
+        anyAgentScoped = true;
+        agentIds.add(UNRESOLVED_AGENT_ID);
+        return;
+      case "ancestor":
+        if (recursive) {
+          anyAgentScoped = true;
+          agentIds.add(UNRESOLVED_AGENT_ID);
+        }
+        return;
+      case "agent":
+        anyAgentScoped = true;
+        agentIds.add(classification.id);
+        return;
+    }
+  };
+  const canonical = canonicalToolName(toolName);
+  if (toolName === "ApplyPatch" || toolName === "apply_patch" || toolName === "memory_apply_patch") {
+    if (typeof toolArgs.input === "string") {
+      for (const p of extractApplyPatchPaths(toolArgs.input)) {
+        addFromPath(p);
+      }
+    }
+    return { agentIds, anyAgentScoped };
+  }
+  if (isShellToolName(toolName) || canonical === "Bash") {
+    const command = extractShellCommand(toolArgs);
+    if (command) {
+      const hits = collectShellAgentTargets(command, env3, homeDir);
+      for (const id of hits.values()) {
+        anyAgentScoped = true;
+        agentIds.add(id);
+      }
+    }
+    return { agentIds, anyAgentScoped };
+  }
+  if (toolName === "MultiEdit") {
+    for (const p of extractMultiEditPaths(toolArgs)) {
+      addFromPath(p);
+    }
+    return { agentIds, anyAgentScoped };
+  }
+  addFromPath(extractFilePath(toolArgs));
+  if (recursive && typeof toolArgs.pattern === "string") {
+    addFromPath(toolArgs.pattern);
+  }
+  return { agentIds, anyAgentScoped };
+}
+function buildReason(offending, allowed) {
+  const offendingDesc = offending.join(", ");
+  const allowedList = [...allowed.ids];
+  const allowedDesc = allowedList.length > 0 ? allowedList.join(", ") : "(none)";
+  return `Permission denied by cross-agent memory guard (${offendingDesc}). ` + `Allowed: ${allowedDesc}. ` + `Set LETTA_MEMORY_SCOPE or pass --memory-scope to opt in.`;
+}
+function evaluateCrossAgentGuard(toolName, toolArgs, workingDirectory, options = {}) {
+  const env3 = options.env ?? process.env;
+  const homeDir = env3.HOME ?? homedir12();
+  const targets = extractTargetAgentPaths(toolName, toolArgs, workingDirectory, env3, homeDir);
+  const allowed = resolveAllowedAgents(options);
+  const offending = new Set;
+  for (const id of targets.agentIds) {
+    if (!allowed.ids.has(id)) {
+      offending.add(id);
+    }
+  }
+  const canonical = canonicalToolName(toolName);
+  if (isShellToolName(toolName) || canonical === "Bash") {
+    const command = extractShellCommand(toolArgs);
+    if (command) {
+      const unresolved = scanRawCommandForUnresolvedAgentRefs(command, allowed.ids, env3, homeDir);
+      for (const id of unresolved) {
+        offending.add(id);
+      }
+    }
+  }
+  if (offending.size === 0) {
+    return null;
+  }
+  const offendingList = [...offending];
+  return {
+    matchedRule: "cross-agent guard",
+    reason: buildReason(offendingList, allowed),
+    offendingAgentIds: offendingList
+  };
+}
+var UNRESOLVED_AGENT_ID = "<unresolved>", SHELL_VAR_REGEX, RECURSIVE_PATH_TOOLS;
+var init_crossAgentGuard = __esm(() => {
+  init_canonical();
+  init_cli();
+  init_memoryScope();
+  SHELL_VAR_REGEX = /\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g;
+  RECURSIVE_PATH_TOOLS = new Set([
+    "Grep",
+    "Glob",
+    "ListDir",
+    "LS",
+    "list_dir",
+    "grep",
+    "glob"
+  ]);
+});
+
+// src/permissions/readOnlyShell.ts
+import { homedir as homedir13 } from "node:os";
 import { resolve as resolve5 } from "node:path";
 function isSafeConditionalTest(condition, options) {
   let tokens = tokenizeShellWords(condition);
@@ -47997,7 +48886,7 @@ function parseGitInvocation(tokens, options) {
   return { subcommand: null, subcommandIndex: -1, isSafePath: true };
 }
 function getAllowedMemoryPrefixes(agentId) {
-  const home = homedir12();
+  const home = homedir13();
   const prefixes = [
     normalizeSeparators(resolve5(home, ".letta", "agents", agentId, "memory")),
     normalizeSeparators(resolve5(home, ".letta", "agents", agentId, "memory-worktrees"))
@@ -48023,7 +48912,7 @@ function expandScopedVariables(value, env3, shellVars) {
       return "";
     }
     if (name === "HOME") {
-      return homedir12();
+      return homedir13();
     }
     const scopedValue = shellVars[name];
     if (typeof scopedValue === "string") {
@@ -48481,202 +49370,12 @@ var init_readOnlyShell = __esm(() => {
   SAFE_FILE_TEST_FLAGS = new Set(["-e", "-f", "-d", "-s", "-L"]);
 });
 
-// src/permissions/shell-command-normalization.ts
-function trimMatchingQuotes(value) {
-  const trimmed = value.trim();
-  if (trimmed.length < 2) {
-    return trimmed;
-  }
-  const first = trimmed[0];
-  const last = trimmed[trimmed.length - 1];
-  if ((first === '"' || first === "'") && last === first) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
-function normalizeExecutableToken(token) {
-  const normalized = trimMatchingQuotes(token).replace(/\\/g, "/");
-  const parts = normalized.split("/").filter(Boolean);
-  const executable = parts[parts.length - 1] ?? normalized;
-  return executable.toLowerCase();
-}
-function tokenizeShell(input) {
-  const tokens = [];
-  let current = "";
-  let quote = null;
-  let escaping = false;
-  const flush = () => {
-    if (current.length > 0) {
-      tokens.push(current);
-      current = "";
-    }
-  };
-  for (let i = 0;i < input.length; i += 1) {
-    const ch = input[i];
-    if (ch === undefined) {
-      continue;
-    }
-    if (escaping) {
-      current += ch;
-      escaping = false;
-      continue;
-    }
-    if (ch === "\\" && quote !== "single") {
-      escaping = true;
-      continue;
-    }
-    if (quote === "single") {
-      if (ch === "'") {
-        quote = null;
-      } else {
-        current += ch;
-      }
-      continue;
-    }
-    if (quote === "double") {
-      if (ch === '"') {
-        quote = null;
-      } else {
-        current += ch;
-      }
-      continue;
-    }
-    if (ch === "'") {
-      quote = "single";
-      continue;
-    }
-    if (ch === '"') {
-      quote = "double";
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      flush();
-      continue;
-    }
-    current += ch;
-  }
-  if (escaping) {
-    current += "\\";
-  }
-  flush();
-  return tokens;
-}
-function isDashCFlag(token) {
-  return token === "-c" || /^-[a-zA-Z]*c[a-zA-Z]*$/.test(token);
-}
-function extractInnerShellCommand(tokens) {
-  if (tokens.length === 0) {
-    return null;
-  }
-  let index = 0;
-  if (normalizeExecutableToken(tokens[0] ?? "") === "env") {
-    index += 1;
-    while (index < tokens.length) {
-      const token = tokens[index] ?? "";
-      if (!token) {
-        index += 1;
-        continue;
-      }
-      if (/^-[A-Za-z]+$/.test(token)) {
-        index += 1;
-        continue;
-      }
-      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token)) {
-        index += 1;
-        continue;
-      }
-      break;
-    }
-  }
-  const executableToken = tokens[index];
-  if (!executableToken) {
-    return null;
-  }
-  if (!SHELL_EXECUTORS.has(normalizeExecutableToken(executableToken))) {
-    return null;
-  }
-  for (let i = index + 1;i < tokens.length; i += 1) {
-    const token = tokens[i];
-    if (!token) {
-      continue;
-    }
-    if (!isDashCFlag(token)) {
-      continue;
-    }
-    const innerCommand = tokens[i + 1];
-    if (!innerCommand) {
-      return null;
-    }
-    return trimMatchingQuotes(innerCommand);
-  }
-  return null;
-}
-function unwrapShellLauncherCommand(command) {
-  let current = command.trim();
-  for (let depth = 0;depth < 5; depth += 1) {
-    if (!current) {
-      break;
-    }
-    const tokens = tokenizeShell(current);
-    const inner = extractInnerShellCommand(tokens);
-    if (!inner || inner === current) {
-      break;
-    }
-    current = inner.trim();
-  }
-  return current;
-}
-function normalizeBashRulePayload(payload) {
-  const trimmed = payload.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const hasWildcardSuffix = trimmed.endsWith(":*");
-  const withoutWildcard = hasWildcardSuffix ? trimmed.slice(0, -2).trimEnd() : trimmed;
-  const unwrapped = unwrapShellLauncherCommand(withoutWildcard);
-  const normalized = normalizeGitCommandPrefix(unwrapped);
-  if (hasWildcardSuffix) {
-    return `${normalized}:*`;
-  }
-  return normalized;
-}
-function normalizeGitCommandPrefix(command) {
-  const trimmed = command.trim();
-  if (!trimmed.startsWith("git ")) {
-    return trimmed;
-  }
-  const tokens = tokenizeShell(trimmed);
-  if (tokens[0] !== "git") {
-    return trimmed;
-  }
-  const normalizedTokens = ["git"];
-  let index = 1;
-  while (index < tokens.length) {
-    const token = tokens[index];
-    if (!token) {
-      index += 1;
-      continue;
-    }
-    if (token === "-C") {
-      index += 2;
-      continue;
-    }
-    normalizedTokens.push(...tokens.slice(index));
-    return normalizedTokens.join(" ");
-  }
-  return normalizedTokens.join(" ");
-}
-var SHELL_EXECUTORS;
-var init_shell_command_normalization = __esm(() => {
-  SHELL_EXECUTORS = new Set(["bash", "sh", "zsh", "dash", "ksh"]);
-});
-
 // src/permissions/mode.ts
 var exports_mode = {};
 __export(exports_mode, {
   permissionMode: () => permissionMode
 });
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 import { isAbsolute as isAbsolute3, join as join15, relative as relative3 } from "node:path";
 function everyResolvedTargetIsWithinRoots(candidatePaths, roots, workingDirectory) {
   return candidatePaths.length > 0 && candidatePaths.every((path3) => {
@@ -48720,22 +49419,6 @@ function isPathInPlansDir(path3, plansDir) {
   const rel = relative3(plansDir, path3);
   return rel !== "" && !rel.startsWith("..") && !isAbsolute3(rel);
 }
-function extractApplyPatchPaths(input) {
-  const paths = [];
-  const fileDirectivePattern = /\*\*\* (?:Add|Update|Delete) File:\s*(.+)/g;
-  const moveDirectivePattern = /\*\*\* Move to:\s*(.+)/g;
-  for (const match of input.matchAll(fileDirectivePattern)) {
-    const matchPath = match[1]?.trim();
-    if (matchPath)
-      paths.push(matchPath);
-  }
-  for (const match of input.matchAll(moveDirectivePattern)) {
-    const matchPath = match[1]?.trim();
-    if (matchPath)
-      paths.push(matchPath);
-  }
-  return paths;
-}
 function stripMatchingQuotes(value) {
   const trimmed = value.trim();
   if (trimmed.length < 2) {
@@ -48906,7 +49589,7 @@ class PermissionModeManager {
           return "allow";
         }
         if (writeTools.includes(toolName)) {
-          const plansDir = join15(homedir13(), ".letta", "plans");
+          const plansDir = join15(homedir14(), ".letta", "plans");
           const targetPath = toolArgs?.file_path || toolArgs?.path;
           let candidatePaths = [];
           if ((toolName === "ApplyPatch" || toolName === "apply_patch" || toolName === "memory_apply_patch") && toolArgs?.input) {
@@ -48957,7 +49640,7 @@ class PermissionModeManager {
           }
           const planWritePath = extractPlanFileWritePathFromShellCommand(command);
           if (planWritePath) {
-            const plansDir = join15(homedir13(), ".letta", "plans");
+            const plansDir = join15(homedir14(), ".letta", "plans");
             const resolvedPath = resolvePlanTargetPath(planWritePath, workingDirectory);
             if (resolvedPath && isPathInPlansDir(resolvedPath, plansDir)) {
               return "allow";
@@ -49068,6 +49751,7 @@ class PermissionModeManager {
 }
 var MODE_KEY, PLAN_FILE_KEY, MODE_BEFORE_PLAN_KEY, permissionMode;
 var init_mode = __esm(() => {
+  init_crossAgentGuard();
   init_memoryScope();
   init_readOnlyShell();
   init_shell_command_normalization();
@@ -52202,7 +52886,7 @@ async function edit(args) {
 var init_Edit2 = () => {};
 
 // src/cli/helpers/planName.ts
-import { homedir as homedir15 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 import { join as join18 } from "node:path";
 function randomElement(arr) {
   return arr[Math.floor(Math.random() * arr.length)];
@@ -52215,7 +52899,7 @@ function generatePlanName() {
 }
 function generatePlanFilePath() {
   const name = generatePlanName();
-  return join18(homedir15(), ".letta", "plans", `${name}.md`);
+  return join18(homedir16(), ".letta", "plans", `${name}.md`);
 }
 var adjectives, nouns;
 var init_planName = __esm(() => {
@@ -53363,7 +54047,6 @@ var activeRuntime = null;
 var init_runtime3 = () => {};
 
 // src/tools/impl/Memory.ts
-import { execFile as execFileCb3 } from "node:child_process";
 import { existsSync as existsSync19 } from "node:fs";
 import {
   mkdir as mkdir5,
@@ -53374,9 +54057,8 @@ import {
   unlink,
   writeFile as writeFile5
 } from "node:fs/promises";
-import { homedir as homedir16 } from "node:os";
+import { homedir as homedir17 } from "node:os";
 import { dirname as dirname8, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve13 } from "node:path";
-import { promisify as promisify6 } from "node:util";
 async function getAgentIdentity() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
   const contextAgentId = (() => {
@@ -53401,6 +54083,10 @@ async function getAgentIdentity() {
   }
   return { agentId, agentName };
 }
+function normalizeComparableContent2(content) {
+  return content.replace(/\r\n/g, `
+`).trim();
+}
 async function memory(args) {
   validateRequiredParams(args, ["command", "reason"], "memory");
   const reason = args.reason.trim();
@@ -53409,7 +54095,46 @@ async function memory(args) {
   }
   const memoryDir = resolveMemoryDir();
   ensureMemoryRepo(memoryDir);
-  let affectedPaths = [];
+  await assertMemoryRepoReadyForWrite(memoryDir);
+  const affectedPaths = await applyMemoryCommand(memoryDir, args);
+  if (affectedPaths.length === 0) {
+    return {
+      message: `Memory ${args.command} completed with no changed paths.`
+    };
+  }
+  const { agentId, agentName } = await getAgentIdentity();
+  const commitResult = await commitAndSyncMemoryWrite({
+    memoryDir,
+    pathspecs: affectedPaths,
+    reason,
+    author: {
+      agentId,
+      authorName: agentName.trim() || agentId,
+      authorEmail: `${agentId}@letta.com`
+    },
+    replay: async () => applyMemoryCommand(memoryDir, args, { replaying: true })
+  });
+  if (!commitResult.committed) {
+    return {
+      message: `Memory ${args.command} made no effective changes; skipped commit and push.`
+    };
+  }
+  emitMemoryUpdated(affectedPaths);
+  if (commitResult.replayed && commitResult.replayNoop) {
+    return {
+      message: `Memory ${args.command} matched newer remote memory; skipped an extra commit.`
+    };
+  }
+  if (commitResult.replayed) {
+    return {
+      message: `Memory ${args.command} reapplied on top of newer remote memory and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
+    };
+  }
+  return {
+    message: `Memory ${args.command} applied and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
+  };
+}
+async function applyMemoryCommand(memoryDir, args, options) {
   const command = args.command;
   if (command === "create") {
     const pathArg = requireString(args.file_path, "file_path", "create");
@@ -53417,17 +54142,25 @@ async function memory(args) {
     const label = normalizeMemoryLabel(memoryDir, pathArg, "file_path");
     const filePath = resolveMemoryFilePath(memoryDir, label);
     const relPath = toRepoRelative(memoryDir, filePath);
-    if (existsSync19(filePath)) {
-      throw new Error(`memory create: block already exists at ${pathArg}`);
-    }
     const body = args.file_text ?? "";
     const rendered = renderMemoryFile({
       description
     }, body);
+    if (existsSync19(filePath)) {
+      if (!options?.replaying) {
+        throw new Error(`memory create: block already exists at ${pathArg}`);
+      }
+      const existingContent = await readFile5(filePath, "utf8");
+      if (normalizeComparableContent2(existingContent) === normalizeComparableContent2(rendered)) {
+        return [relPath];
+      }
+      throw new Error(`memory create: block already exists at ${pathArg}`);
+    }
     await mkdir5(dirname8(filePath), { recursive: true });
     await writeFile5(filePath, rendered, "utf8");
-    affectedPaths = [relPath];
-  } else if (command === "str_replace") {
+    return [relPath];
+  }
+  if (command === "str_replace") {
     const pathArg = requireString(args.file_path, "file_path", "str_replace");
     const oldString = requireString(args.old_string, "old_string", "str_replace");
     const newString = requireString(args.new_string, "new_string", "str_replace");
@@ -53442,8 +54175,9 @@ async function memory(args) {
     const nextBody = `${file.body.slice(0, idx)}${newString}${file.body.slice(idx + oldString.length)}`;
     const rendered = renderMemoryFile(file.frontmatter, nextBody);
     await writeFile5(filePath, rendered, "utf8");
-    affectedPaths = [relPath];
-  } else if (command === "insert") {
+    return [relPath];
+  }
+  if (command === "insert") {
     const pathArg = requireString(args.file_path, "file_path", "insert");
     const insertText = requireString(args.insert_text, "insert_text", "insert");
     if (typeof args.insert_line !== "number" || Number.isNaN(args.insert_line)) {
@@ -53464,23 +54198,27 @@ async function memory(args) {
 `);
     const rendered = renderMemoryFile(file.frontmatter, nextBody);
     await writeFile5(filePath, rendered, "utf8");
-    affectedPaths = [relPath];
-  } else if (command === "delete") {
+    return [relPath];
+  }
+  if (command === "delete") {
+    if (options?.replaying) {
+      throw new Error("memory delete could not be replayed safely after remote changes");
+    }
     const pathArg = requireString(args.file_path, "file_path", "delete");
     const label = normalizeMemoryLabel(memoryDir, pathArg, "file_path");
     const targetPath = resolveMemoryPath(memoryDir, label);
     if (existsSync19(targetPath) && (await stat2(targetPath)).isDirectory()) {
-      const relPath = toRepoRelative(memoryDir, targetPath);
+      const relPath2 = toRepoRelative(memoryDir, targetPath);
       await rm(targetPath, { recursive: true, force: false });
-      affectedPaths = [relPath];
-    } else {
-      const filePath = resolveMemoryFilePath(memoryDir, label);
-      const relPath = toRepoRelative(memoryDir, filePath);
-      await loadEditableMemoryFile(filePath, pathArg);
-      await unlink(filePath);
-      affectedPaths = [relPath];
+      return [relPath2];
     }
-  } else if (command === "rename") {
+    const filePath = resolveMemoryFilePath(memoryDir, label);
+    const relPath = toRepoRelative(memoryDir, filePath);
+    await loadEditableMemoryFile(filePath, pathArg);
+    await unlink(filePath);
+    return [relPath];
+  }
+  if (command === "rename") {
     const oldPathArg = requireString(args.old_path, "old_path", "rename");
     const newPathArg = requireString(args.new_path, "new_path", "rename");
     const oldLabel = normalizeMemoryLabel(memoryDir, oldPathArg, "old_path");
@@ -53495,8 +54233,9 @@ async function memory(args) {
     await loadEditableMemoryFile(oldFilePath, oldPathArg);
     await mkdir5(dirname8(newFilePath), { recursive: true });
     await rename(oldFilePath, newFilePath);
-    affectedPaths = [oldRelPath, newRelPath];
-  } else if (command === "update_description") {
+    return [oldRelPath, newRelPath];
+  }
+  if (command === "update_description") {
     const pathArg = requireString(args.file_path, "file_path", "update_description");
     const newDescription = requireString(args.description, "description", "update_description");
     const label = normalizeMemoryLabel(memoryDir, pathArg, "file_path");
@@ -53508,24 +54247,9 @@ async function memory(args) {
       description: newDescription
     }, file.body);
     await writeFile5(filePath, rendered, "utf8");
-    affectedPaths = [relPath];
-  } else {
-    throw new Error(`Unsupported memory command: ${command}`);
-  }
-  affectedPaths = Array.from(new Set(affectedPaths)).filter((p) => p.length > 0);
-  if (affectedPaths.length === 0) {
-    return { message: `Memory ${command} completed with no changed paths.` };
+    return [relPath];
   }
-  const commitResult = await commitAndPush(memoryDir, affectedPaths, reason);
-  if (!commitResult.committed) {
-    return {
-      message: `Memory ${command} made no effective changes; skipped commit and push.`
-    };
-  }
-  emitMemoryUpdated(affectedPaths);
-  return {
-    message: `Memory ${command} applied and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
-  };
+  throw new Error(`Unsupported memory command: ${command}`);
 }
 function resolveMemoryDir() {
   const direct = process.env.MEMORY_DIR || process.env.LETTA_MEMORY_DIR;
@@ -53541,7 +54265,7 @@ function resolveMemoryDir() {
   })();
   const agentId = contextAgentId || (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
   if (agentId && agentId.trim().length > 0) {
-    return resolve13(homedir16(), ".letta", "agents", agentId, "memory");
+    return resolve13(homedir17(), ".letta", "agents", agentId, "memory");
   }
   throw new Error("memory: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
@@ -53691,78 +54415,6 @@ ${body}`;
 function sanitizeFrontmatterValue(value) {
   return value.replace(/\r?\n/g, " ").trim();
 }
-async function runGit4(memoryDir, args) {
-  try {
-    const result = await execFile6("git", args, {
-      cwd: memoryDir,
-      maxBuffer: 10 * 1024 * 1024,
-      env: {
-        ...process.env,
-        PAGER: "cat",
-        GIT_PAGER: "cat"
-      }
-    });
-    return {
-      stdout: result.stdout?.toString() ?? "",
-      stderr: result.stderr?.toString() ?? ""
-    };
-  } catch (error) {
-    const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr ?? "") : "";
-    const stdout = typeof error === "object" && error !== null && "stdout" in error ? String(error.stdout ?? "") : "";
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`git ${args.join(" ")} failed: ${stderr || stdout || message}`.trim());
-  }
-}
-async function commitAndPush(memoryDir, pathspecs, reason) {
-  await runGit4(memoryDir, ["add", "-A", "--", ...pathspecs]);
-  const status = await runGit4(memoryDir, [
-    "status",
-    "--porcelain",
-    "--",
-    ...pathspecs
-  ]);
-  if (!status.stdout.trim()) {
-    return { committed: false };
-  }
-  const { agentId, agentName } = await getAgentIdentity();
-  const authorName = agentName.trim() || agentId;
-  const authorEmail = `${agentId}@letta.com`;
-  try {
-    await runGit4(memoryDir, [
-      "-c",
-      `user.name=${authorName}`,
-      "-c",
-      `user.email=${authorEmail}`,
-      "commit",
-      "-m",
-      reason
-    ]);
-  } catch (error) {
-    await unstagePaths(memoryDir, pathspecs);
-    throw error;
-  }
-  const head = await runGit4(memoryDir, ["rev-parse", "HEAD"]);
-  const sha = head.stdout.trim();
-  await maybeUpdateMemoryRemoteOrigin(memoryDir, agentId);
-  try {
-    await runGit4(memoryDir, ["push"]);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Memory changes were committed (${sha.slice(0, 7)}) but push failed: ${message}`);
-  }
-  return {
-    committed: true,
-    sha
-  };
-}
-async function unstagePaths(memoryDir, pathspecs) {
-  if (pathspecs.length === 0) {
-    return;
-  }
-  try {
-    await runGit4(memoryDir, ["reset", "HEAD", "--", ...pathspecs]);
-  } catch {}
-}
 function requireString(value, field, command) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new Error(`memory ${command}: '${field}' must be a non-empty string`);
@@ -53784,16 +54436,13 @@ function emitMemoryUpdated(affectedPaths) {
     }));
   } catch {}
 }
-var execFile6;
 var init_Memory2 = __esm(() => {
   init_client2();
   init_context();
   init_memoryGit();
-  execFile6 = promisify6(execFileCb3);
 });
 
 // src/tools/impl/MemoryApplyPatch.ts
-import { execFile as execFileCb4 } from "node:child_process";
 import { existsSync as existsSync20 } from "node:fs";
 import {
   access,
@@ -53804,9 +54453,8 @@ import {
   unlink as unlink2,
   writeFile as writeFile6
 } from "node:fs/promises";
-import { homedir as homedir17 } from "node:os";
+import { homedir as homedir18 } from "node:os";
 import { dirname as dirname9, isAbsolute as isAbsolute10, relative as relative6, resolve as resolve14 } from "node:path";
-import { promisify as promisify7 } from "node:util";
 async function getAgentIdentity2() {
   const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
   const contextAgentId = (() => {
@@ -53843,6 +54491,43 @@ async function memory_apply_patch(args) {
   }
   const memoryDir = resolveMemoryDir2();
   ensureMemoryRepo2(memoryDir);
+  await assertMemoryRepoReadyForWrite(memoryDir);
+  const pathspecs = await applyMemoryPatch(memoryDir, input);
+  if (pathspecs.length === 0) {
+    return { message: "memory_apply_patch completed with no changed paths." };
+  }
+  const { agentId, agentName } = await getAgentIdentity2();
+  const commitResult = await commitAndSyncMemoryWrite({
+    memoryDir,
+    pathspecs,
+    reason,
+    author: {
+      agentId,
+      authorName: agentName.trim() || agentId,
+      authorEmail: `${agentId}@letta.com`
+    },
+    replay: async () => applyMemoryPatch(memoryDir, input)
+  });
+  if (!commitResult.committed) {
+    return {
+      message: "memory_apply_patch made no effective changes; skipped commit and push."
+    };
+  }
+  if (commitResult.replayed && commitResult.replayNoop) {
+    return {
+      message: "memory_apply_patch matched newer remote memory; skipped an extra commit."
+    };
+  }
+  if (commitResult.replayed) {
+    return {
+      message: `memory_apply_patch reapplied on top of newer remote memory and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
+    };
+  }
+  return {
+    message: `memory_apply_patch applied and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
+  };
+}
+async function applyMemoryPatch(memoryDir, input) {
   const ops = parsePatchOperations(memoryDir, input);
   if (ops.length === 0) {
     throw new Error("memory_apply_patch: no file operations found in patch");
@@ -53934,18 +54619,7 @@ async function memory_apply_patch(args) {
     }
   }
   const pathspecs = Array.from(affectedPaths).filter((p) => p.length > 0);
-  if (pathspecs.length === 0) {
-    return { message: "memory_apply_patch completed with no changed paths." };
-  }
-  const commitResult = await commitAndPush2(memoryDir, pathspecs, reason);
-  if (!commitResult.committed) {
-    return {
-      message: "memory_apply_patch made no effective changes; skipped commit and push."
-    };
-  }
-  return {
-    message: `memory_apply_patch applied and pushed (${commitResult.sha?.slice(0, 7) ?? "unknown"}).`
-  };
+  return pathspecs;
 }
 function parsePatchOperations(memoryDir, input) {
   const lines = input.split(/\r?\n/);
@@ -54092,7 +54766,7 @@ function resolveMemoryDir2() {
   })();
   const agentId = contextAgentId || (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
   if (agentId && agentId.trim().length > 0) {
-    return resolve14(homedir17(), ".letta", "agents", agentId, "memory");
+    return resolve14(homedir18(), ".letta", "agents", agentId, "memory");
   }
   throw new Error("memory_apply_patch: unable to resolve memory directory. Ensure MEMORY_DIR (or AGENT_ID) is available.");
 }
@@ -54241,65 +54915,6 @@ ${body}`;
 function sanitizeFrontmatterValue2(value) {
   return value.replace(/\r?\n/g, " ").trim();
 }
-async function runGit5(memoryDir, args) {
-  try {
-    const result = await execFile7("git", args, {
-      cwd: memoryDir,
-      maxBuffer: 10 * 1024 * 1024,
-      env: {
-        ...process.env,
-        PAGER: "cat",
-        GIT_PAGER: "cat"
-      }
-    });
-    return {
-      stdout: result.stdout?.toString() ?? "",
-      stderr: result.stderr?.toString() ?? ""
-    };
-  } catch (error) {
-    const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr ?? "") : "";
-    const stdout = typeof error === "object" && error !== null && "stdout" in error ? String(error.stdout ?? "") : "";
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`git ${args.join(" ")} failed: ${stderr || stdout || message}`.trim());
-  }
-}
-async function commitAndPush2(memoryDir, pathspecs, reason) {
-  await runGit5(memoryDir, ["add", "-A", "--", ...pathspecs]);
-  const status = await runGit5(memoryDir, [
-    "status",
-    "--porcelain",
-    "--",
-    ...pathspecs
-  ]);
-  if (!status.stdout.trim()) {
-    return { committed: false };
-  }
-  const { agentId, agentName } = await getAgentIdentity2();
-  const authorName = agentName.trim() || agentId;
-  const authorEmail = `${agentId}@letta.com`;
-  await runGit5(memoryDir, [
-    "-c",
-    `user.name=${authorName}`,
-    "-c",
-    `user.email=${authorEmail}`,
-    "commit",
-    "-m",
-    reason
-  ]);
-  const head = await runGit5(memoryDir, ["rev-parse", "HEAD"]);
-  const sha = head.stdout.trim();
-  await maybeUpdateMemoryRemoteOrigin(memoryDir, agentId);
-  try {
-    await runGit5(memoryDir, ["push"]);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Memory changes were committed (${sha.slice(0, 7)}) but push failed: ${message}`);
-  }
-  return {
-    committed: true,
-    sha
-  };
-}
 async function isMissing(filePath) {
   try {
     await access(filePath);
@@ -54360,12 +54975,10 @@ function buildOldNewChunks(lines) {
     newChunk: newParts.join("")
   };
 }
-var execFile7;
 var init_MemoryApplyPatch2 = __esm(() => {
   init_client2();
   init_context();
   init_memoryGit();
-  execFile7 = promisify7(execFileCb4);
 });
 
 // src/tools/impl/MessageChannel.ts
@@ -68955,211 +69568,6 @@ var init_subagentState = __esm(() => {
   streamEventListeners = new Set;
 });
 
-// src/permissions/canonical.ts
-function canonicalToolName(toolName) {
-  if (SHELL_TOOL_NAMES.has(toolName))
-    return "Bash";
-  if (READ_TOOL_NAMES.has(toolName))
-    return "Read";
-  if (WRITE_TOOL_NAMES.has(toolName))
-    return "Write";
-  if (EDIT_TOOL_NAMES.has(toolName))
-    return "Edit";
-  if (GLOB_TOOL_NAMES.has(toolName))
-    return "Glob";
-  if (GREP_TOOL_NAMES.has(toolName))
-    return "Grep";
-  if (LIST_TOOL_NAMES.has(toolName))
-    return "ListDir";
-  if (TASK_TOOL_NAMES.has(toolName))
-    return "Task";
-  return toolName;
-}
-function isShellToolName(toolName) {
-  return canonicalToolName(toolName) === "Bash";
-}
-function isFileToolName(toolName) {
-  return FILE_TOOL_FAMILIES.has(canonicalToolName(toolName));
-}
-function canonicalizePathLike(value) {
-  let normalized = value.replace(/\\/g, "/").trim();
-  if (/^\/+[a-zA-Z]:\//.test(normalized)) {
-    normalized = normalized.replace(/^\/+/, "");
-  }
-  if (/^[a-zA-Z]:\//.test(normalized)) {
-    normalized = `${normalized[0]?.toUpperCase() ?? ""}${normalized.slice(1)}`;
-  }
-  return normalized;
-}
-var SHELL_TOOL_NAMES, READ_TOOL_NAMES, WRITE_TOOL_NAMES, EDIT_TOOL_NAMES, GLOB_TOOL_NAMES, GREP_TOOL_NAMES, LIST_TOOL_NAMES, TASK_TOOL_NAMES, FILE_TOOL_FAMILIES;
-var init_canonical = __esm(() => {
-  SHELL_TOOL_NAMES = new Set([
-    "Bash",
-    "shell",
-    "Shell",
-    "shell_command",
-    "ShellCommand",
-    "run_shell_command",
-    "RunShellCommand"
-  ]);
-  READ_TOOL_NAMES = new Set([
-    "Read",
-    "read_file",
-    "ReadFile",
-    "read_file_gemini",
-    "ReadFileGemini"
-  ]);
-  WRITE_TOOL_NAMES = new Set([
-    "Write",
-    "write_file",
-    "WriteFile",
-    "write_file_gemini",
-    "WriteFileGemini"
-  ]);
-  EDIT_TOOL_NAMES = new Set([
-    "Edit",
-    "MultiEdit",
-    "NotebookEdit",
-    "replace",
-    "Replace"
-  ]);
-  GLOB_TOOL_NAMES = new Set(["Glob", "glob_gemini", "GlobGemini"]);
-  GREP_TOOL_NAMES = new Set([
-    "Grep",
-    "grep_files",
-    "GrepFiles",
-    "search_file_content",
-    "SearchFileContent"
-  ]);
-  LIST_TOOL_NAMES = new Set([
-    "list_dir",
-    "ListDir",
-    "list_directory",
-    "ListDirectory",
-    "LS"
-  ]);
-  TASK_TOOL_NAMES = new Set(["Task", "task"]);
-  FILE_TOOL_FAMILIES = new Set([
-    "Read",
-    "Write",
-    "Edit",
-    "Glob",
-    "Grep",
-    "ListDir"
-  ]);
-});
-
-// src/permissions/rule-normalization.ts
-function splitRule(rule) {
-  const match2 = rule.trim().match(/^([^(]+)(?:\(([\s\S]*)\))?$/);
-  if (!match2?.[1]) {
-    return { tool: rule.trim(), payload: null };
-  }
-  return {
-    tool: match2[1].trim(),
-    payload: match2[2] !== undefined ? match2[2] : null
-  };
-}
-function normalizePermissionRule(rule) {
-  const { tool, payload } = splitRule(rule);
-  const canonicalTool = canonicalToolName(tool);
-  if (payload === null) {
-    return canonicalTool;
-  }
-  if (isShellToolName(canonicalTool)) {
-    return `Bash(${normalizeBashRulePayload(payload)})`;
-  }
-  if (isFileToolName(canonicalTool)) {
-    return `${canonicalTool}(${canonicalizePathLike(payload)})`;
-  }
-  return `${canonicalTool}(${payload.trim()})`;
-}
-function permissionRulesEquivalent(left, right) {
-  return normalizePermissionRule(left) === normalizePermissionRule(right);
-}
-var init_rule_normalization = __esm(() => {
-  init_canonical();
-  init_shell_command_normalization();
-});
-
-// src/permissions/cli.ts
-var exports_cli = {};
-__export(exports_cli, {
-  cliPermissions: () => cliPermissions
-});
-
-class CliPermissions {
-  allowedTools = [];
-  disallowedTools = [];
-  setAllowedTools(toolsString) {
-    this.allowedTools = this.parseToolList(toolsString);
-  }
-  setDisallowedTools(toolsString) {
-    this.disallowedTools = this.parseToolList(toolsString);
-  }
-  parseToolList(toolsString) {
-    if (!toolsString)
-      return [];
-    const tools = [];
-    let current = "";
-    let depth = 0;
-    for (let i = 0;i < toolsString.length; i++) {
-      const char = toolsString[i];
-      if (char === "(") {
-        depth++;
-        current += char;
-      } else if (char === ")") {
-        depth--;
-        current += char;
-      } else if (char === "," && depth === 0) {
-        if (current.trim()) {
-          tools.push(this.normalizePattern(current.trim()));
-        }
-        current = "";
-      } else {
-        current += char;
-      }
-    }
-    if (current.trim()) {
-      tools.push(this.normalizePattern(current.trim()));
-    }
-    return tools;
-  }
-  normalizePattern(pattern) {
-    const trimmed = pattern.trim();
-    if (trimmed.includes("(")) {
-      return normalizePermissionRule(trimmed);
-    }
-    const canonicalTool = canonicalToolName(trimmed);
-    if (isShellToolName(canonicalTool)) {
-      return "Bash(:*)";
-    }
-    if (isFileToolName(canonicalTool)) {
-      return `${canonicalTool}(**)`;
-    }
-    return canonicalTool;
-  }
-  getAllowedTools() {
-    return [...this.allowedTools];
-  }
-  getDisallowedTools() {
-    return [...this.disallowedTools];
-  }
-  hasOverrides() {
-    return this.allowedTools.length > 0 || this.disallowedTools.length > 0;
-  }
-  clear() {
-    this.allowedTools = [];
-    this.disallowedTools = [];
-  }
-}
-var cliPermissions;
-var init_cli = __esm(() => {
-  init_canonical();
-  init_rule_normalization();
-  cliPermissions = new CliPermissions;
-});
-
 // src/agent/prompts/recall_subagent.md
 var recall_subagent_default = `Your task is to recall past experience based on a query. Use the CLI commands and search strategies below to search conversation history. Try to finish quickly with just 1-2 tool calls if possible (but use more if needed).
 
@@ -69639,11 +70047,14 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
         delete childEnv.MEMORY_DIR;
         delete childEnv.LETTA_MEMORY_DIR;
       }
-      const parentMemoryDir = process.env.MEMORY_DIR || process.env.LETTA_MEMORY_DIR;
-      if (parentMemoryDir && parentMemoryDir.trim().length > 0) {
-        childEnv.PARENT_MEMORY_DIR = parentMemoryDir;
+      const nextScope = new Set(parseScopeList(process.env.LETTA_MEMORY_SCOPE));
+      if (parentAgentId) {
+        nextScope.add(parentAgentId);
+      }
+      if (nextScope.size > 0) {
+        childEnv.LETTA_MEMORY_SCOPE = [...nextScope].join(",");
       } else {
-        delete childEnv.PARENT_MEMORY_DIR;
+        delete childEnv.LETTA_MEMORY_SCOPE;
       }
     }
     const proc2 = spawn5(launcher.command, launcher.args, {
@@ -70247,7 +70658,10 @@ async function task(args) {
       const parentAgentId = getCurrentAgentId();
       const parentConvId = getConversationId() ?? "default";
       const forkedConv = await client.post(`/v1/conversations/${encodeURIComponent(parentConvId)}/fork`, {
-        query: parentConvId === "default" ? { agent_id: parentAgentId } : {}
+        query: {
+          ...parentConvId === "default" ? { agent_id: parentAgentId } : {},
+          hidden: true
+        }
       });
       effectiveAgentId = parentAgentId;
       effectiveConversationId = forkedConv.id;
@@ -73459,8 +73873,8 @@ function matchesFilePattern(query, pattern, workingDirectory, options) {
     globPattern = globPattern.slice(2);
   }
   if (globPattern.startsWith("~/")) {
-    const homedir18 = __require("node:os").homedir();
-    globPattern = globPattern.replace(/^~/, homedir18);
+    const homedir19 = __require("node:os").homedir();
+    globPattern = globPattern.replace(/^~/, homedir19);
   }
   globPattern = normalizeAbsolutePattern(globPattern, workingDirectory);
   const windowsContext = isWindowsContext(workingDirectory);
@@ -73655,6 +74069,18 @@ function checkPermissionForEngine(engine, toolName, toolArgs, permissions, worki
   const trace = createTrace(engine, toolName, canonicalTool, query);
   const sessionRules = sessionPermissions.getRules();
   const workingDirectoryTools = engine === "v2" ? WORKING_DIRECTORY_TOOLS_V2 : WORKING_DIRECTORY_TOOLS_V1;
+  const guardResult = evaluateCrossAgentGuard(toolName, toolArgs, workingDirectory);
+  if (guardResult) {
+    traceEvent(trace, "cross-agent-guard", guardResult.reason);
+    return {
+      result: {
+        decision: "deny",
+        matchedRule: guardResult.matchedRule,
+        reason: guardResult.reason
+      },
+      trace
+    };
+  }
   if (permissions.deny) {
     for (const pattern of permissions.deny) {
       const matched = matchesPattern(toolName, query, pattern, workingDirectory, engine);
@@ -73731,7 +74157,7 @@ function checkPermissionForEngine(engine, toolName, toolArgs, permissions, worki
     };
   }
   if (READ_ONLY_SHELL_TOOLS.has(toolName) || isShellToolName(canonicalTool)) {
-    const shellCommand = extractShellCommand(toolArgs);
+    const shellCommand = extractShellCommand2(toolArgs);
     if (shellCommand && isReadOnlyShellCommand(shellCommand, {
       allowedPathRoots: getAllowedShellPathRoots(permissions, workingDirectory)
     })) {
@@ -73833,18 +74259,6 @@ function checkPermissionForEngine(engine, toolName, toolArgs, permissions, worki
     trace
   };
 }
-function extractFilePath(toolArgs) {
-  if (typeof toolArgs.file_path === "string" && toolArgs.file_path.length > 0) {
-    return toolArgs.file_path;
-  }
-  if (typeof toolArgs.path === "string" && toolArgs.path.length > 0) {
-    return toolArgs.path;
-  }
-  if (typeof toolArgs.notebook_path === "string" && toolArgs.notebook_path.length > 0) {
-    return toolArgs.notebook_path;
-  }
-  return null;
-}
 function isWithinAllowedDirectories(filePath, permissions, workingDirectory) {
   const absolutePath = resolve22(workingDirectory, filePath);
   if (absolutePath.startsWith(workingDirectory)) {
@@ -73918,7 +74332,7 @@ function buildPermissionQuery(toolName, toolArgs, engine) {
       return toolName;
   }
 }
-function extractShellCommand(toolArgs) {
+function extractShellCommand2(toolArgs) {
   const command = toolArgs.command;
   if (typeof command === "string" || Array.isArray(command)) {
     return command;
@@ -74013,6 +74427,7 @@ var init_checker = __esm(() => {
   init_hooks();
   init_canonical();
   init_cli();
+  init_crossAgentGuard();
   init_matcher();
   init_mode();
   init_readOnlyShell();
@@ -74092,10 +74507,10 @@ __export(exports_loader, {
   loadPermissions: () => loadPermissions,
   getUserSettingsPaths: () => getUserSettingsPaths
 });
-import { homedir as homedir18 } from "node:os";
+import { homedir as homedir19 } from "node:os";
 import { join as join24 } from "node:path";
 function getUserSettingsPaths(options = {}) {
-  const homeDir = options.homeDir || homedir18();
+  const homeDir = options.homeDir || homedir19();
   const xdgConfigHome = options.xdgConfigHome || process.env.XDG_CONFIG_HOME || join24(homeDir, ".config");
   return {
     canonical: join24(homeDir, ".letta", "settings.json"),
@@ -74217,7 +74632,7 @@ var exports_analyzer = {};
 __export(exports_analyzer, {
   analyzeApprovalContext: () => analyzeApprovalContext
 });
-import { homedir as homedir19 } from "node:os";
+import { homedir as homedir20 } from "node:os";
 import { dirname as dirname13, relative as relative8, resolve as resolve23, win32 as win322 } from "node:path";
 function normalizeOsPath(path19) {
   return path19.replace(/\\/g, "/");
@@ -74254,7 +74669,7 @@ function formatAbsoluteRulePath(path19) {
   return `//${normalized.replace(/^\/+/, "")}`;
 }
 function formatDisplayPath(path19) {
-  return normalizeOsPath(path19).replace(normalizeOsPath(homedir19()), "~");
+  return normalizeOsPath(path19).replace(normalizeOsPath(homedir20()), "~");
 }
 function analyzeApprovalContext(toolName, toolArgs, workingDirectory) {
   const canonicalTool = canonicalToolName(toolName);
@@ -74416,7 +74831,7 @@ function containsDangerousCommand(command) {
   }
   return false;
 }
-function escapeRegex2(text) {
+function escapeRegex3(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function normalizePathSeparators(path19) {
@@ -74448,7 +74863,7 @@ function detectSkillScript(command, workingDir) {
     return null;
   }
   const normalizedWorkingDir = normalizePathSeparators(workingDir).replace(/\/$/, "");
-  const normalizedHomeDir = normalizePathSeparators(homedir19()).replace(/\/$/, "");
+  const normalizedHomeDir = normalizePathSeparators(homedir20()).replace(/\/$/, "");
   const detect = (source, regex2) => {
     for (const candidate of pathCandidates) {
       const match3 = candidate.match(regex2);
@@ -74461,17 +74876,17 @@ function detectSkillScript(command, workingDir) {
     }
     return null;
   };
-  const projectRegex = new RegExp(`^${escapeRegex2(normalizedWorkingDir)}/\\.skills/(.+?)/scripts/`);
+  const projectRegex = new RegExp(`^${escapeRegex3(normalizedWorkingDir)}/\\.skills/(.+?)/scripts/`);
   const projectSkill = detect("project", projectRegex);
   if (projectSkill) {
     return projectSkill;
   }
-  const agentRegex = new RegExp(`^${escapeRegex2(normalizedHomeDir)}/\\.letta/agents/[^/]+/skills/(.+?)/scripts/`);
+  const agentRegex = new RegExp(`^${escapeRegex3(normalizedHomeDir)}/\\.letta/agents/[^/]+/skills/(.+?)/scripts/`);
   const agentSkill = detect("agent-scoped", agentRegex);
   if (agentSkill) {
     return agentSkill;
   }
-  const globalRegex = new RegExp(`^${escapeRegex2(normalizedHomeDir)}/\\.letta/skills/(.+?)/scripts/`);
+  const globalRegex = new RegExp(`^${escapeRegex3(normalizedHomeDir)}/\\.letta/skills/(.+?)/scripts/`);
   const globalSkill = detect("global", globalRegex);
   if (globalSkill) {
     return globalSkill;
@@ -77164,9 +77579,9 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 }
 
 // node_modules/default-browser-id/index.js
-import { promisify as promisify8 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 import process15 from "node:process";
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 async function defaultBrowserId() {
   if (process15.platform !== "darwin") {
     throw new Error("macOS only");
@@ -77177,13 +77592,13 @@ async function defaultBrowserId() {
 }
 var execFileAsync4;
 var init_default_browser_id = __esm(() => {
-  execFileAsync4 = promisify8(execFile8);
+  execFileAsync4 = promisify6(execFile6);
 });
 
 // node_modules/run-applescript/index.js
 import process16 from "node:process";
-import { promisify as promisify9 } from "node:util";
-import { execFile as execFile9, execFileSync as execFileSync2 } from "node:child_process";
+import { promisify as promisify7 } from "node:util";
+import { execFile as execFile7, execFileSync as execFileSync2 } from "node:child_process";
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
   if (process16.platform !== "darwin") {
     throw new Error("macOS only");
@@ -77198,7 +77613,7 @@ async function runAppleScript(script, { humanReadableOutput = true, signal } = {
 }
 var execFileAsync5;
 var init_run_applescript = __esm(() => {
-  execFileAsync5 = promisify9(execFile9);
+  execFileAsync5 = promisify7(execFile7);
 });
 
 // node_modules/bundle-name/index.js
@@ -77211,8 +77626,8 @@ var init_bundle_name = __esm(() => {
 });
 
 // node_modules/default-browser/windows.js
-import { promisify as promisify10 } from "node:util";
-import { execFile as execFile10 } from "node:child_process";
+import { promisify as promisify8 } from "node:util";
+import { execFile as execFile8 } from "node:child_process";
 async function defaultBrowser(_execFileAsync = execFileAsync6) {
   const { stdout } = await _execFileAsync("reg", [
     "QUERY",
@@ -77233,7 +77648,7 @@ async function defaultBrowser(_execFileAsync = execFileAsync6) {
 }
 var execFileAsync6, windowsBrowserProgIds, UnknownBrowserError;
 var init_windows = __esm(() => {
-  execFileAsync6 = promisify10(execFile10);
+  execFileAsync6 = promisify8(execFile8);
   windowsBrowserProgIds = {
     AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
     MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
@@ -77250,9 +77665,9 @@ var init_windows = __esm(() => {
 });
 
 // node_modules/default-browser/index.js
-import { promisify as promisify11 } from "node:util";
+import { promisify as promisify9 } from "node:util";
 import process17 from "node:process";
-import { execFile as execFile11 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 async function defaultBrowser2() {
   if (process17.platform === "darwin") {
     const id = await defaultBrowserId();
@@ -77275,7 +77690,7 @@ var init_default_browser = __esm(() => {
   init_default_browser_id();
   init_bundle_name();
   init_windows();
-  execFileAsync7 = promisify11(execFile11);
+  execFileAsync7 = promisify9(execFile9);
 });
 
 // node_modules/open/index.js
@@ -77289,14 +77704,14 @@ import process18 from "node:process";
 import { Buffer as Buffer3 } from "node:buffer";
 import path19 from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
-import { promisify as promisify12 } from "node:util";
+import { promisify as promisify10 } from "node:util";
 import childProcess from "node:child_process";
 import fs14, { constants as fsConstants2 } from "node:fs/promises";
 async function getWindowsDefaultBrowserFromWsl() {
   const powershellPath = await powerShellPath();
   const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
   const encodedCommand = Buffer3.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile12(powershellPath, [
+  const { stdout } = await execFile10(powershellPath, [
     "-NoProfile",
     "-NonInteractive",
     "-ExecutionPolicy",
@@ -77332,7 +77747,7 @@ function detectPlatformBinary({ [platform4]: platformBinary }, { wsl }) {
   }
   return detectArchBinary(platformBinary);
 }
-var execFile12, __dirname2, localXdgOpenPath, platform4, arch, pTryEach = async (array, mapper) => {
+var execFile10, __dirname2, localXdgOpenPath, platform4, arch, pTryEach = async (array, mapper) => {
   let latestError;
   for (const item of array) {
     try {
@@ -77511,7 +77926,7 @@ var init_open = __esm(() => {
   init_wsl_utils();
   init_default_browser();
   init_is_inside_container();
-  execFile12 = promisify12(childProcess.execFile);
+  execFile10 = promisify10(childProcess.execFile);
   __dirname2 = path19.dirname(fileURLToPath7(import.meta.url));
   localXdgOpenPath = path19.join(__dirname2, "xdg-open");
   ({ platform: platform4, arch } = process18);
@@ -83385,7 +83800,7 @@ import {
   readFile as readFile10,
   writeFile as writeFile7
 } from "node:fs/promises";
-import { homedir as homedir21, tmpdir as tmpdir3 } from "node:os";
+import { homedir as homedir22, tmpdir as tmpdir3 } from "node:os";
 import { join as join28 } from "node:path";
 function buildReflectionSubagentPrompt(input) {
   const lines = [];
@@ -83579,7 +83994,7 @@ function getTranscriptRoot() {
   if (envRoot) {
     return envRoot;
   }
-  return join28(homedir21(), ".letta", DEFAULT_TRANSCRIPT_DIR);
+  return join28(homedir22(), ".letta", DEFAULT_TRANSCRIPT_DIR);
 }
 function defaultState() {
   return { auto_cursor_line: 0 };
@@ -83819,7 +84234,7 @@ import {
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { homedir as homedir22 } from "node:os";
+import { homedir as homedir23 } from "node:os";
 import { join as join29 } from "node:path";
 function truncateStr(value, maxLen) {
   if (value === null || value === undefined)
@@ -83960,7 +84375,7 @@ class ChunkLog {
 var MAX_ENTRIES = 100, CONTENT_TRUNCATE_LEN = 200, MAX_SESSION_FILES2 = 5, LOG_BASE_DIR, chunkLog;
 var init_chunkLog = __esm(() => {
   init_debug();
-  LOG_BASE_DIR = join29(homedir22(), ".letta", "logs", "chunk-logs");
+  LOG_BASE_DIR = join29(homedir23(), ".letta", "logs", "chunk-logs");
   chunkLog = new ChunkLog;
 });
 
@@ -84960,10 +85375,10 @@ var init_constants2 = __esm(() => {
 // src/websocket/listener/remote-settings.ts
 import { existsSync as existsSync26, readFileSync as readFileSync17 } from "node:fs";
 import { mkdir as mkdir8, writeFile as writeFile8 } from "node:fs/promises";
-import { homedir as homedir23 } from "node:os";
+import { homedir as homedir24 } from "node:os";
 import path20 from "node:path";
 function getRemoteSettingsPath() {
-  return path20.join(homedir23(), ".letta", "remote-settings.json");
+  return path20.join(homedir24(), ".letta", "remote-settings.json");
 }
 function loadRemoteSettings() {
   if (_cache !== null) {
@@ -85007,7 +85422,7 @@ function saveRemoteSettings(updates) {
 }
 function loadLegacyCwdCache() {
   try {
-    const legacyPath = path20.join(homedir23(), ".letta", "cwd-cache.json");
+    const legacyPath = path20.join(homedir24(), ".letta", "cwd-cache.json");
     if (!existsSync26(legacyPath))
       return {};
     const raw = readFileSync17(legacyPath, "utf-8");
@@ -92475,6 +92890,9 @@ async function handleNewWorktree(params) {
   const newWorktreePath = path22.join(worktreesDir, filename);
   if (!await directoryExists(newWorktreePath))
     return;
+  const conversationRuntime = getConversationRuntime(runtime, agentId, conversationId);
+  if (!conversationRuntime?.isProcessing)
+    return;
   const currentCwd = getConversationWorkingDirectory(runtime, agentId, conversationId);
   if (currentCwd === newWorktreePath)
     return;
@@ -92519,6 +92937,7 @@ async function safeReaddir(dir) {
 var WORKTREES_DIR = ".letta/worktrees", DEBOUNCE_MS = 500;
 var init_worktree_watcher = __esm(async () => {
   init_cwd();
+  init_runtime3();
   await init_protocol_outbound();
 });
 
@@ -92602,10 +93021,10 @@ function readFileContent(fullPath) {
 var init_memoryScanner = () => {};
 
 // src/websocket/listener/client.ts
-import { execFile as execFile13 } from "node:child_process";
+import { execFile as execFile11 } from "node:child_process";
 import { realpath as realpath3, stat as stat6 } from "node:fs/promises";
 import path23 from "node:path";
-import { promisify as promisify13 } from "node:util";
+import { promisify as promisify11 } from "node:util";
 import WebSocket5 from "ws";
 async function loadChannelsService() {
   if (channelsServiceLoaderOverride) {
@@ -95491,9 +95910,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       if (isMemoryHistoryCommand(parsed)) {
         runDetachedListenerTask("memory_history", async () => {
           const { getMemoryFilesystemRoot: getMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
-          const { execFile: execFileCb5 } = await import("node:child_process");
-          const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync8 = promisify14(execFileCb5);
+          const { execFile: execFileCb3 } = await import("node:child_process");
+          const { promisify: promisify12 } = await import("node:util");
+          const execFileAsync8 = promisify12(execFileCb3);
           const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
           const limit2 = parsed.limit ?? 50;
           const { stdout } = await execFileAsync8("git", [
@@ -95526,9 +95945,9 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       if (isMemoryFileAtRefCommand(parsed)) {
         runDetachedListenerTask("memory_file_at_ref", async () => {
           const { getMemoryFilesystemRoot: getMemoryFilesystemRoot2 } = await Promise.resolve().then(() => (init_memoryFilesystem(), exports_memoryFilesystem));
-          const { execFile: execFileCb5 } = await import("node:child_process");
-          const { promisify: promisify14 } = await import("node:util");
-          const execFileAsync8 = promisify14(execFileCb5);
+          const { execFile: execFileCb3 } = await import("node:child_process");
+          const { promisify: promisify12 } = await import("node:util");
+          const execFileAsync8 = promisify12(execFileCb3);
           const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
           try {
             const { stdout } = await execFileAsync8("git", ["show", `${parsed.ref}:${parsed.file_path}`], { cwd: memoryRoot, timeout: 1e4 });
@@ -95599,7 +96018,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           try {
             const cwd2 = parsed.cwd ?? runtime.bootWorkingDirectory;
             const maxResults = parsed.max_results ?? 20;
-            const execFileAsync8 = promisify13(execFile13);
+            const execFileAsync8 = promisify11(execFile11);
             const { stdout } = await execFileAsync8("git", ["branch", "-a", "--format=%(refname:short)\t%(HEAD)"], {
               cwd: cwd2,
               encoding: "utf-8",
@@ -95639,7 +96058,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         runDetachedListenerTask("checkout_branch", async () => {
           try {
             const cwd2 = parsed.cwd ?? runtime.bootWorkingDirectory;
-            const execFileAsync8 = promisify13(execFile13);
+            const execFileAsync8 = promisify11(execFile11);
             const args = parsed.create ? ["checkout", "-b", parsed.branch] : ["checkout", parsed.branch];
             await execFileAsync8("git", args, {
               cwd: cwd2,
@@ -96127,7 +96546,7 @@ import {
   readFileSync as readFileSync19,
   unlinkSync as unlinkSync8
 } from "node:fs";
-import { homedir as homedir27 } from "node:os";
+import { homedir as homedir28 } from "node:os";
 import { join as join34 } from "node:path";
 import { format as format2 } from "node:util";
 function isDebugEnabled2() {
@@ -96233,7 +96652,7 @@ function debugWarn2(prefix, message, ...args) {
 }
 var DEBUG_LOG_DIR2, MAX_SESSION_FILES3 = 5, DEFAULT_TAIL_LINES2 = 50, debugLogFile2;
 var init_debug2 = __esm(() => {
-  DEBUG_LOG_DIR2 = join34(homedir27(), ".letta", "logs", "debug");
+  DEBUG_LOG_DIR2 = join34(homedir28(), ".letta", "logs", "debug");
   debugLogFile2 = new DebugLogFile2;
 });
 
@@ -96610,7 +97029,7 @@ __export(exports_bootstrap_tools, {
   bootstrapBaseToolsIfNeeded: () => bootstrapBaseToolsIfNeeded
 });
 import { existsSync as existsSync31, mkdirSync as mkdirSync23, writeFileSync as writeFileSync17 } from "node:fs";
-import { homedir as homedir28 } from "node:os";
+import { homedir as homedir29 } from "node:os";
 import { join as join36 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
   if (existsSync31(MARKER_PATH))
@@ -96619,7 +97038,7 @@ async function bootstrapBaseToolsIfNeeded() {
   try {
     const success = await addBaseToolsToServer();
     if (success) {
-      mkdirSync23(join36(homedir28(), ".letta"), { recursive: true });
+      mkdirSync23(join36(homedir29(), ".letta"), { recursive: true });
       writeFileSync17(MARKER_PATH, new Date().toISOString(), "utf-8");
     }
   } catch (err) {
@@ -96630,7 +97049,7 @@ var MARKER_PATH;
 var init_bootstrap_tools = __esm(() => {
   init_debug();
   init_create();
-  MARKER_PATH = join36(homedir28(), ".letta", ".bootstrapped");
+  MARKER_PATH = join36(homedir29(), ".letta", ".bootstrapped");
 });
 
 // src/lsp/manager.ts
@@ -96822,11 +97241,11 @@ __export(exports_auto_update, {
   buildInstallCommand: () => buildInstallCommand,
   buildInstallArgs: () => buildInstallArgs
 });
-import { execFile as execFile14 } from "node:child_process";
+import { execFile as execFile12 } from "node:child_process";
 import { realpathSync as realpathSync3 } from "node:fs";
 import { readdir as readdir9, rm as rm3 } from "node:fs/promises";
 import { join as join37 } from "node:path";
-import { promisify as promisify14 } from "node:util";
+import { promisify as promisify12 } from "node:util";
 function debugLog4(...args) {
   if (DEBUG2) {
     console.error("[auto-update]", ...args);
@@ -97151,7 +97570,7 @@ var execFileAsync8, DEBUG2, DEFAULT_UPDATE_PACKAGE_NAME = "@letta-ai/letta-code"
 var init_auto_update2 = __esm(() => {
   init_errorReporting();
   init_version();
-  execFileAsync8 = promisify14(execFile14);
+  execFileAsync8 = promisify12(execFile12);
   DEBUG2 = process.env.LETTA_DEBUG_AUTOUPDATE === "1";
   INSTALL_ARG_PREFIX2 = {
     npm: ["install", "-g"],
@@ -97860,12 +98279,16 @@ __export(exports_cli2, {
 class CliPermissions2 {
   allowedTools = [];
   disallowedTools = [];
+  memoryScope = [];
   setAllowedTools(toolsString) {
     this.allowedTools = this.parseToolList(toolsString);
   }
   setDisallowedTools(toolsString) {
     this.disallowedTools = this.parseToolList(toolsString);
   }
+  setMemoryScope(scopeString) {
+    this.memoryScope = parseScopeList(scopeString);
+  }
   parseToolList(toolsString) {
     if (!toolsString)
       return [];
@@ -97914,17 +98337,25 @@ class CliPermissions2 {
   getDisallowedTools() {
     return [...this.disallowedTools];
   }
+  getMemoryScope() {
+    return [...this.memoryScope];
+  }
+  hasMemoryScope() {
+    return this.memoryScope.length > 0;
+  }
   hasOverrides() {
-    return this.allowedTools.length > 0 || this.disallowedTools.length > 0;
+    return this.allowedTools.length > 0 || this.disallowedTools.length > 0 || this.memoryScope.length > 0;
   }
   clear() {
     this.allowedTools = [];
     this.disallowedTools = [];
+    this.memoryScope = [];
   }
 }
 var cliPermissions2;
 var init_cli2 = __esm(() => {
   init_canonical();
+  init_memoryScope();
   init_rule_normalization();
   cliPermissions2 = new CliPermissions2;
 });
@@ -98748,7 +99179,7 @@ async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride,
       }
     }
   }
-  if (values.allowedTools || values.disallowedTools) {
+  if (values.allowedTools || values.disallowedTools || values["memory-scope"]) {
     const { cliPermissions: cliPermissions3 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
     if (values.allowedTools) {
       cliPermissions3.setAllowedTools(values.allowedTools);
@@ -98756,6 +99187,9 @@ async function handleHeadlessCommand(parsedArgs, model, skillsDirectoryOverride,
     if (values.disallowedTools) {
       cliPermissions3.setDisallowedTools(values.disallowedTools);
     }
+    if (values["memory-scope"]) {
+      cliPermissions3.setMemoryScope(values["memory-scope"]);
+    }
   }
   const inputFormat = values["input-format"];
   const isBidirectionalMode = inputFormat === "stream-json";
@@ -99272,10 +99706,14 @@ In headless mode, use:
       }
     }
   } else if (forceNewConversation) {
-    const conversation = await client.conversations.create({
+    const createParams = {
       agent_id: agent.id,
       isolated_block_labels: isolatedBlockLabels
-    });
+    };
+    if (fromAgentId) {
+      createParams.hidden = true;
+    }
+    const conversation = await client.conversations.create(createParams);
     conversationId = conversation.id;
   } else if (isSubagent) {
     conversationId = "default";
@@ -101657,10 +102095,10 @@ __export(exports_settings, {
   loadProjectSettings: () => loadProjectSettings,
   getSetting: () => getSetting
 });
-import { homedir as homedir31 } from "node:os";
+import { homedir as homedir32 } from "node:os";
 import { join as join40 } from "node:path";
 function getSettingsPath() {
-  return join40(homedir31(), ".letta", "settings.json");
+  return join40(homedir32(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -121209,7 +121647,7 @@ var init_plan_viewer_template = () => {};
 
 // src/web/generate-plan-viewer.ts
 import { chmodSync as chmodSync2, existsSync as existsSync34, mkdirSync as mkdirSync26, writeFileSync as writeFileSync20 } from "node:fs";
-import { homedir as homedir32 } from "node:os";
+import { homedir as homedir33 } from "node:os";
 import { join as join41 } from "node:path";
 async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
   const data = {
@@ -121243,7 +121681,7 @@ async function generateAndOpenPlanViewer(planContent, planFilePath, options) {
 var VIEWERS_DIR;
 var init_generate_plan_viewer = __esm(() => {
   init_plan_viewer_template();
-  VIEWERS_DIR = join41(homedir32(), ".letta", "viewers");
+  VIEWERS_DIR = join41(homedir33(), ".letta", "viewers");
 });
 
 // src/cli/components/StaticPlanApproval.tsx
@@ -124408,7 +124846,7 @@ import {
   readFileSync as readFileSync22,
   writeFileSync as writeFileSync21
 } from "node:fs";
-import { homedir as homedir33, platform as platform6 } from "node:os";
+import { homedir as homedir34, platform as platform6 } from "node:os";
 import { dirname as dirname17, join as join43 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
@@ -124441,7 +124879,7 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os7 = platform6();
   if (os7 === "darwin") {
-    return join43(homedir33(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join43(homedir34(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os7 === "win32") {
     const appData = process.env.APPDATA;
@@ -124450,7 +124888,7 @@ function getKeybindingsPath(terminal) {
     return join43(appData, appName, "User", "keybindings.json");
   }
   if (os7 === "linux") {
-    return join43(homedir33(), ".config", appName, "User", "keybindings.json");
+    return join43(homedir34(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -124607,10 +125045,10 @@ function getWezTermConfigPath() {
     if (existsSync36(xdgPath))
       return xdgPath;
   }
-  const configPath = join43(homedir33(), ".config", "wezterm", "wezterm.lua");
+  const configPath = join43(homedir34(), ".config", "wezterm", "wezterm.lua");
   if (existsSync36(configPath))
     return configPath;
-  return join43(homedir33(), ".wezterm.lua");
+  return join43(homedir34(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists(configPath) {
   if (!existsSync36(configPath))
@@ -125658,10 +126096,10 @@ var init_HelpDialog = __esm(async () => {
 });
 
 // src/hooks/writer.ts
-import { homedir as homedir34 } from "node:os";
+import { homedir as homedir35 } from "node:os";
 import { resolve as resolve30 } from "node:path";
 function isProjectSettingsPathCollidingWithGlobal2(workingDirectory) {
-  const home = process.env.HOME || homedir34();
+  const home = process.env.HOME || homedir35();
   const globalSettingsPath = resolve30(home, ".letta", "settings.json");
   const projectSettingsPath = resolve30(workingDirectory, ".letta", "settings.json");
   return globalSettingsPath === projectSettingsPath;
@@ -128559,6 +128997,11 @@ function FileAutocomplete({
   const [isLoading, setIsLoading] = import_react70.useState(false);
   const [lastValidQuery, setLastValidQuery] = import_react70.useState("");
   const debounceTimeout = import_react70.useRef(null);
+  const searchGenRef = import_react70.useRef(0);
+  const lastValidQueryRef = import_react70.useRef(lastValidQuery);
+  lastValidQueryRef.current = lastValidQuery;
+  const matchesRef = import_react70.useRef(matches);
+  matchesRef.current = matches;
   const { selectedIndex } = useAutocompleteNavigation({
     matches,
     maxVisible: 10,
@@ -128591,8 +129034,8 @@ function FileAutocomplete({
         onActiveChange?.(false);
         return;
       }
-      if (query === lastValidQuery && lastValidQuery.length > 0) {
-        if (matches[0]?.path !== query) {
+      if (query === lastValidQueryRef.current && lastValidQueryRef.current.length > 0) {
+        if (matchesRef.current[0]?.path !== query) {
           setMatches([{ path: query, type: "file" }]);
         }
         setIsLoading(false);
@@ -128604,14 +129047,19 @@ function FileAutocomplete({
       onActiveChange?.(false);
       return;
     }
+    const gen = ++searchGenRef.current;
     if (query.length === 0) {
       setIsLoading(true);
       onActiveChange?.(true);
       searchFiles("", false).then((results) => {
+        if (searchGenRef.current !== gen)
+          return;
         setMatches(results);
         setIsLoading(false);
         onActiveChange?.(results.length > 0);
       }).catch(() => {
+        if (searchGenRef.current !== gen)
+          return;
         setMatches([]);
         setIsLoading(false);
         onActiveChange?.(false);
@@ -128628,6 +129076,8 @@ function FileAutocomplete({
     onActiveChange?.(true);
     debounceTimeout.current = setTimeout(() => {
       searchFiles(query, true).then((results) => {
+        if (searchGenRef.current !== gen)
+          return;
         setMatches(results);
         setIsLoading(false);
         onActiveChange?.(results.length > 0);
@@ -128635,6 +129085,8 @@ function FileAutocomplete({
           setLastValidQuery(query);
         }
       }).catch(() => {
+        if (searchGenRef.current !== gen)
+          return;
         setMatches([]);
         setIsLoading(false);
         onActiveChange?.(false);
@@ -128645,13 +129097,7 @@ function FileAutocomplete({
         clearTimeout(debounceTimeout.current);
       }
     };
-  }, [
-    currentInput,
-    cursorPosition,
-    onActiveChange,
-    lastValidQuery,
-    matches[0]?.path
-  ]);
+  }, [currentInput, cursorPosition, onActiveChange]);
   if (!currentInput.includes("@")) {
     return null;
   }
@@ -130719,7 +131165,7 @@ function cloneRepoToTemp(repo) {
 function createBranchName() {
   return `letta/install-github-app-${Date.now().toString(36)}`;
 }
-function runGit6(args, cwd2) {
+function runGit3(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
@@ -130740,7 +131186,7 @@ function writeWorkflow(repoDir, workflowPath, content) {
 }
 function getDefaultBaseBranch(repoDir) {
   try {
-    const headRef = runGit6(["symbolic-ref", "refs/remotes/origin/HEAD"], repoDir);
+    const headRef = runGit3(["symbolic-ref", "refs/remotes/origin/HEAD"], repoDir);
     return headRef.replace("refs/remotes/origin/", "").trim() || "main";
   } catch {
     return "main";
@@ -130816,7 +131262,7 @@ async function installGithubApp(options) {
       includeAgentId: resolvedAgentId != null
     });
     const branchName = createBranchName();
-    runGit6(["checkout", "-b", branchName], repoDir);
+    runGit3(["checkout", "-b", branchName], repoDir);
     progress(onProgress, "Creating workflow files");
     const changed = writeWorkflow(repoDir, workflowPath, workflowContent);
     progress(onProgress, "Setting up LETTA_API_KEY secret");
@@ -130839,10 +131285,10 @@ async function installGithubApp(options) {
         agentUrl: resolvedAgentId ? buildChatUrl(resolvedAgentId) : null
       };
     }
-    runGit6(["add", workflowPath], repoDir);
-    runGit6(["commit", "-m", "Add Letta Code GitHub Workflow"], repoDir);
+    runGit3(["add", workflowPath], repoDir);
+    runGit3(["commit", "-m", "Add Letta Code GitHub Workflow"], repoDir);
     progress(onProgress, "Opening pull request page");
-    runGit6(["push", "-u", "origin", branchName], repoDir);
+    runGit3(["push", "-u", "origin", branchName], repoDir);
     const pullRequest = createPullRequest(repo, branchName, workflowPath, repoDir);
     return {
       repo,
@@ -134966,14 +135412,14 @@ var exports_generate_memory_viewer = {};
 __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
-import { execFile as execFileCb5 } from "node:child_process";
+import { execFile as execFileCb3 } from "node:child_process";
 import { chmodSync as chmodSync3, existsSync as existsSync39, mkdirSync as mkdirSync29, writeFileSync as writeFileSync23 } from "node:fs";
-import { homedir as homedir35 } from "node:os";
+import { homedir as homedir36 } from "node:os";
 import { join as join47 } from "node:path";
-import { promisify as promisify15 } from "node:util";
+import { promisify as promisify13 } from "node:util";
 async function runGitSafe(cwd2, args) {
   try {
-    const { stdout } = await execFile15("git", args, {
+    const { stdout } = await execFile13("git", args, {
       cwd: cwd2,
       maxBuffer: 10 * 1024 * 1024,
       timeout: 60000
@@ -135307,15 +135753,15 @@ async function generateAndOpenMemoryViewer(agentId, options) {
   }
   return { filePath, opened: !skipOpen };
 }
-var execFile15, VIEWERS_DIR2, MAX_COMMITS = 500, RECENT_DIFF_COUNT = 50, PER_DIFF_CAP = 1e5, TOTAL_PAYLOAD_CAP = 5000000, RECORD_SEP = "\x1E", REFLECTION_PATTERN;
+var execFile13, VIEWERS_DIR2, MAX_COMMITS = 500, RECENT_DIFF_COUNT = 50, PER_DIFF_CAP = 1e5, TOTAL_PAYLOAD_CAP = 5000000, RECORD_SEP = "\x1E", REFLECTION_PATTERN;
 var init_generate_memory_viewer = __esm(() => {
   init_client2();
   init_memoryFilesystem();
   init_memoryGit();
   init_memoryScanner();
   init_memory_viewer_template();
-  execFile15 = promisify15(execFileCb5);
-  VIEWERS_DIR2 = join47(homedir35(), ".letta", "viewers");
+  execFile13 = promisify13(execFileCb3);
+  VIEWERS_DIR2 = join47(homedir36(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
@@ -138040,11 +138486,11 @@ var init_PersonalitySelector = __esm(async () => {
 
 // src/utils/aws-credentials.ts
 import { readFile as readFile16 } from "node:fs/promises";
-import { homedir as homedir36 } from "node:os";
+import { homedir as homedir37 } from "node:os";
 import { join as join48 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join48(homedir36(), ".aws", "credentials");
-  const configPath = join48(homedir36(), ".aws", "config");
+  const credentialsPath = join48(homedir37(), ".aws", "credentials");
+  const configPath = join48(homedir37(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile16(credentialsPath, "utf-8");
@@ -143990,7 +144436,7 @@ __export(exports_shellAliases, {
   clearAliasCache: () => clearAliasCache
 });
 import { existsSync as existsSync42, readFileSync as readFileSync25 } from "node:fs";
-import { homedir as homedir37 } from "node:os";
+import { homedir as homedir38 } from "node:os";
 import { join as join50 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
@@ -144060,7 +144506,7 @@ function loadAliases(forceReload = false) {
   if (aliasCache && !forceReload) {
     return aliasCache;
   }
-  const home = homedir37();
+  const home = homedir38();
   const allAliases = new Map;
   for (const file of ALIAS_FILES) {
     const filePath = join50(home, file);
@@ -144910,7 +145356,7 @@ __export(exports_App, {
 });
 import { randomUUID as randomUUID14 } from "node:crypto";
 import { existsSync as existsSync43, readFileSync as readFileSync26, renameSync as renameSync3, writeFileSync as writeFileSync24 } from "node:fs";
-import { homedir as homedir38, tmpdir as tmpdir6 } from "node:os";
+import { homedir as homedir39, tmpdir as tmpdir6 } from "node:os";
 import { join as join51, relative as relative18 } from "node:path";
 function deriveReasoningEffort(modelSettings, llmConfig) {
   if (modelSettings && "provider_type" in modelSettings) {
@@ -153276,7 +153722,7 @@ ${guidance}`);
         }
         if (mode === "bypassPermissions") {
           const planFilePath = activePlanPath ?? fallbackPlanPath;
-          const plansDir = join51(homedir38(), ".letta", "plans");
+          const plansDir = join51(homedir39(), ".letta", "plans");
           handlePlanKeepPlanning(`You must write your plan to a plan file before exiting plan mode.
 ` + (planFilePath ? `Plan file path: ${planFilePath}
 ` : "") + `Use a write tool to create your plan in ${plansDir}, then use ExitPlanMode to present the plan to the user.`);
@@ -153311,7 +153757,7 @@ ${guidance}`);
       if (!hasUsablePlan) {
         lastAutoHandledExitPlanToolCallIdRef.current = approval.toolCallId;
         const planFilePath = activePlanPath ?? fallbackPlanPath;
-        const plansDir = join51(homedir38(), ".letta", "plans");
+        const plansDir = join51(homedir39(), ".letta", "plans");
         handlePlanKeepPlanning(`You must write your plan to a plan file before exiting plan mode.
 ` + (planFilePath ? `Plan file path: ${planFilePath}
 ` : "") + `Use a write tool to create your plan in ${plansDir}, then use ExitPlanMode to present the plan to the user.`);
@@ -154727,7 +155173,7 @@ import {
   readFileSync as readFileSync27,
   writeFileSync as writeFileSync25
 } from "node:fs";
-import { homedir as homedir39, platform as platform7 } from "node:os";
+import { homedir as homedir40, platform as platform7 } from "node:os";
 import { dirname as dirname20, join as join52 } from "node:path";
 function detectTerminalType2() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
@@ -154760,7 +155206,7 @@ function getKeybindingsPath2(terminal) {
   }[terminal];
   const os8 = platform7();
   if (os8 === "darwin") {
-    return join52(homedir39(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join52(homedir40(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os8 === "win32") {
     const appData = process.env.APPDATA;
@@ -154769,7 +155215,7 @@ function getKeybindingsPath2(terminal) {
     return join52(appData, appName, "User", "keybindings.json");
   }
   if (os8 === "linux") {
-    return join52(homedir39(), ".config", appName, "User", "keybindings.json");
+    return join52(homedir40(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -154926,10 +155372,10 @@ function getWezTermConfigPath2() {
     if (existsSync44(xdgPath))
       return xdgPath;
   }
-  const configPath = join52(homedir39(), ".config", "wezterm", "wezterm.lua");
+  const configPath = join52(homedir40(), ".config", "wezterm", "wezterm.lua");
   if (existsSync44(configPath))
     return configPath;
-  return join52(homedir39(), ".wezterm.lua");
+  return join52(homedir40(), ".wezterm.lua");
 }
 function wezTermDeleteFixExists2(configPath) {
   if (!existsSync44(configPath))
@@ -155027,10 +155473,10 @@ __export(exports_settings2, {
   loadProjectSettings: () => loadProjectSettings2,
   getSetting: () => getSetting2
 });
-import { homedir as homedir40 } from "node:os";
+import { homedir as homedir41 } from "node:os";
 import { join as join53 } from "node:path";
 function getSettingsPath2() {
-  return join53(homedir40(), ".letta", "settings.json");
+  return join53(homedir41(), ".letta", "settings.json");
 }
 async function loadSettings2() {
   const settingsPath = getSettingsPath2();
@@ -155717,15 +156163,15 @@ __export(exports_memoryFilesystem2, {
   MEMORY_FS_AGENTS_DIR: () => MEMORY_FS_AGENTS_DIR2
 });
 import { existsSync as existsSync45, mkdirSync as mkdirSync31 } from "node:fs";
-import { homedir as homedir41 } from "node:os";
+import { homedir as homedir42 } from "node:os";
 import { join as join54 } from "node:path";
-function getMemoryFilesystemRoot2(agentId, homeDir = homedir41()) {
+function getMemoryFilesystemRoot2(agentId, homeDir = homedir42()) {
   return join54(homeDir, MEMORY_FS_ROOT2, MEMORY_FS_AGENTS_DIR2, agentId, MEMORY_FS_MEMORY_DIR2);
 }
-function getMemorySystemDir2(agentId, homeDir = homedir41()) {
+function getMemorySystemDir2(agentId, homeDir = homedir42()) {
   return join54(getMemoryFilesystemRoot2(agentId, homeDir), MEMORY_SYSTEM_DIR2);
 }
-function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir41()) {
+function ensureMemoryFilesystemDirs2(agentId, homeDir = homedir42()) {
   const root = getMemoryFilesystemRoot2(agentId, homeDir);
   const systemDir = getMemorySystemDir2(agentId, homeDir);
   if (!existsSync45(root)) {
@@ -156533,7 +156979,10 @@ If you experience this issue multiple times, move ~/.letta to ~/.letta_backup, a
     timeout: Number(process.env.LETTA_REQUEST_TIMEOUT_MS) || 10 * 60 * 1000,
     defaultHeaders: {
       "X-Letta-Source": "letta-code",
-      "User-Agent": `letta-code/${package_default.version}`
+      "User-Agent": `letta-code/${package_default.version}`,
+      ...process.env.LETTA_NODE === "1" && {
+        "x-letta-node": "1"
+      }
     },
     ...isTimingsEnabled() && { fetch: createTimingFetch(fetch) }
   });
@@ -156949,6 +157398,18 @@ var CLI_FLAG_CATALOG = {
   allowedTools: { parser: { type: "string" }, mode: "both" },
   disallowedTools: { parser: { type: "string" }, mode: "both" },
   "permission-mode": { parser: { type: "string" }, mode: "both" },
+  "memory-scope": {
+    parser: { type: "string" },
+    mode: "both",
+    help: {
+      argLabel: "<ids>",
+      description: "Comma-separated agent IDs this session may access in addition to self.",
+      continuationLines: [
+        "Example: --memory-scope agent-abc,agent-def",
+        "Required to read or write another agent's memory directory."
+      ]
+    }
+  },
   yolo: { parser: { type: "boolean" }, mode: "both" },
   "output-format": {
     parser: { type: "string" },
@@ -160391,9 +160852,9 @@ import {
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync6
 } from "node:fs";
-import { homedir as homedir20 } from "node:os";
+import { homedir as homedir21 } from "node:os";
 import { join as join26 } from "node:path";
-var REMOTE_LOG_DIR = join26(homedir20(), ".letta", "logs", "remote");
+var REMOTE_LOG_DIR = join26(homedir21(), ".letta", "logs", "remote");
 var MAX_LOG_FILES = 10;
 function formatTimestamp2() {
   const now = new Date;
@@ -160956,7 +161417,7 @@ async function runListenSubcommand(argv) {
 init_memoryGit();
 import { cpSync, existsSync as existsSync27, mkdirSync as mkdirSync20, rmSync as rmSync3, statSync as statSync8 } from "node:fs";
 import { readdir as readdir7 } from "node:fs/promises";
-import { homedir as homedir24 } from "node:os";
+import { homedir as homedir25 } from "node:os";
 import { join as join31 } from "node:path";
 import { parseArgs as parseArgs8 } from "node:util";
 function printUsage5() {
@@ -161002,10 +161463,10 @@ function parseMemfsArgs(argv) {
   });
 }
 function getMemoryRoot(agentId) {
-  return join31(homedir24(), ".letta", "agents", agentId, "memory");
+  return join31(homedir25(), ".letta", "agents", agentId, "memory");
 }
 function getAgentRoot(agentId) {
-  return join31(homedir24(), ".letta", "agents", agentId);
+  return join31(homedir25(), ".letta", "agents", agentId);
 }
 function formatBackupTimestamp(date = new Date) {
   const pad = (value) => String(value).padStart(2, "0");
@@ -161083,11 +161544,11 @@ async function runMemfsSubcommand(argv) {
         console.error("Not a git repo. Enable git-backed memory first.");
         return 1;
       }
-      const { execFile: execFileCb5 } = await import("node:child_process");
-      const { promisify: promisify14 } = await import("node:util");
-      const execFile14 = promisify14(execFileCb5);
+      const { execFile: execFileCb3 } = await import("node:child_process");
+      const { promisify: promisify12 } = await import("node:util");
+      const execFile12 = promisify12(execFileCb3);
       const dir = getMemoryRepoDir(agentId);
-      const { stdout } = await execFile14("git", ["diff"], { cwd: dir });
+      const { stdout } = await execFile12("git", ["diff"], { cwd: dir });
       if (stdout.trim()) {
         console.log(stdout);
         return 2;
@@ -161558,10 +162019,11 @@ async function runSubcommand(argv) {
 }
 
 // src/permissions/mode.ts
+init_crossAgentGuard();
 init_memoryScope();
 init_readOnlyShell();
 init_shell_command_normalization();
-import { homedir as homedir25 } from "node:os";
+import { homedir as homedir26 } from "node:os";
 import { isAbsolute as isAbsolute18, join as join32, relative as relative13 } from "node:path";
 var MODE_KEY2 = Symbol.for("@letta/permissionMode");
 var PLAN_FILE_KEY2 = Symbol.for("@letta/planFilePath");
@@ -161608,22 +162070,6 @@ function isPathInPlansDir2(path24, plansDir) {
   const rel = relative13(plansDir, path24);
   return rel !== "" && !rel.startsWith("..") && !isAbsolute18(rel);
 }
-function extractApplyPatchPaths2(input) {
-  const paths = [];
-  const fileDirectivePattern = /\*\*\* (?:Add|Update|Delete) File:\s*(.+)/g;
-  const moveDirectivePattern = /\*\*\* Move to:\s*(.+)/g;
-  for (const match3 of input.matchAll(fileDirectivePattern)) {
-    const matchPath = match3[1]?.trim();
-    if (matchPath)
-      paths.push(matchPath);
-  }
-  for (const match3 of input.matchAll(moveDirectivePattern)) {
-    const matchPath = match3[1]?.trim();
-    if (matchPath)
-      paths.push(matchPath);
-  }
-  return paths;
-}
 function stripMatchingQuotes2(value) {
   const trimmed = value.trim();
   if (trimmed.length < 2) {
@@ -161794,12 +162240,12 @@ class PermissionModeManager2 {
           return "allow";
         }
         if (writeTools.includes(toolName)) {
-          const plansDir = join32(homedir25(), ".letta", "plans");
+          const plansDir = join32(homedir26(), ".letta", "plans");
           const targetPath = toolArgs?.file_path || toolArgs?.path;
           let candidatePaths = [];
           if ((toolName === "ApplyPatch" || toolName === "apply_patch" || toolName === "memory_apply_patch") && toolArgs?.input) {
             const input = toolArgs.input;
-            candidatePaths = extractApplyPatchPaths2(input);
+            candidatePaths = extractApplyPatchPaths(input);
           } else if (typeof targetPath === "string") {
             candidatePaths = [targetPath];
           }
@@ -161845,7 +162291,7 @@ class PermissionModeManager2 {
           }
           const planWritePath = extractPlanFileWritePathFromShellCommand2(command);
           if (planWritePath) {
-            const plansDir = join32(homedir25(), ".letta", "plans");
+            const plansDir = join32(homedir26(), ".letta", "plans");
             const resolvedPath = resolvePlanTargetPath2(planWritePath, workingDirectory);
             if (resolvedPath && isPathInPlansDir2(resolvedPath, plansDir)) {
               return "allow";
@@ -161919,7 +162365,7 @@ class PermissionModeManager2 {
           const targetPath = toolArgs?.file_path || toolArgs?.path;
           let candidatePaths = [];
           if ((toolName === "ApplyPatch" || toolName === "apply_patch") && toolArgs?.input) {
-            candidatePaths = extractApplyPatchPaths2(toolArgs.input);
+            candidatePaths = extractApplyPatchPaths(toolArgs.input);
           } else if (typeof targetPath === "string") {
             candidatePaths = [targetPath];
           }
@@ -161962,7 +162408,7 @@ init_debug();
 init_fs();
 init_secrets();
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { homedir as homedir26 } from "node:os";
+import { homedir as homedir27 } from "node:os";
 import { join as join33, resolve as resolve26 } from "node:path";
 var DEFAULT_SETTINGS3 = {
   lastAgent: null,
@@ -162349,7 +162795,7 @@ class SettingsManager2 {
     if (!this.settings)
       return;
     const settingsPath = this.getSettingsPath();
-    const home = process.env.HOME || homedir26();
+    const home = process.env.HOME || homedir27();
     const dirPath = join33(home, ".letta");
     try {
       if (!exists(dirPath)) {
@@ -162410,7 +162856,7 @@ class SettingsManager2 {
     }
   }
   getSettingsPath() {
-    const home = process.env.HOME || homedir26();
+    const home = process.env.HOME || homedir27();
     return join33(home, ".letta", "settings.json");
   }
   getProjectSettingsPath(workingDirectory) {
@@ -164253,7 +164699,7 @@ Error: ${message}`);
     const { toolFilter: toolFilter3 } = await Promise.resolve().then(() => (init_filter2(), exports_filter2));
     toolFilter3.setEnabledTools(values.tools);
   }
-  if (values.allowedTools || values.disallowedTools) {
+  if (values.allowedTools || values.disallowedTools || values["memory-scope"]) {
     const { cliPermissions: cliPermissions3 } = await Promise.resolve().then(() => (init_cli2(), exports_cli2));
     if (values.allowedTools) {
       cliPermissions3.setAllowedTools(values.allowedTools);
@@ -164261,6 +164707,9 @@ Error: ${message}`);
     if (values.disallowedTools) {
       cliPermissions3.setDisallowedTools(values.disallowedTools);
     }
+    if (values["memory-scope"]) {
+      cliPermissions3.setMemoryScope(values["memory-scope"]);
+    }
   }
   const permissionModeValue = values["permission-mode"];
   const yoloMode = values.yolo;
@@ -165038,4 +165487,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=D837155EA6C28D1764756E2164756E21
+//# debugId=1D3F2BB144427E1064756E2164756E21