@letta-ai/letta-code 0.30.4 → 0.30.5

package/letta.js

@@ -5359,7 +5359,9 @@ var init_settings_manager = __esm(() => {
     recentModels: [],
     memoryReminderInterval: 25,
     reflectionTrigger: "step-count",
-    reflectionStepCount: 25
+    reflectionStepCount: 25,
+    reflectionMerge: "auto",
+    reflectionMergeInstructions: ""
   };
   DEFAULT_PROJECT_SETTINGS = {};
   DEFAULT_LOCAL_PROJECT_SETTINGS = {
@@ -5462,7 +5464,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.30.4",
+    version: "0.30.5",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -6486,6 +6488,14 @@ class TelemetryManager {
     };
     this.track("reflection_end", data);
   }
+  trackReflectionWorktreeCleanup(options) {
+    const data = {
+      ...options,
+      version: getVersion(),
+      platform: process.platform
+    };
+    this.track("reflection_worktree_cleanup", data);
+  }
   trackReflectionArenaVote(vote) {
     this.track("reflection_arena_vote", {
       ...vote,
@@ -141415,6 +141425,73 @@ var init_models7 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "opus-5",
+        handle: "anthropic/claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 (high reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "high",
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-5-low",
+        handle: "anthropic/claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 (low reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "low",
+          max_reasoning_tokens: 4000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-5-medium",
+        handle: "anthropic/claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 (med reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "medium",
+          max_reasoning_tokens: 12000,
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-5-xhigh",
+        handle: "anthropic/claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 (extra-high reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "xhigh",
+          parallel_tool_calls: true
+        }
+      },
+      {
+        id: "opus-5-max",
+        handle: "anthropic/claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 (max reasoning)",
+        updateArgs: {
+          context_window: 200000,
+          max_output_tokens: 128000,
+          enable_reasoner: true,
+          reasoning_effort: "max",
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "opus",
         handle: "anthropic/claude-opus-4-8",
@@ -141689,7 +141766,7 @@ var init_models7 = __esm(() => {
         id: "sonnet-5-xhigh",
         handle: "anthropic/claude-sonnet-5",
         label: "Sonnet 5",
-        description: "Sonnet 5 (max reasoning)",
+        description: "Sonnet 5 (extra-high reasoning)",
         updateArgs: {
           context_window: 1e6,
           max_output_tokens: 128000,
@@ -141698,6 +141775,19 @@ var init_models7 = __esm(() => {
           parallel_tool_calls: true
         }
       },
+      {
+        id: "sonnet-5-max",
+        handle: "anthropic/claude-sonnet-5",
+        label: "Sonnet 5",
+        description: "Sonnet 5 (max reasoning)",
+        updateArgs: {
+          context_window: 1e6,
+          max_output_tokens: 128000,
+          reasoning_effort: "max",
+          enable_reasoner: true,
+          parallel_tool_calls: true
+        }
+      },
       {
         id: "sonnet-4.6",
         handle: "anthropic/claude-sonnet-4-6",
@@ -145321,7 +145411,7 @@ __export(exports_modify, {
   __modifyTestUtils: () => __modifyTestUtils
 });
 function supportsDistinctAnthropicXHighEffort(modelHandle) {
-  return modelHandle.includes("claude-fable-5") || modelHandle.includes("claude-opus-4-7") || modelHandle.includes("claude-opus-4-8");
+  return modelHandle.includes("claude-fable-5") || modelHandle.includes("claude-opus-5") || modelHandle.includes("claude-sonnet-5") || modelHandle.includes("claude-opus-4-7") || modelHandle.includes("claude-opus-4-8");
 }
 function buildModelSettings(modelHandle, updateArgs) {
   const explicitProviderType = typeof updateArgs?.provider_type === "string" ? updateArgs.provider_type : undefined;
@@ -175417,10 +175507,18 @@ function normalizeTrigger(value, fallback) {
   }
   return fallback;
 }
+function normalizeMerge(value, fallback) {
+  return value === "auto" || value === "explicit" ? value : fallback;
+}
+function normalizeMergeInstructions(value, fallback) {
+  return typeof value === "string" ? value.trim() : fallback;
+}
 function applyExplicitReflectionOverrides(base2, raw) {
   return {
     trigger: normalizeTrigger(raw.reflectionTrigger, base2.trigger),
-    stepCount: normalizeStepCount(raw.reflectionStepCount, base2.stepCount)
+    stepCount: normalizeStepCount(raw.reflectionStepCount, base2.stepCount),
+    merge: normalizeMerge(raw.reflectionMerge, base2.merge),
+    mergeInstructions: normalizeMergeInstructions(raw.reflectionMergeInstructions, base2.mergeInstructions)
   };
 }
 function applyPersistedAgentScopedSettings(base2, raw) {
@@ -175429,32 +175527,42 @@ function applyPersistedAgentScopedSettings(base2, raw) {
   }
   return {
     trigger: normalizeTrigger(raw.trigger, base2.trigger),
-    stepCount: normalizeStepCount(raw.stepCount, base2.stepCount)
+    stepCount: normalizeStepCount(raw.stepCount, base2.stepCount),
+    merge: normalizeMerge(raw.merge, base2.merge),
+    mergeInstructions: normalizeMergeInstructions(raw.mergeInstructions, base2.mergeInstructions)
   };
 }
 function legacyModeToReflectionSettings(mode) {
   if (typeof mode === "number") {
     return {
       trigger: "step-count",
-      stepCount: normalizeStepCount(mode, DEFAULT_STEP_COUNT)
+      stepCount: normalizeStepCount(mode, DEFAULT_STEP_COUNT),
+      merge: DEFAULT_REFLECTION_SETTINGS.merge,
+      mergeInstructions: DEFAULT_REFLECTION_SETTINGS.mergeInstructions
     };
   }
   if (mode === null) {
     return {
       trigger: "off",
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount,
+      merge: DEFAULT_REFLECTION_SETTINGS.merge,
+      mergeInstructions: DEFAULT_REFLECTION_SETTINGS.mergeInstructions
     };
   }
   if (mode === "compaction") {
     return {
       trigger: "compaction-event",
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount,
+      merge: DEFAULT_REFLECTION_SETTINGS.merge,
+      mergeInstructions: DEFAULT_REFLECTION_SETTINGS.mergeInstructions
     };
   }
   if (mode === "auto-compaction") {
     return {
       trigger: "compaction-event",
-      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount
+      stepCount: DEFAULT_REFLECTION_SETTINGS.stepCount,
+      merge: DEFAULT_REFLECTION_SETTINGS.merge,
+      mergeInstructions: DEFAULT_REFLECTION_SETTINGS.mergeInstructions
     };
   }
   return { ...DEFAULT_REFLECTION_SETTINGS };
@@ -175476,16 +175584,6 @@ function getReflectionSettings(agentId, workingDirectory = process.cwd()) {
   } catch {
     localSettings = null;
   }
-  if (agentId) {
-    const localScoped = localSettings?.reflectionSettingsByAgent?.[agentId];
-    if (localScoped) {
-      return applyPersistedAgentScopedSettings(DEFAULT_REFLECTION_SETTINGS, localScoped);
-    }
-    const globalScoped = globalSettings.reflectionSettingsByAgent?.[agentId];
-    if (globalScoped) {
-      return applyPersistedAgentScopedSettings(DEFAULT_REFLECTION_SETTINGS, globalScoped);
-    }
-  }
   let resolved = legacyModeToReflectionSettings(globalSettings.memoryReminderInterval);
   resolved = applyExplicitReflectionOverrides(resolved, globalSettings);
   if (localSettings) {
@@ -175494,6 +175592,10 @@ function getReflectionSettings(agentId, workingDirectory = process.cwd()) {
     }
     resolved = applyExplicitReflectionOverrides(resolved, localSettings);
   }
+  if (agentId) {
+    resolved = applyPersistedAgentScopedSettings(resolved, globalSettings.reflectionSettingsByAgent?.[agentId]);
+    resolved = applyPersistedAgentScopedSettings(resolved, localSettings?.reflectionSettingsByAgent?.[agentId]);
+  }
   return resolved;
 }
 function shouldFireStepCountTrigger(stepsSinceLastSuccessfulReflection, settings3 = getReflectionSettings()) {
@@ -175509,6 +175611,8 @@ async function persistReflectionSettingsForAgent(agentId, settings3, options3 =
     persistLocalProject = true,
     persistGlobal = true
   } = options3;
+  const merge2 = normalizeMerge(settings3.merge, DEFAULT_REFLECTION_SETTINGS.merge);
+  const mergeInstructions = normalizeMergeInstructions(settings3.mergeInstructions, DEFAULT_REFLECTION_SETTINGS.mergeInstructions);
   const legacyMode = reflectionSettingsToLegacyMode(settings3);
   if (persistLocalProject) {
     try {
@@ -175521,11 +175625,15 @@ async function persistReflectionSettingsForAgent(agentId, settings3, options3 =
       memoryReminderInterval: legacyMode,
       reflectionTrigger: settings3.trigger,
       reflectionStepCount: settings3.stepCount,
+      reflectionMerge: merge2,
+      reflectionMergeInstructions: mergeInstructions,
       reflectionSettingsByAgent: {
         ...localSettings.reflectionSettingsByAgent ?? {},
         [agentId]: {
           trigger: settings3.trigger,
-          stepCount: settings3.stepCount
+          stepCount: settings3.stepCount,
+          merge: merge2,
+          mergeInstructions
         }
       }
     }, workingDirectory);
@@ -175536,11 +175644,15 @@ async function persistReflectionSettingsForAgent(agentId, settings3, options3 =
       memoryReminderInterval: legacyMode,
       reflectionTrigger: settings3.trigger,
       reflectionStepCount: settings3.stepCount,
+      reflectionMerge: merge2,
+      reflectionMergeInstructions: mergeInstructions,
       reflectionSettingsByAgent: {
         ...globalSettings.reflectionSettingsByAgent ?? {},
         [agentId]: {
           trigger: settings3.trigger,
-          stepCount: settings3.stepCount
+          stepCount: settings3.stepCount,
+          merge: merge2,
+          mergeInstructions
         }
       }
     });
@@ -175551,7 +175663,9 @@ var init_memory_reminder = __esm(() => {
   init_settings_manager();
   DEFAULT_REFLECTION_SETTINGS = {
     trigger: "compaction-event",
-    stepCount: DEFAULT_STEP_COUNT
+    stepCount: DEFAULT_STEP_COUNT,
+    merge: "auto",
+    mergeInstructions: ""
   };
 });
 
@@ -175694,7 +175808,7 @@ function buildBackgroundProcessSnapshot(agentId, conversationId = "default") {
   const taskProcesses = Array.from(backgroundTasks.entries()).filter(([, task]) => task.status === "running" && (!runtimeScope || belongsToRuntime(task, runtimeScope))).map(([processId, task]) => ({
     process_id: processId,
     kind: "agent_task",
-    task_type: task.subagentType,
+    task_type: task.displayType ?? task.subagentType,
     description: task.description,
     started_at_ms: task.startTime.getTime(),
     status: task.status,
@@ -349572,7 +349686,9 @@ function buildDeviceStatus(runtime, params) {
     reflection_settings: scopedAgentId ? {
       agent_id: scopedAgentId,
       trigger: reflectionSettings?.trigger ?? "compaction-event",
-      step_count: reflectionSettings?.stepCount ?? 25
+      step_count: reflectionSettings?.stepCount ?? 25,
+      merge: reflectionSettings?.merge ?? "auto",
+      merge_instructions: reflectionSettings?.mergeInstructions ?? ""
     } : null
   };
 }
@@ -364685,6 +364801,9 @@ function resolveSubagentWorkingDirectory(env3 = process.env, fallbackCwd = getCu
   if (options3.subagentType === "reflection" && options3.launchProfile === "memory-subagent" && options3.memoryScope) {
     return env3.USER_CWD || fallbackCwd;
   }
+  if (options3.subagentType !== "reflection" && options3.launchProfile === "memory-subagent" && options3.memoryScope?.primaryRoot) {
+    return options3.memoryScope.primaryRoot;
+  }
   const primaryRoot = options3.memoryScope?.primaryRoot ?? options3.inheritedPrimaryRoot;
   if (options3.subagentType === "reflection" && options3.launchProfile === "memory-subagent" && primaryRoot) {
     return primaryRoot;
@@ -365231,13 +365350,14 @@ function buildSubagentArgs(type3, config3, model, userPrompt, existingAgentId, e
   return args;
 }
 async function executeSubagent(type3, config3, model, userPrompt, subagentId, isRetry = false, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride) {
+  const withModel = (result) => model ? { ...result, model } : result;
   if (signal?.aborted) {
-    return {
+    return withModel({
       agentId: "",
       report: "",
       success: false,
       error: INTERRUPTED_BY_USER
-    };
+    });
   }
   if (model) {
     updateSubagent(subagentId, { model });
@@ -365268,6 +365388,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
     const inheritedMemoryRoots = resolveAllowedMemoryRoots({
       currentAgentId: parentAgentId ?? null
     });
+    const effectiveLaunchProfile = memoryScope ? "memory-subagent" : config3.launchProfile;
     const localBackendStorageDir = backendMode === "local" ? getLocalBackendStorageDir2() : null;
     const inheritedPrimaryRoot = resolveSubagentInheritedPrimaryRoot({
       backendMode,
@@ -365277,7 +365398,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
     });
     const subagentWorkingDirectory = resolveSubagentWorkingDirectory(process.env, getCurrentWorkingDirectory(), {
       subagentType: type3,
-      launchProfile: config3.launchProfile,
+      launchProfile: effectiveLaunchProfile,
       inheritedPrimaryRoot,
       memoryScope
     });
@@ -365289,7 +365410,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
       backendMode,
       localBackendStorageDir,
       parentAgentId,
-      launchProfile: config3.launchProfile,
+      launchProfile: effectiveLaunchProfile,
       inheritedPrimaryRoot,
       memoryScope,
       inheritedApiKey,
@@ -365299,7 +365420,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
     });
     const sandbox = wrapSubagentLauncher({
       launcher,
-      launchProfile: config3.launchProfile,
+      launchProfile: effectiveLaunchProfile,
       backendMode,
       memoryRoots: inheritedMemoryRoots.roots,
       inheritedPrimaryRoot,
@@ -365359,13 +365480,13 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
     }
     signal?.removeEventListener("abort", abortHandler);
     if (wasAborted) {
-      return {
+      return withModel({
         agentId: state.agentId || "",
         conversationId: state.conversationId || undefined,
         report: "",
         success: false,
         error: INTERRUPTED_BY_USER
-      };
+      });
     }
     const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
     if (exitCode !== 0) {
@@ -365383,16 +365504,16 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
       }
       const propagatedError = state.finalError?.trim();
       const fallbackError = stderr || `Subagent exited with code ${exitCode}`;
-      return {
+      return withModel({
         agentId: state.agentId || "",
         conversationId: state.conversationId || undefined,
         report: "",
         success: false,
         error: propagatedError || fallbackError
-      };
+      });
     }
     if (state.finalResult !== null) {
-      return {
+      return withModel({
         agentId: state.agentId || "",
         conversationId: state.conversationId || undefined,
         report: state.finalResult,
@@ -365401,11 +365522,11 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
         totalTokens: state.resultStats?.totalTokens,
         stepCount: state.resultStats?.stepCount,
         durationMs: state.resultStats?.durationMs
-      };
+      });
     }
     if (state.finalError) {
       debugWarn("subagent", `Subagent ${subagentId} (agentId=${state.agentId}) exited with captured error: ${state.finalError}. ` + `exitCode=${exitCode}, stderr=${stderr.length} bytes`);
-      return {
+      return withModel({
         agentId: state.agentId || "",
         conversationId: state.conversationId || undefined,
         report: "",
@@ -365414,7 +365535,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
         totalTokens: state.resultStats?.totalTokens,
         stepCount: state.resultStats?.stepCount,
         durationMs: state.resultStats?.durationMs
-      };
+      });
     }
     debugWarn("subagent", `Subagent ${subagentId} (agentId=${state.agentId}) exited cleanly (exitCode=${exitCode}) ` + `but no result event was captured during streaming. ` + `stdout=${Buffer.concat(stdoutChunks).length} bytes, stderr=${stderr.length} bytes`);
     const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
@@ -365427,14 +365548,14 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
         return executeSubagent(type3, config3, model, userPrompt, subagentId, true, signal, existingAgentId, existingConversationId, maxTurns, parentAgentIdOverride, transcriptPath, memoryScope, systemPromptOverride);
       }
     }
-    return result;
+    return withModel(result);
   } catch (error54) {
-    return {
+    return withModel({
       agentId: "",
       report: "",
       success: false,
       error: getErrorMessage2(error54)
-    };
+    });
   }
 }
 function buildDeploySystemReminder(senderAgentName, senderAgentId) {
@@ -365446,6 +365567,9 @@ ${SYSTEM_REMINDER_CLOSE}
 
 `;
 }
+function shouldPrependDeploySystemReminder(existingAgentId, parentAgentId) {
+  return !existingAgentId || existingAgentId !== parentAgentId;
+}
 function recallPromptForBackend(backendMode) {
   return backendMode === "local" ? recall_subagent_local_default : recall_subagent_default;
 }
@@ -365527,7 +365651,7 @@ async function spawnSubagent(type3, prompt, userModel, subagentId, signal, exist
       if (forkedContext) {
         const systemReminder = buildForkSystemReminder(type3, backendMode);
         finalPrompt = systemReminder + prompt;
-      } else {
+      } else if (shouldPrependDeploySystemReminder(existingAgentId, resolvedParentAgentId)) {
         const systemReminder = buildDeploySystemReminder(cachedParent.name ?? "", resolvedParentAgentId);
         finalPrompt = systemReminder + prompt;
       }
@@ -365687,6 +365811,7 @@ var init_task_notifications = __esm(() => {
 var exports_task = {};
 __export(exports_task, {
   waitForBackgroundSubagentLink: () => waitForBackgroundSubagentLink,
+  waitForBackgroundSubagentConversationId: () => waitForBackgroundSubagentConversationId,
   waitForBackgroundSubagentAgentId: () => waitForBackgroundSubagentAgentId,
   task: () => task,
   spawnBackgroundSubagentTask: () => spawnBackgroundSubagentTask
@@ -365791,10 +365916,33 @@ async function waitForBackgroundSubagentAgentId(subagentId, timeoutMs = null, si
     await sleep8(BACKGROUND_STARTUP_POLL_MS);
   }
 }
+async function waitForBackgroundSubagentConversationId(subagentId, timeoutMs = null, signal) {
+  const deadline = timeoutMs !== null && timeoutMs > 0 ? Date.now() + timeoutMs : null;
+  while (true) {
+    if (signal?.aborted) {
+      return null;
+    }
+    const agent2 = getSnapshot().agents.find((a) => a.id === subagentId);
+    if (!agent2) {
+      return null;
+    }
+    if (agent2.conversationId) {
+      return agent2.conversationId;
+    }
+    if (agent2.status === "error" || agent2.status === "completed") {
+      return agent2.conversationId ?? null;
+    }
+    if (deadline !== null && Date.now() >= deadline) {
+      return agent2.conversationId ?? null;
+    }
+    await sleep8(BACKGROUND_STARTUP_POLL_MS);
+  }
+}
 function spawnBackgroundSubagentTask(args) {
   assertBackgroundTaskCapacity();
   const {
     subagentType,
+    displayType,
     prompt,
     description,
     model,
@@ -365824,13 +365972,14 @@ function spawnBackgroundSubagentTask(args) {
   const completeSubagentFn = deps?.completeSubagentImpl ?? completeSubagent;
   const getSubagentSnapshotFn = deps?.getSubagentSnapshotImpl ?? getSnapshot;
   const subagentId = generateSubagentIdFn();
-  registerSubagentFn(subagentId, subagentType, description, toolCallId, true, silentCompletion, resolvedParentScope, prompt);
+  registerSubagentFn(subagentId, displayType ?? subagentType, description, toolCallId, true, silentCompletion, resolvedParentScope, prompt);
   const taskId = getNextTaskId();
   const outputFile = createBackgroundOutputFile(taskId);
   const abortController = new AbortController;
   const bgTask = {
     description,
     subagentType,
+    displayType,
     subagentId,
     status: "running",
     output: [],
@@ -365864,6 +366013,7 @@ function spawnBackgroundSubagentTask(args) {
         error: result.error,
         agentId: result.agentId,
         conversationId: result.conversationId,
+        model: result.model,
         stepCount: result.stepCount,
         durationMs: result.durationMs,
         report: result.report
@@ -384829,6 +384979,59 @@ var init_check_approval = __esm(() => {
 });
 
 // src/agent/create-agent-request.ts
+function mergeMemoryBlocks(base2, overrides) {
+  const blocks = base2.map((block) => ({ ...block }));
+  for (const override of overrides ?? []) {
+    const index = blocks.findIndex((block) => block.label === override.label);
+    if (index >= 0) {
+      blocks[index] = { ...override };
+    } else {
+      blocks.push({ ...override });
+    }
+  }
+  return blocks;
+}
+async function buildCreateAgentRequest(options3 = {}) {
+  const personality = options3.personalityId ? getPersonalityOption(options3.personalityId) : undefined;
+  const modelIdentifier = options3.model ?? personality?.defaultModel;
+  const modelHandle = modelIdentifier ? resolveModel(modelIdentifier) : getDefaultModel();
+  if (!modelHandle) {
+    throw new Error(`Unknown model: ${modelIdentifier}`);
+  }
+  if (!options3.isSubagent && options3.enableMemfs !== undefined && options3.memoryPromptMode !== undefined && options3.enableMemfs !== (options3.memoryPromptMode !== "standard")) {
+    throw new Error("enableMemfs and memoryPromptMode must describe the same memory mode");
+  }
+  const enableMemfs = options3.isSubagent ? false : options3.enableMemfs ?? options3.memoryPromptMode !== "standard";
+  const memoryPromptMode = options3.isSubagent ? "standard" : options3.memoryPromptMode ?? (enableMemfs ? "memfs" : "standard");
+  const personalityTags = options3.personalityId ? getPersonalityCreationTags(options3.personalityId) : [];
+  const personalityBlocks = options3.personalityId ? buildPersonalityMemoryBlocks(options3.personalityId, await getDefaultMemoryBlocks()) : [];
+  const memoryBlocks = options3.isSubagent ? undefined : options3.personalityId || options3.memoryBlocks !== undefined ? mergeMemoryBlocks(personalityBlocks, options3.memoryBlocks) : undefined;
+  const blockIds = options3.isSubagent ? undefined : options3.blockIds;
+  return {
+    agent_type: LETTA_CODE_AGENT_TYPE,
+    ...options3.name !== undefined || personality ? { name: options3.name ?? personality?.label } : {},
+    ...options3.description !== undefined || personality ? { description: options3.description ?? personality?.description } : {},
+    model: modelHandle,
+    system: options3.system ?? buildSystemPrompt("default", memoryPromptMode),
+    ...memoryBlocks !== undefined ? { memory_blocks: memoryBlocks } : {},
+    ...blockIds && blockIds.length > 0 ? { block_ids: blockIds } : {},
+    tags: buildCreatedAgentTags({
+      enableMemfs,
+      isSubagent: options3.isSubagent,
+      tags: [...personalityTags, ...options3.extraTags ?? []]
+    }),
+    tools: [...options3.baseTools ?? DEFAULT_CREATED_AGENT_BASE_TOOLS],
+    include_base_tools: false,
+    include_base_tool_rules: false,
+    initial_message_sequence: [],
+    parallel_tool_calls: options3.parallelToolCalls ?? true,
+    compaction_settings: {
+      model: options3.compactionModel ?? DEFAULT_SUMMARIZATION_MODEL
+    },
+    ...options3.embedding !== undefined ? { embedding: options3.embedding } : {},
+    ...options3.isSubagent ? { hidden: true } : options3.hidden !== undefined ? { hidden: options3.hidden } : {}
+  };
+}
 var LETTA_CODE_AGENT_TYPE = "letta_v1_agent", DEFAULT_CREATED_AGENT_BASE_TOOLS;
 var init_create_agent_request = __esm(() => {
   init_constants2();
@@ -384932,8 +385135,7 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
     isLettaCloud: isLettaCloud2,
     isSubagent
   });
-  const defaultBaseTools = options3.baseTools ?? DEFAULT_CREATED_AGENT_BASE_TOOLS;
-  const toolNames = [...defaultBaseTools];
+  const toolNames = options3.baseTools;
   const referencedBlockIds = [];
   let filteredMemoryBlocks;
   if (options3.memoryBlocks !== undefined) {
@@ -384971,37 +385173,28 @@ async function createAgent(nameOrOptions = DEFAULT_AGENT_NAME, model, embeddingM
   const contextWindow = modelUpdateArgs?.context_window ?? await getModelContextWindow(modelHandle);
   const memMode = memfsConfig.memoryPromptMode;
   const systemPromptContent = options3.systemPromptCustom ? options3.systemPromptCustom : await resolveAndBuildSystemPrompt(options3.systemPromptPreset, memMode);
-  const tags = buildCreatedAgentTags({
-    tags: options3.tags,
-    isSubagent,
-    enableMemfs: memfsConfig.enableMemfs
-  });
   const agentDescription = options3.description ?? `Letta Code agent created in ${process.cwd()}`;
-  const createAgentRequestBase = {
-    agent_type: LETTA_CODE_AGENT_TYPE,
-    system: systemPromptContent,
+  const createAgentRequestBase = await buildCreateAgentRequest({
     name,
     description: agentDescription,
-    embedding: embeddingModelVal || undefined,
     model: modelHandle,
-    ...contextWindow && { context_window_limit: contextWindow },
-    memory_blocks: filteredMemoryBlocks.length > 0 ? filteredMemoryBlocks : undefined,
-    block_ids: referencedBlockIds.length > 0 ? referencedBlockIds : undefined,
-    tags,
-    ...isSubagent && { hidden: true },
-    include_base_tools: false,
-    include_base_tool_rules: false,
-    initial_message_sequence: [],
-    parallel_tool_calls: parallelToolCallsVal,
-    compaction_settings: {
-      model: DEFAULT_SUMMARIZATION_MODEL
-    }
-  };
+    system: systemPromptContent,
+    memoryPromptMode: memMode,
+    memoryBlocks: filteredMemoryBlocks.length > 0 ? filteredMemoryBlocks : undefined,
+    blockIds: referencedBlockIds,
+    extraTags: options3.tags,
+    enableMemfs: memfsConfig.enableMemfs,
+    isSubagent,
+    baseTools: toolNames,
+    embedding: embeddingModelVal || undefined,
+    parallelToolCalls: parallelToolCallsVal
+  });
   const createWithTools = (tools) => backend3.createAgent({
     ...createAgentRequestBase,
+    ...contextWindow && { context_window_limit: contextWindow },
     tools
   });
-  const agent2 = await createAgentWithBaseToolsRecovery(createWithTools, toolNames, addBaseToolsToServer);
+  const agent2 = await createAgentWithBaseToolsRecovery(createWithTools, createAgentRequestBase.tools, addBaseToolsToServer);
   const mergedUpdateArgs = {
     ...modelUpdateArgs ?? {},
     ...options3.updateArgs ?? {}
@@ -385575,6 +385768,13 @@ var init_args = __esm(() => {
       mode: "both",
       help: { description: "Enable memory filesystem for this agent" }
     },
+    stateless: {
+      parser: { type: "boolean" },
+      mode: "headless",
+      help: {
+        description: "Run an existing agent without MemFS enablement or sync"
+      }
+    },
     "no-memfs": {
       parser: { type: "boolean" },
       mode: "both"
@@ -425742,6 +425942,74 @@ function validateConversationDefaultRequiresAgent(options3) {
     throw new Error("--conv default requires --agent <agent-id>");
   }
 }
+function validateStatelessStartupOptions(options3) {
+  if (!options3.stateless) {
+    return;
+  }
+  if (!options3.isHeadless) {
+    throw new Error("--stateless is only supported in headless mode");
+  }
+  if (options3.memfs) {
+    throw new Error("--stateless cannot be used with --memfs");
+  }
+  if (options3.memfsStartup) {
+    throw new Error("--stateless cannot be used with --memfs-startup");
+  }
+  if (options3.forceNewAgent) {
+    throw new Error("--stateless is for existing agents and cannot be used with --new-agent");
+  }
+  if (!options3.hasExistingAgentSelector) {
+    throw new Error("--stateless requires --agent, --name, or --conversation");
+  }
+}
+function validatePrimaryStartupFlagConflicts(options3) {
+  validateStatelessStartupOptions({
+    stateless: options3.stateless,
+    isHeadless: options3.isHeadless,
+    memfs: options3.memfs,
+    memfsStartup: options3.memfsStartup,
+    forceNewAgent: options3.forceNewAgent,
+    hasExistingAgentSelector: Boolean(options3.specifiedAgentId || options3.specifiedAgentName || options3.specifiedConversationId)
+  });
+  validateFlagConflicts({
+    guard: options3.specifiedConversationId && options3.specifiedConversationId !== "default",
+    checks: [
+      {
+        when: options3.specifiedAgentId,
+        message: "--conversation cannot be used with --agent"
+      },
+      {
+        when: options3.specifiedAgentName,
+        message: "--conversation cannot be used with --name"
+      },
+      {
+        when: options3.forceNewAgent,
+        message: "--conversation cannot be used with --new-agent"
+      },
+      {
+        when: options3.importFile,
+        message: "--conversation cannot be used with --import"
+      },
+      {
+        when: options3.shouldResume,
+        message: "--conversation cannot be used with --resume"
+      }
+    ]
+  });
+  validateFlagConflicts({
+    guard: options3.forceNewConversation,
+    checks: [
+      {
+        when: options3.specifiedConversationId,
+        message: "--new cannot be used with --conversation"
+      },
+      {
+        when: options3.shouldResume,
+        message: "--new cannot be used with --resume"
+      }
+    ]
+  });
+}
 function validateRegistryHandleOrThrow(handle2) {
   const normalized = handle2.startsWith("@") ? handle2.slice(1) : handle2;
   const parts = normalized.split("/");
@@ -437758,7 +438026,8 @@ function buildQueuedTurnMessage(runtime, batch) {
       messages: [
         {
           role: "user",
-          content: mergedContent2
+          content: mergedContent2,
+          otid: crypto.randomUUID()
         }
       ]
     };
@@ -443817,8 +444086,8 @@ var init_dream_targets = __esm(() => {
 import { execFile as execFileCb4 } from "node:child_process";
 import { randomUUID as randomUUID24 } from "node:crypto";
 import { existsSync as existsSync46 } from "node:fs";
-import { mkdir as mkdir13, realpath as realpath4 } from "node:fs/promises";
-import { dirname as dirname26, isAbsolute as isAbsolute25, join as join61, relative as relative9, resolve as resolve31 } from "node:path";
+import { mkdir as mkdir13 } from "node:fs/promises";
+import { dirname as dirname26, isAbsolute as isAbsolute25, join as join61, resolve as resolve31 } from "node:path";
 import { promisify as promisify13 } from "node:util";
 async function runGit4(cwd2, args) {
   try {
@@ -443922,23 +444191,19 @@ function buildReflectionMemoryScope(worktree) {
     readonlyRoots: [dirname26(worktree.parentMemoryDir)]
   };
 }
-function buildPendingResultFromPending(pending, status, summary, error54) {
+function buildReflectionIntegrationMemoryScope(worktree) {
   return {
-    status,
-    parentMemoryDir: pending.parentMemoryDir,
-    reflectionWorktreeDir: pending.reflectionWorktreeDir,
-    reflectionBranch: pending.reflectionBranch,
-    commitCount: pending.commitCount,
-    head: pending.head,
-    summary,
-    error: error54
+    primaryRoot: worktree.worktreeDir,
+    writableRoots: [
+      worktree.worktreeDir,
+      worktree.parentMemoryDir,
+      worktree.gitCommonDir
+    ],
+    readonlyRoots: []
   };
 }
 function reflectionIntegrationConsumesTranscript(result) {
-  return result.status === "merged" || result.status === "no_changes" || result.status === "pending_conflict" || result.status === "pending_manual_merge";
-}
-function reflectionIntegrationNeedsReminder(result) {
-  return result.status === "pending_conflict" || result.status === "pending_manual_merge";
+  return result.status === "merged" || result.status === "no_changes";
 }
 function reflectionIntegrationShouldRecompile(result) {
   return result.status === "merged";
@@ -443947,6 +444212,9 @@ async function getStatusPorcelain(cwd2) {
   const { stdout } = await runGit4(cwd2, ["status", "--porcelain"]);
   return stdout.trim();
 }
+async function reflectionMemoryParentHasChanges(parentMemoryDir) {
+  return (await getStatusPorcelain(resolve31(parentMemoryDir))).length > 0;
+}
 async function getCommitCount(worktree) {
   const { stdout } = await runGit4(worktree.worktreeDir, [
     "rev-list",
@@ -443960,131 +444228,12 @@ async function getHead(cwd2) {
   const head2 = result?.stdout.trim();
   return head2 || undefined;
 }
-async function getBranchCommitCount(parentMemoryDir, branchName) {
-  const result = await tryRunGit(parentMemoryDir, [
-    "rev-list",
-    "--count",
-    `HEAD..${branchName}`
-  ]);
-  return Number.parseInt(result?.stdout.trim() ?? "", 10) || 0;
-}
-function parseWorktreeListPorcelain(output) {
-  const entries = [];
-  for (const block of output.split(/\n\s*\n/)) {
-    const entry = {};
-    for (const line of block.split(`
-`)) {
-      const separatorIndex = line.indexOf(" ");
-      const key2 = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
-      const value = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
-      if (key2 === "worktree")
-        entry.path = value;
-      if (key2 === "HEAD")
-        entry.head = value;
-      if (key2 === "branch")
-        entry.branch = value;
-    }
-    if (!entry.path)
-      continue;
-    entries.push({
-      path: entry.path,
-      ...entry.head ? { head: entry.head } : {},
-      ...entry.branch ? { branch: entry.branch } : {}
-    });
-  }
-  return entries;
-}
-async function listPendingReflectionMemoryWorktrees(parentMemoryDir) {
-  const resolvedParent = await realpath4(resolve31(parentMemoryDir));
-  const worktreeBaseDir = join61(dirname26(resolvedParent), "memory-worktrees");
-  const worktreeList = await tryRunGit(resolvedParent, [
-    "worktree",
-    "list",
-    "--porcelain"
-  ]);
-  if (!worktreeList)
-    return [];
-  const pending = [];
-  for (const entry of parseWorktreeListPorcelain(worktreeList.stdout)) {
-    const worktreeDir = normalizeGitPath(entry.path, resolvedParent);
-    const relativeWorktreeDir = relative9(worktreeBaseDir, worktreeDir);
-    if (relativeWorktreeDir.startsWith("..") || isAbsolute25(relativeWorktreeDir))
-      continue;
-    const branchName = entry.branch?.startsWith("refs/heads/") ? entry.branch.slice("refs/heads/".length) : undefined;
-    if (!branchName?.startsWith("letta/reflection/"))
-      continue;
-    const isMerged = await tryRunGit(resolvedParent, [
-      "merge-base",
-      "--is-ancestor",
-      branchName,
-      "HEAD"
-    ]);
-    if (isMerged) {
-      await cleanupWorktreeAndBranch(resolvedParent, worktreeDir, branchName, {
-        force: true
-      });
-      debugLog("memfs-git", "reflection pending scan cleaned already-merged branch=%s worktree=%s", branchName, worktreeDir);
-      continue;
-    }
-    pending.push({
-      id: branchName.slice("letta/reflection/".length),
-      parentMemoryDir: resolvedParent,
-      reflectionWorktreeDir: worktreeDir,
-      reflectionBranch: branchName,
-      commitCount: await getBranchCommitCount(resolvedParent, branchName),
-      head: entry.head
-    });
-  }
-  if (pending.length > 0) {
-    debugLog("memfs-git", "reflection pending scan found=%d parent=%s branches=%s", pending.length, resolvedParent, pending.map((entry) => entry.reflectionBranch).join(","));
-  }
-  return pending;
-}
-async function integratePendingReflectionMemoryWorktrees(parentMemoryDir) {
-  const pendingWorktrees = await listPendingReflectionMemoryWorktrees(parentMemoryDir);
-  const unresolved = [];
-  for (const pending of pendingWorktrees) {
-    const isMerged = await tryRunGit(pending.parentMemoryDir, [
-      "merge-base",
-      "--is-ancestor",
-      pending.reflectionBranch,
-      "HEAD"
-    ]);
-    if (isMerged) {
-      await cleanupWorktreeAndBranch(pending.parentMemoryDir, pending.reflectionWorktreeDir, pending.reflectionBranch, { force: true });
-      debugLog("memfs-git", "reflection pending integration cleaned already-merged branch=%s worktree=%s", pending.reflectionBranch, pending.reflectionWorktreeDir);
-      continue;
-    }
-    const worktreeStatus = await getStatusPorcelain(pending.reflectionWorktreeDir);
-    if (worktreeStatus.length > 0) {
-      unresolved.push(buildPendingResultFromPending(pending, "pending_manual_merge", "A previously unresolved reflection memory worktree has uncommitted changes. Background merge was deferred."));
-      debugLog("memfs-git", "reflection pending integration deferred branch=%s reason=worktree_dirty worktree=%s", pending.reflectionBranch, pending.reflectionWorktreeDir);
-      continue;
-    }
-    const parentStatus = await getStatusPorcelain(pending.parentMemoryDir);
-    if (parentStatus.length > 0) {
-      unresolved.push(buildPendingResultFromPending(pending, "pending_manual_merge", "A previously unresolved reflection memory worktree is still unmerged, and the parent memory repo has uncommitted changes. Background merge was deferred."));
-      debugLog("memfs-git", "reflection pending integration deferred branch=%s reason=parent_dirty", pending.reflectionBranch);
-      continue;
-    }
-    const mergeMessage = await buildReflectionMergeMessage(pending.parentMemoryDir, pending.reflectionBranch);
-    const mergeResult = await tryRunGit(pending.parentMemoryDir, [
-      "merge",
-      pending.reflectionBranch,
-      "-m",
-      mergeMessage
-    ]);
-    if (!mergeResult) {
-      await tryRunGit(pending.parentMemoryDir, ["merge", "--abort"]);
-      unresolved.push(buildPendingResultFromPending(pending, "pending_conflict", "A previously unresolved reflection memory worktree still has conflicts. The parent merge was aborted and the reflection worktree was preserved."));
-      debugLog("memfs-git", "reflection pending integration conflicted branch=%s mergeAbort=true preservedWorktree=%s", pending.reflectionBranch, pending.reflectionWorktreeDir);
-      continue;
-    }
-    const mergedHead = await getHead(pending.parentMemoryDir);
-    await cleanupWorktreeAndBranch(pending.parentMemoryDir, pending.reflectionWorktreeDir, pending.reflectionBranch, { force: true });
-    debugLog("memfs-git", "reflection pending integration merged branch=%s commitCount=%d parentHead=%s cleanedUp=true", pending.reflectionBranch, pending.commitCount, mergedHead ?? "<none>");
-  }
-  return unresolved;
+async function inspectReflectionMemoryWorktree(worktree) {
+  return {
+    commitCount: await getCommitCount(worktree),
+    dirty: (await getStatusPorcelain(worktree.worktreeDir)).length > 0,
+    head: await getHead(worktree.worktreeDir)
+  };
 }
 async function cleanupWorktreeAndBranch(parentMemoryDir, worktreeDir, branchName, options3 = {}) {
   const removedWorktree = existsSync46(worktreeDir);
@@ -444102,19 +444251,28 @@ async function cleanupWorktreeAndBranch(parentMemoryDir, worktreeDir, branchName
     branchName
   ]);
 }
-function buildPendingManualResult(worktree, commitCount, summary, options3 = {}) {
-  return {
-    status: "pending_manual_merge",
-    parentMemoryDir: worktree.parentMemoryDir,
-    reflectionWorktreeDir: worktree.worktreeDir,
-    reflectionBranch: worktree.branchName,
-    commitCount,
-    head: options3.head,
-    summary,
-    error: options3.error
-  };
-}
-async function finalizeReflectionMemoryWorktree(worktree, options3) {
+async function finalizeReflectionMemoryWorktreeImpl(worktree, options3) {
+  if (!existsSync46(worktree.worktreeDir) && options3.knownNoChanges) {
+    const branchHead = (await tryRunGit(worktree.parentMemoryDir, [
+      "rev-parse",
+      "--verify",
+      worktree.branchName
+    ]))?.stdout.trim();
+    if (branchHead && branchHead !== worktree.baseHead) {
+      throw new Error(`Cannot finalize missing reflection worktree ${worktree.worktreeDir} as no-op: ${worktree.branchName} advanced from ${worktree.baseHead} to ${branchHead}`);
+    }
+    await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName, { force: true });
+    debugLog("memfs-git", "reflection finalized id=%s status=no_changes worktreeMissing=true cleanedUp=true", worktree.id);
+    return {
+      status: "no_changes",
+      parentMemoryDir: worktree.parentMemoryDir,
+      reflectionWorktreeDir: worktree.worktreeDir,
+      reflectionBranch: worktree.branchName,
+      commitCount: 0,
+      head: worktree.baseHead,
+      summary: "Reflection made no memory commits."
+    };
+  }
   const commitCount = await getCommitCount(worktree);
   const status = await getStatusPorcelain(worktree.worktreeDir);
   const head2 = await getHead(worktree.worktreeDir);
@@ -444131,6 +444289,19 @@ async function finalizeReflectionMemoryWorktree(worktree, options3) {
       summary: "Reflection memory worktree had uncommitted changes; it was cleaned up so the transcript can be retried."
     };
   }
+  if (!options3.shouldMerge) {
+    await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName, { force: true });
+    debugLog("memfs-git", "reflection finalized id=%s status=failed commitCount=%d cleanedUp=true retryable=true", worktree.id, commitCount);
+    return {
+      status: "failed",
+      parentMemoryDir: worktree.parentMemoryDir,
+      reflectionWorktreeDir: worktree.worktreeDir,
+      reflectionBranch: worktree.branchName,
+      commitCount,
+      head: head2,
+      summary: "Reflection subagent did not complete successfully; the worktree was cleaned up so the transcript can be retried."
+    };
+  }
   if (commitCount === 0) {
     await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName);
     debugLog("memfs-git", "reflection finalized id=%s status=no_changes cleanedUp=true", worktree.id);
@@ -444144,23 +444315,52 @@ async function finalizeReflectionMemoryWorktree(worktree, options3) {
       summary: "Reflection made no memory commits."
     };
   }
-  if (!options3.shouldMerge) {
+  const parentStatus = await getStatusPorcelain(worktree.parentMemoryDir);
+  if (parentStatus.length > 0) {
     await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName, { force: true });
-    debugLog("memfs-git", "reflection finalized id=%s status=failed commitCount=%d cleanedUp=true retryable=true", worktree.id, commitCount);
+    debugLog("memfs-git", "reflection finalized id=%s status=parent_dirty commitCount=%d cleanedUp=true retryable=true", worktree.id, commitCount);
     return {
-      status: "failed",
+      status: "parent_dirty",
       parentMemoryDir: worktree.parentMemoryDir,
       reflectionWorktreeDir: worktree.worktreeDir,
       reflectionBranch: worktree.branchName,
       commitCount,
       head: head2,
-      summary: "Reflection produced committed memory updates, but the subagent did not complete successfully; the worktree was cleaned up so the transcript can be retried."
+      summary: "Reflection produced memory updates, but the parent memory repo had uncommitted changes; the worktree was cleaned up so the transcript can be retried."
     };
   }
-  const parentStatus = await getStatusPorcelain(worktree.parentMemoryDir);
-  if (parentStatus.length > 0) {
-    debugLog("memfs-git", "reflection finalized id=%s status=pending_manual_merge reason=parent_dirty branch=%s preservedWorktree=%s", worktree.id, worktree.branchName, worktree.worktreeDir);
-    return buildPendingManualResult(worktree, commitCount, "Reflection produced memory updates, but the parent memory repo has uncommitted changes. Merge was deferred.", { head: head2 });
+  if (options3.requireAlreadyMerged) {
+    const alreadyMerged = await tryRunGit(worktree.parentMemoryDir, [
+      "merge-base",
+      "--is-ancestor",
+      worktree.branchName,
+      "HEAD"
+    ]);
+    if (!alreadyMerged) {
+      await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName, { force: true });
+      return {
+        status: "failed",
+        parentMemoryDir: worktree.parentMemoryDir,
+        reflectionWorktreeDir: worktree.worktreeDir,
+        reflectionBranch: worktree.branchName,
+        commitCount,
+        head: head2,
+        failurePhase: "integration",
+        summary: options3.failureSummary ?? "The primary-agent integration conversation did not merge the reflection branch; the worktree was cleaned up so the transcript can be retried."
+      };
+    }
+    const mergedHead2 = await getHead(worktree.parentMemoryDir);
+    await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName);
+    debugLog("memfs-git", "reflection finalized id=%s status=merged integration=primary_agent commitCount=%d parentHead=%s cleanedUp=true", worktree.id, commitCount, mergedHead2 ?? "<none>");
+    return {
+      status: "merged",
+      parentMemoryDir: worktree.parentMemoryDir,
+      reflectionWorktreeDir: worktree.worktreeDir,
+      reflectionBranch: worktree.branchName,
+      commitCount,
+      head: mergedHead2,
+      summary: `Primary agent integrated ${commitCount} reflection memory commit(s).`
+    };
   }
   debugLog("memfs-git", "reflection merge attempt id=%s branch=%s parent=%s commitCount=%d", worktree.id, worktree.branchName, worktree.parentMemoryDir, commitCount);
   const mergeMessage = await buildReflectionMergeMessage(worktree.parentMemoryDir, worktree.branchName);
@@ -444172,15 +444372,16 @@ async function finalizeReflectionMemoryWorktree(worktree, options3) {
   ]);
   if (!mergeResult) {
     await tryRunGit(worktree.parentMemoryDir, ["merge", "--abort"]);
-    debugLog("memfs-git", "reflection finalized id=%s status=pending_conflict branch=%s mergeAbort=true preservedWorktree=%s", worktree.id, worktree.branchName, worktree.worktreeDir);
+    await cleanupWorktreeAndBranch(worktree.parentMemoryDir, worktree.worktreeDir, worktree.branchName, { force: true });
+    debugLog("memfs-git", "reflection finalized id=%s status=merge_conflict commitCount=%d mergeAbort=true cleanedUp=true retryable=true", worktree.id, commitCount);
     return {
-      status: "pending_conflict",
+      status: "merge_conflict",
       parentMemoryDir: worktree.parentMemoryDir,
       reflectionWorktreeDir: worktree.worktreeDir,
       reflectionBranch: worktree.branchName,
       commitCount,
       head: head2,
-      summary: "Reflection produced memory updates, but merging them into the parent memory repo has conflicts. The parent merge was aborted and the reflection worktree was preserved for manual merge."
+      summary: "Reflection produced memory updates, but merging them into the parent memory repo conflicted; the worktree was cleaned up so the transcript can be retried."
     };
   }
   const mergedHead = await getHead(worktree.parentMemoryDir);
@@ -444196,6 +444397,9 @@ async function finalizeReflectionMemoryWorktree(worktree, options3) {
     summary: `Merged ${commitCount} reflection memory commit(s) into parent memory main.`
   };
 }
+async function finalizeReflectionMemoryWorktree(worktree, options3) {
+  return await finalizeReflectionMemoryWorktreeImpl(worktree, options3);
+}
 var execFile13, GIT_TIMEOUT_MS = 30000, HARNESS_GIT_ENV;
 var init_memory_worktree = __esm(() => {
   init_memory_git_signing();
@@ -444268,6 +444472,43 @@ var init_memory_subagent_completion = __esm(() => {
   init_system_prompt_warning();
 });
 
+// src/cli/helpers/reflection-integration.ts
+function buildReflectionIntegrationConversationTitle(reflectionSubagentId) {
+  return reflectionSubagentId ? `Reflection integration (reflection ${reflectionSubagentId})` : "Reflection integration";
+}
+function buildReflectionIntegrationPrompt(params) {
+  const instructions = params.instructions?.trim();
+  return `Integrate proposed reflection changes into your memory.
+
+The user configured explicit handling for reflection merges. You are responsible for the entire integration. Work autonomously in this separate conversation; do not interrupt or add messages to the original conversation.
+
+Reflection worktree: ${params.worktree.worktreeDir}
+Your memory repository: ${params.worktree.parentMemoryDir}
+Reflection branch: ${params.worktree.branchName}
+Reflection base commit: ${params.worktree.baseHead}
+Original reflection subagent ID: ${params.reflectionSubagentId ?? "unavailable"}
+
+Work in the reflection worktree while refining the proposal. Start directly by checking both repository states and the proposed diff in one combined shell call; do not create a task plan or spend turns narrating routine Git checks.
+
+Review the proposal for accuracy, placement, precision, and consistency with existing memory, then make any needed edits. If no edits are needed, do not create another commit. If you edit the proposal, stage only those files and create one follow-up commit on top of the reflection commit; do not amend. Use the subject \`merge(reflection): <concise summary>\`.${params.reflectionSubagentId ? ` Include the trailer \`Reflection-Subagent-ID: ${params.reflectionSubagentId}\`.` : ""}
+
+Before merging, incorporate the latest committed memory repository HEAD into the reflection branch and resolve conflicts yourself while preserving the intended memory state. If the memory repository has pre-existing uncommitted changes, leave them completely untouched—do not modify, stash, commit, or discard them—and stop the integration.
+
+Merge the completed reflection branch into your memory repository without pushing, then verify both repositories are clean. Do not remove the worktree or branch; the harness performs final verification and cleanup.
+
+Do not ask the user questions or wait for input. Handle the integration as far as you safely can and explain any remaining blocker in your final response. If integration remains incomplete, the harness will clean up this proposal without consuming the source transcript so reflection can retry later.
+
+${instructions ? `## IMPORTANT: Additional reflection merge instructions from the user
+
+The user explicitly configured the following instructions for this integration. Follow them carefully:
+
+<reflection-merge-instructions>
+${instructions}
+</reflection-merge-instructions>
+
+` : ""}When finished, provide a concise normal summary of what you reviewed, changed, and merged.`;
+}
+
 // src/telemetry/reflection-threshold-feedback.ts
 import { randomUUID as randomUUID25 } from "node:crypto";
 async function resolveFeedbackApiKey() {
@@ -444283,6 +444524,18 @@ function getFeedbackDeviceId() {
   } catch {}
   return randomUUID25();
 }
+function getAlertDeviceType() {
+  switch (process.platform) {
+    case "darwin":
+      return "macOS";
+    case "win32":
+      return "Windows";
+    case "linux":
+      return "Linux";
+    default:
+      return process.platform;
+  }
+}
 function getAlertReasonDescriptions(alertReasons) {
   return alertReasons.map((reason) => {
     switch (reason) {
@@ -444323,6 +444576,10 @@ function maybeSendReflectionThresholdFeedback(options3) {
       feature: "letta-code",
       agent_id: agentId,
       session_id: telemetry.getSessionId(),
+      version: getVersion(),
+      platform: process.platform,
+      device_type: getAlertDeviceType(),
+      node_version: process.version,
       total_wall_ms: options3.durationMs,
       step_count: options3.stepCount,
       agent_name: options3.parentAgentName ?? undefined,
@@ -444350,6 +444607,7 @@ var init_reflection_threshold_feedback = __esm(() => {
   init_metadata();
   init_settings_manager();
   init_telemetry();
+  init_version();
   REFLECTION_DURATION_THRESHOLD_MS = 10 * 60 * 1000;
 });
 
@@ -444359,10 +444617,11 @@ __export(exports_reflection_launcher, {
   tryReserveReflectionLaunch: () => tryReserveReflectionLaunch,
   shouldRunQueuedReflectionLaunch: () => shouldRunQueuedReflectionLaunch,
   releaseReflectionLaunch: () => releaseReflectionLaunch,
-  queuePendingReflectionWorktreeReminders: () => queuePendingReflectionWorktreeReminders,
   prepareReflectionMemoryWorktreeLaunch: () => prepareReflectionMemoryWorktreeLaunch,
   launchReflectionSubagent: () => launchReflectionSubagent,
-  formatReflectionIntegrationReminder: () => formatReflectionIntegrationReminder,
+  getReflectionMergeLaunchOptions: () => getReflectionMergeLaunchOptions,
+  getReflectionLaunchSkippedMessage: () => getReflectionLaunchSkippedMessage,
+  getReflectionFinalizationContext: () => getReflectionFinalizationContext,
   finalizeReflectionMemoryWorktreeLaunch: () => finalizeReflectionMemoryWorktreeLaunch,
   emitReflectionRunStart: () => emitReflectionRunStart,
   emitReflectionRunEnd: () => emitReflectionRunEnd,
@@ -444370,11 +444629,56 @@ __export(exports_reflection_launcher, {
   REFLECTION_AGENT_ID_WAIT_MS: () => REFLECTION_AGENT_ID_WAIT_MS,
   AUTO_REFLECTION_DESCRIPTION: () => AUTO_REFLECTION_DESCRIPTION
 });
+function getReflectionMergeLaunchOptions(agentId) {
+  const settings3 = getReflectionSettings(agentId);
+  return {
+    mergePolicy: settings3.merge ?? "auto",
+    mergeInstructions: settings3.mergeInstructions
+  };
+}
+function getReflectionFinalizationContext(agentId) {
+  return {
+    agentId,
+    ...getReflectionMergeLaunchOptions(agentId)
+  };
+}
+function getReflectionLaunchSkippedMessage(reason, surface = "cli") {
+  switch (reason) {
+    case "already_active":
+      return surface === "listener" ? "A reflection agent is already running for this conversation." : "A reflection agent is already running in the background.";
+    case "memfs_disabled":
+      return surface === "listener" ? "Reflection needs the memory filesystem to be enabled for this agent. Use /remember for a lightweight memory update instead." : "Memory filesystem is not enabled. Use /remember instead.";
+    case "no_payload":
+      return surface === "listener" ? "No new transcript content to reflect on for this conversation." : "No new transcript content to reflect on.";
+    case "parent_dirty":
+      return "Parent memory has uncommitted changes; commit or discard them before reflecting.";
+    case "error":
+      return;
+  }
+}
 function drainReflectionTelemetry() {
   telemetry.drain().catch((error54) => {
     debugWarn("telemetry", `Failed to flush reflection telemetry: ${error54 instanceof Error ? error54.message : String(error54)}`);
   });
 }
+function getReflectionWorktreeCleanupOutcome(integration) {
+  switch (integration.status) {
+    case "parent_dirty":
+      return { outcome: "parent_dirty", integrationStatus: "parent_dirty" };
+    case "merge_conflict":
+      return { outcome: "merge_conflict", integrationStatus: "merge_conflict" };
+    case "dirty_uncommitted":
+      return {
+        outcome: "reflection_worktree_dirty",
+        integrationStatus: "dirty_uncommitted"
+      };
+    case "failed":
+      return { outcome: "subagent_failed", integrationStatus: "failed" };
+    case "merged":
+    case "no_changes":
+      return;
+  }
+}
 function emitReflectionRunStart(params) {
   telemetry.trackReflectionStart(params.triggerSource, {
     subagentId: params.subagentId,
@@ -444392,7 +444696,7 @@ function emitReflectionRunEnd(params) {
     error: params.error,
     stepCount: params.stepCount,
     durationMs: params.durationMs,
-    model: params.feedbackContext?.model
+    model: params.model
   });
   drainReflectionTelemetry();
   maybeSendReflectionThresholdFeedback({
@@ -444407,7 +444711,7 @@ function emitReflectionRunEnd(params) {
     stepCount: params.stepCount,
     durationMs: params.durationMs,
     surface: params.feedbackContext?.surface,
-    model: params.feedbackContext?.model
+    model: params.model
   });
 }
 function isReflectionSubagentActiveForAgent(agentId) {
@@ -444480,84 +444784,64 @@ function getReflectionCompletionMessage(integration) {
       return;
     case "no_changes":
       return ({ action: action3 }) => `${action3}; no durable memory changes were needed.`;
-    case "pending_conflict":
-      return ({ action: action3 }) => `${action3}; memory merge will finish after conflicts are resolved.`;
-    case "pending_manual_merge":
-      return ({ action: action3 }) => `${action3}; memory merge will finish after pending memory changes are resolved.`;
+    case "parent_dirty":
+      return "Tried to reflect, but parent memory had uncommitted changes; will retry later.";
+    case "merge_conflict":
+      return "Tried to reflect, but memory updates conflicted with newer changes; will retry later.";
     case "dirty_uncommitted":
       return "Tried to reflect, but memory changes were not committed cleanly; will retry later.";
     case "failed":
-      return "Tried to reflect, but memory updates were not completed cleanly; will retry later.";
+      return integration.failurePhase === "integration" ? `${integration.summary} Will retry later.` : "Tried to reflect, but memory updates were not completed cleanly; will retry later.";
   }
 }
-function escapeTaskNotificationSummary(summary) {
-  return summary.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function formatReflectionIntegrationNotification(reminder) {
-  return `<task-notification>
-<summary>${escapeTaskNotificationSummary("Memory reflection merge is pending.")}</summary>
-<result>
-${reminder}
-</result>
-</task-notification>`;
-}
-function formatReflectionIntegrationReminder(integration) {
-  const resolveCommands = `cd ${JSON.stringify(integration.parentMemoryDir)}
-git status
-reflection_branch=${JSON.stringify(integration.reflectionBranch)}
-reflection_subject=$(git log -1 --pretty=%s "$reflection_branch")
-reflection_summary=$(printf '%s' "$reflection_subject" | sed -E 's/^[a-z]+(\\([^)]+\\))?!?:[[:space:]]*//I')
-merge_message="merge(reflection): \${reflection_summary:-reflection memory updates}"
-# If parent MemFS has unrelated changes, inspect changes, then commit or discard them.
-# Then merge the reflection branch and resolve conflicts if prompted:
-git merge "$reflection_branch" -m "$merge_message" || {
-  git status
-  echo "Resolve conflicted memory files, then stage specific resolved files and run: git commit --no-edit"
-  exit 1
-}
-
-git worktree remove ${JSON.stringify(integration.reflectionWorktreeDir)}
-git branch -d "$reflection_branch"`;
-  const reminder = `${SYSTEM_REMINDER_OPEN}
-BACKGROUND MEMORY MAINTENANCE: A reflection memory merge is pending.
-
-A background reflection completed and produced committed memory updates, but the harness could not merge them into your main MemFS automatically.
-
-Do not interrupt the user's current request just because of this reminder, and do not invoke a skill solely because this reminder arrived. If you are already responding to the user, finish that response first. Resolve this later when appropriate, or when the user asks you to handle pending memory merges.
-
-Parent memory dir: ${integration.parentMemoryDir}
-Reflection branch: ${integration.reflectionBranch}
-Reflection worktree: ${integration.reflectionWorktreeDir}
-Status: ${integration.summary}
-
-When you decide to resolve it, use standard git commands like:
-\`\`\`bash
-${resolveCommands}
-\`\`\`
-
-This reminder is one-time. The transcript was already reflected, so do not launch another reflection for the same content just to resolve this merge.
-${SYSTEM_REMINDER_CLOSE}`;
-  return formatReflectionIntegrationNotification(reminder);
-}
-function queueReflectionIntegrationReminder(params) {
-  addToMessageQueue({
-    kind: "task_notification",
-    text: formatReflectionIntegrationReminder(params.integration),
-    agentId: params.agentId,
-    conversationId: params.conversationId
+async function runExplicitReflectionIntegration(params) {
+  const {
+    spawnBackgroundSubagentTask: spawnBackgroundSubagentTask2,
+    waitForBackgroundSubagentConversationId: waitForBackgroundSubagentConversationId2
+  } = await Promise.resolve().then(() => (init_task(), exports_task));
+  return await new Promise((resolve32) => {
+    try {
+      const { subagentId } = spawnBackgroundSubagentTask2({
+        subagentType: "general-purpose",
+        displayType: "reflection integration",
+        prompt: buildReflectionIntegrationPrompt({
+          worktree: params.worktree,
+          instructions: params.instructions,
+          reflectionSubagentId: params.reflectionSubagentId
+        }),
+        description: "Integrate reflection memory changes",
+        existingAgentId: params.agentId,
+        memoryScope: buildReflectionIntegrationMemoryScope(params.worktree),
+        parentScope: {
+          agentId: params.agentId,
+          conversationId: params.conversationId
+        },
+        silentCompletion: true,
+        onComplete: (result) => {
+          resolve32({
+            success: result.success,
+            error: result.success ? undefined : result.error ?? "Reflection integration did not complete",
+            conversationId: result.conversationId
+          });
+        }
+      });
+      waitForBackgroundSubagentConversationId2(subagentId, REFLECTION_AGENT_ID_WAIT_MS).then(async (conversationId) => {
+        if (!conversationId)
+          return;
+        await getBackend().updateConversation(conversationId, {
+          summary: buildReflectionIntegrationConversationTitle(params.reflectionSubagentId)
+        });
+      }).catch((error54) => {
+        debugWarn("memory", `Failed to title reflection integration conversation: ${error54 instanceof Error ? error54.message : String(error54)}`);
+      });
+    } catch (error54) {
+      resolve32({
+        success: false,
+        error: error54 instanceof Error ? error54.message : String(error54)
+      });
+    }
   });
 }
-async function queuePendingReflectionWorktreeReminders(params) {
-  const memoryDir = getScopedMemoryFilesystemRoot(params.agentId);
-  const unresolvedIntegrations = await integratePendingReflectionMemoryWorktrees(memoryDir);
-  for (const integration of unresolvedIntegrations) {
-    queueReflectionIntegrationReminder({
-      agentId: params.agentId,
-      conversationId: params.conversationId,
-      integration
-    });
-  }
-}
 async function prepareReflectionMemoryWorktreeLaunch(params) {
   const memoryDir = getScopedMemoryFilesystemRoot(params.agentId);
   const worktree = await createReflectionMemoryWorktree({
@@ -444577,16 +444861,39 @@ async function prepareReflectionMemoryWorktreeLaunch(params) {
   }
 }
 async function finalizeReflectionMemoryWorktreeLaunch(params) {
+  let integrationRun;
+  if (params.subagentSuccess && params.mergePolicy === "explicit") {
+    const state = params.knownNoChanges ? { commitCount: 0, dirty: false } : await inspectReflectionMemoryWorktree(params.worktree);
+    if (state.commitCount > 0 || state.dirty) {
+      integrationRun = await (params.runExplicitIntegration ?? runExplicitReflectionIntegration)({
+        agentId: params.agentId,
+        conversationId: params.conversationId,
+        worktree: params.worktree,
+        instructions: params.mergeInstructions,
+        reflectionSubagentId: params.subagentAgentId
+      });
+    }
+  }
   const integration = await finalizeReflectionMemoryWorktree(params.worktree, {
-    shouldMerge: params.subagentSuccess
+    shouldMerge: params.subagentSuccess,
+    knownNoChanges: params.knownNoChanges,
+    requireAlreadyMerged: params.mergePolicy === "explicit" && integrationRun !== undefined,
+    failureSummary: integrationRun?.error ? `Reflection integration did not complete (${integrationRun.error}); the worktree was cleaned up so the transcript can be retried.` : undefined
   });
   const completionSuccess = params.subagentSuccess && reflectionIntegrationConsumesTranscript(integration);
-  if (reflectionIntegrationNeedsReminder(integration)) {
-    queueReflectionIntegrationReminder({
-      agentId: params.agentId,
-      conversationId: params.conversationId,
-      integration
+  const cleanup = getReflectionWorktreeCleanupOutcome(integration);
+  if (cleanup) {
+    telemetry.trackReflectionWorktreeCleanup({
+      outcome: cleanup.outcome,
+      integration_status: cleanup.integrationStatus,
+      trigger_source: params.telemetryContext?.triggerSource,
+      subagent_id: params.subagentAgentId,
+      conversation_id: params.conversationId,
+      reflection_worktree_id: params.worktree.id,
+      commit_count: integration.commitCount,
+      model: params.model ?? undefined
     });
+    drainReflectionTelemetry();
   }
   const completionMessage = await handleMemorySubagentCompletion({
     agentId: params.agentId,
@@ -444602,7 +444909,27 @@ async function finalizeReflectionMemoryWorktreeLaunch(params) {
     recompileQueuedByConversation: params.recompileQueuedByConversation,
     logRecompileFailure: params.logRecompileFailure
   });
-  return { integration, completionSuccess, completionMessage };
+  if (completionSuccess && integrationRun?.conversationId) {
+    try {
+      const body3 = {
+        summary: buildReflectionIntegrationConversationTitle(params.subagentAgentId),
+        archived: true
+      };
+      if (params.updateIntegrationConversation) {
+        await params.updateIntegrationConversation(integrationRun.conversationId, body3);
+      } else {
+        await getBackend().updateConversation(integrationRun.conversationId, body3);
+      }
+    } catch (error54) {
+      debugWarn("memory", `Failed to archive reflection integration conversation: ${error54 instanceof Error ? error54.message : String(error54)}`);
+    }
+  }
+  return {
+    integration,
+    completionSuccess,
+    completionMessage,
+    integrationConversationId: integrationRun?.conversationId
+  };
 }
 async function launchReflectionSubagent(options3) {
   const {
@@ -444615,19 +444942,10 @@ async function launchReflectionSubagent(options3) {
     recompileQueuedByConversation,
     onCompletionMessage
   } = options3;
+  const reflectionSettings = options3.reflectionSettings ?? getReflectionSettings(agentId);
   if (!memfsEnabled) {
     return { launched: false, reason: "memfs_disabled" };
   }
-  if (triggerSource === "compaction-event" && !options3.skipPendingWorktreeReminderScan) {
-    try {
-      await queuePendingReflectionWorktreeReminders({
-        agentId,
-        conversationId
-      });
-    } catch (error54) {
-      debugWarn("memory", "Failed to queue pending reflection worktree reminders after compaction:", error54 instanceof Error ? error54.message : String(error54));
-    }
-  }
   if (!tryReserveReflectionLaunch(agentId)) {
     debugLog("memory", `Skipping reflection launch (${triggerSource}) because one is already active`);
     if (reservedReflectionAgentIds.has(agentId)) {
@@ -444638,6 +444956,12 @@ async function launchReflectionSubagent(options3) {
   let releaseOnComplete = false;
   let preparedWorktree;
   try {
+    const memoryDir = getScopedMemoryFilesystemRoot(agentId);
+    if (await reflectionMemoryParentHasChanges(memoryDir)) {
+      debugLog("memory", `Skipping reflection launch (${triggerSource}) because parent memory has uncommitted changes`);
+      releaseReflectionLaunch(agentId);
+      return { launched: false, reason: "parent_dirty" };
+    }
     const autoPayload = await buildAutoReflectionPayload(agentId, conversationId);
     if (!autoPayload) {
       debugLog("memory", `Skipping reflection launch (${triggerSource}) because transcript has no new content`);
@@ -444658,7 +444982,7 @@ async function launchReflectionSubagent(options3) {
         conversationId,
         startMessageId: autoPayload.startMessageId,
         endMessageId: autoPayload.endMessageId,
-        model: options3.feedbackContext?.model
+        model: options3.model
       });
     };
     const { subagentId } = spawnBackgroundSubagentTask2({
@@ -444675,6 +444999,7 @@ async function launchReflectionSubagent(options3) {
         success: success2,
         error: error54,
         agentId: reflectionAgentId,
+        model: reflectionModel,
         stepCount,
         durationMs
       }) => {
@@ -444688,16 +445013,25 @@ async function launchReflectionSubagent(options3) {
             error: error54,
             stepCount,
             durationMs,
+            model: reflectionModel,
             feedbackContext: options3.feedbackContext
           });
           const completionConversationId = resolveCompletionConversationId(options3.completionConversationId, conversationId);
-          const { completionSuccess, completionMessage } = await finalizeReflectionMemoryWorktreeLaunch({
+          const {
+            completionSuccess,
+            completionMessage,
+            integrationConversationId
+          } = await finalizeReflectionMemoryWorktreeLaunch({
             worktree,
             subagentSuccess: success2,
             subagentError: error54,
             agentId,
             conversationId: completionConversationId,
             subagentAgentId: reflectionAgentId ?? undefined,
+            model: reflectionModel,
+            mergePolicy: reflectionSettings.merge,
+            mergeInstructions: reflectionSettings.mergeInstructions,
+            telemetryContext: { triggerSource },
             recompileByConversation,
             recompileQueuedByConversation,
             logRecompileFailure: (message) => debugWarn("memory", message)
@@ -444706,7 +445040,8 @@ async function launchReflectionSubagent(options3) {
           await onCompletionMessage?.(completionMessage, {
             success: completionSuccess,
             error: error54,
-            reflectionAgentId: reflectionAgentId ?? undefined
+            reflectionAgentId: reflectionAgentId ?? undefined,
+            integrationConversationId
           });
         } finally {
           releaseReflectionLaunch(agentId);
@@ -444747,14 +445082,13 @@ var init_reflection_launcher = __esm(() => {
   init_memory_filesystem2();
   init_memory_worktree();
   init_subagent_state();
+  init_backend2();
   init_memory_reminder();
   init_memory_subagent_completion();
   init_reflection_transcript();
-  init_constants2();
   init_telemetry();
   init_reflection_threshold_feedback();
   init_debug();
-  init_message_queue_bridge();
   reservedReflectionAgentIds = new Set;
   pendingReflectionLaunches = new Map;
 });
@@ -444938,8 +445272,7 @@ ${targetInstruction}` : targetInstruction;
       });
     },
     feedbackContext: {
-      surface: "letta_code_cli",
-      model: parsed.values.model
+      surface: "letta_code_cli"
     }
   });
   if (!result.launched) {
@@ -444962,6 +445295,9 @@ ${targetInstruction}` : targetInstruction;
       case "memfs_disabled":
         console.error(`Memory filesystem is not enabled for ${agentId}.`);
         return 1;
+      case "parent_dirty":
+        console.error("Parent memory has uncommitted changes; commit or discard them before reflecting.");
+        return 1;
       default: {
         const message = result.error instanceof Error ? result.error.message : String(result.error ?? "Unknown error");
         console.error(`Failed to start reflection pass: ${message}`);
@@ -448563,7 +448899,7 @@ function isSetReflectionSettingsCommand(value) {
     return false;
   }
   const settings3 = c.settings;
-  return (settings3.trigger === "off" || settings3.trigger === "step-count" || settings3.trigger === "compaction-event") && typeof settings3.step_count === "number" && Number.isInteger(settings3.step_count) && settings3.step_count > 0 && (c.scope === undefined || c.scope === "local_project" || c.scope === "global" || c.scope === "both");
+  return (settings3.trigger === "off" || settings3.trigger === "step-count" || settings3.trigger === "compaction-event") && typeof settings3.step_count === "number" && Number.isInteger(settings3.step_count) && settings3.step_count > 0 && (settings3.merge === undefined || settings3.merge === "auto" || settings3.merge === "explicit") && (settings3.merge_instructions === undefined || typeof settings3.merge_instructions === "string") && (c.scope === undefined || c.scope === "local_project" || c.scope === "global" || c.scope === "both");
 }
 function isGetExperimentsCommand(value) {
   if (!value || typeof value !== "object")
@@ -449443,7 +449779,7 @@ __export(exports_memory_scanner, {
   getFileNodes: () => getFileNodes
 });
 import { readdirSync as readdirSync18, readFileSync as readFileSync33, statSync as statSync17 } from "node:fs";
-import { join as join63, relative as relative10 } from "node:path";
+import { join as join63, relative as relative9 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
   const scanDir = (dir, depth, parentIsLast) => {
@@ -449483,7 +449819,7 @@ function scanMemoryFilesystem(memoryRoot) {
       } catch {
         return;
       }
-      const relativePath = relative10(memoryRoot, fullPath).replace(/\\/g, "/");
+      const relativePath = relative9(memoryRoot, fullPath).replace(/\\/g, "/");
       const isLast = index === sorted.length - 1;
       nodes.push({
         name: isDir ? `${name}/` : name,
@@ -449900,14 +450236,14 @@ function handleMemoryProtocolCommand(parsed, context3) {
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
         const { readFile: readFile20 } = await import("node:fs/promises");
         const { existsSync: existsSync48 } = await import("node:fs");
-        const { isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative11, sep: sep7 } = await import("node:path");
+        const { isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative10, sep: sep7 } = await import("node:path");
         if (isAbsolute26(parsed.path) || parsed.path.length === 0) {
           sendFailure("path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
         const absolutePath = normalize5(join64(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const rel = relative10(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute26(rel) || rel.split(sep7).includes("..")) {
           sendFailure("path must resolve inside the memory root");
           return;
@@ -449966,14 +450302,14 @@ function handleMemoryProtocolCommand(parsed, context3) {
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { writeFile: writeFile16, mkdir: mkdir15 } = await import("node:fs/promises");
         const { existsSync: existsSync48 } = await import("node:fs");
-        const { dirname: dirname27, isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative11, sep: sep7 } = await import("node:path");
+        const { dirname: dirname27, isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative10, sep: sep7 } = await import("node:path");
         if (isAbsolute26(parsed.path) || parsed.path.length === 0) {
           sendFailure("write_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
         const absolutePath = normalize5(join64(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const rel = relative10(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute26(rel) || rel.split(sep7).includes("..")) {
           sendFailure("write_memory_file: path must resolve inside the memory root");
           return;
@@ -450064,14 +450400,14 @@ function handleMemoryProtocolCommand(parsed, context3) {
         const { commitMemoryWrite: commitMemoryWrite2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
         const { unlink: unlink6 } = await import("node:fs/promises");
         const { existsSync: existsSync48 } = await import("node:fs");
-        const { isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative11, sep: sep7 } = await import("node:path");
+        const { isAbsolute: isAbsolute26, join: join64, normalize: normalize5, relative: relative10, sep: sep7 } = await import("node:path");
         if (isAbsolute26(parsed.path) || parsed.path.length === 0) {
           sendFailure("delete_memory_file: path must be a non-empty relative path");
           return;
         }
         const memoryRoot = getScopedMemoryFilesystemRoot2(parsed.agent_id);
         const absolutePath = normalize5(join64(memoryRoot, parsed.path));
-        const rel = relative11(memoryRoot, absolutePath);
+        const rel = relative10(memoryRoot, absolutePath);
         if (rel.startsWith("..") || rel === "" || isAbsolute26(rel) || rel.split(sep7).includes("..")) {
           sendFailure("delete_memory_file: path must resolve inside the memory root");
           return;
@@ -451407,7 +451743,9 @@ function toReflectionSettingsResponse(agentId, workingDirectory) {
   return {
     agent_id: agentId,
     trigger: settings3.trigger,
-    step_count: settings3.stepCount
+    step_count: settings3.stepCount,
+    merge: settings3.merge,
+    merge_instructions: settings3.mergeInstructions
   };
 }
 function resolveReflectionSettingsScope(scope) {
@@ -451488,9 +451826,12 @@ async function handleReflectionSettingsCommand(parsed, socket, listener, safeSoc
   }
   const { persistLocalProject, persistGlobal, normalizedScope } = resolveReflectionSettingsScope(parsed.scope);
   try {
+    const currentSettings = getReflectionSettings(agentId, workingDirectory);
     await persistReflectionSettingsForAgent(agentId, {
       trigger: parsed.settings.trigger,
-      stepCount: parsed.settings.step_count
+      stepCount: parsed.settings.step_count,
+      merge: parsed.settings.merge ?? currentSettings.merge,
+      mergeInstructions: parsed.settings.merge_instructions ?? currentSettings.mergeInstructions
     }, {
       workingDirectory,
       persistLocalProject,
@@ -456901,7 +457242,7 @@ var init_diff4 = __esm(() => {
 });
 
 // src/cli/helpers/shell-semantic-display.ts
-import { relative as relative11 } from "node:path";
+import { relative as relative10 } from "node:path";
 function quoteSummaryValue(value) {
   return JSON.stringify(value);
 }
@@ -456968,7 +457309,7 @@ function formatDisplayPath2(filePath) {
     return ".";
   }
   const cwd2 = process.cwd();
-  const relativePath = relative11(cwd2, filePath);
+  const relativePath = relative10(cwd2, filePath);
   if (relativePath === "") {
     return ".";
   }
@@ -457593,13 +457934,13 @@ __export(exports_format_args_display, {
   parsePatchInput: () => parsePatchInput,
   formatArgsDisplay: () => formatArgsDisplay
 });
-import { relative as relative12 } from "node:path";
+import { relative as relative11 } from "node:path";
 function formatItemCount(count) {
   return `${String(count)} item${count === 1 ? "" : "s"}`;
 }
 function formatDisplayPath3(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative12(cwd2, filePath);
+  const relativePath = relative11(cwd2, filePath);
   if (relativePath.startsWith("..")) {
     return filePath;
   }
@@ -458753,7 +459094,7 @@ var init_post_turn_reflection = __esm(() => {
 });
 
 // src/websocket/listener/turn-events.ts
-function escapeTaskNotificationSummary2(summary) {
+function escapeTaskNotificationSummary(summary) {
   return summary.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function isTurnInputArray(value) {
@@ -458818,7 +459159,6 @@ function buildMaybeLaunchReflectionSubagent(params) {
       conversationId,
       memfsEnabled: settingsManager.isMemfsEnabled(agentId),
       triggerSource,
-      skipPendingWorktreeReminderScan: triggerSource === "compaction-event",
       reflectionSettings,
       description: AUTO_REFLECTION_DESCRIPTION,
       recompileByConversation: runtime.listener.systemPromptRecompileByConversation,
@@ -458827,8 +459167,8 @@ function buildMaybeLaunchReflectionSubagent(params) {
         surface: getListenerTelemetrySurface()
       },
       onCompletionMessage: async (completionMessage, reflectionResult) => {
-        const reflectionAgentIdTag = reflectionResult.reflectionAgentId ? `<reflection-agent-id>${escapeTaskNotificationSummary2(reflectionResult.reflectionAgentId)}</reflection-agent-id>` : "";
-        const notificationXml = `<task-notification><summary>${escapeTaskNotificationSummary2(completionMessage)}</summary>${reflectionAgentIdTag}</task-notification>`;
+        const reflectionAgentIdTag = reflectionResult.reflectionAgentId ? `<reflection-agent-id>${escapeTaskNotificationSummary(reflectionResult.reflectionAgentId)}</reflection-agent-id>` : "";
+        const notificationXml = `<task-notification><summary>${escapeTaskNotificationSummary(completionMessage)}</summary>${reflectionAgentIdTag}</task-notification>`;
         emitCanonicalMessageDelta(socket, runtime, {
           type: "message",
           id: `user-msg-${crypto.randomUUID()}`,
@@ -458898,10 +459238,6 @@ async function completeSuccessfulListenerTurn(params) {
       reflectionSettings,
       reminderState: params.runtime.reminderState,
       contextTracker: params.runtime.contextTracker,
-      onCompaction: () => queuePendingReflectionWorktreeReminders({
-        agentId: params.agentId,
-        conversationId: params.conversationId
-      }),
       launch: buildMaybeLaunchReflectionSubagent({
         runtime: params.runtime,
         socket: params.socket,
@@ -458926,7 +459262,6 @@ var init_turn_completion = __esm(async () => {
   init_conversation_description();
   init_memory_reminder();
   init_post_turn_reflection();
-  init_reflection_launcher();
   init_reflection_transcript();
   init_settings_manager();
   init_debug();
@@ -460639,7 +460974,7 @@ var init_turn = __esm(async () => {
 });
 
 // src/websocket/listener/control-inputs.ts
-import { realpath as realpath5, stat as stat13 } from "node:fs/promises";
+import { realpath as realpath4, stat as stat13 } from "node:fs/promises";
 import path38 from "node:path";
 function trackListenerError2(errorType, error54, context3) {
   trackBoundaryError({
@@ -460900,7 +461235,7 @@ async function handleCwdChange(msg, socket, runtime) {
       throw new Error("Working directory cannot be empty");
     }
     const resolvedPath = path38.isAbsolute(requestedPath) ? requestedPath : path38.resolve(currentWorkingDirectory, requestedPath);
-    const normalizedPath = await realpath5(resolvedPath);
+    const normalizedPath = await realpath4(resolvedPath);
     const stats = await stat13(normalizedPath);
     if (!stats.isDirectory()) {
       throw new Error(`Not a directory: ${normalizedPath}`);
@@ -461553,8 +461888,8 @@ function normalizeAbsPath(value) {
   return path40.resolve(value);
 }
 function isWithinOrEqual(parent, child) {
-  const relative14 = path40.relative(parent, child);
-  return relative14 === "" || !relative14.startsWith("..") && !path40.isAbsolute(relative14);
+  const relative13 = path40.relative(parent, child);
+  return relative13 === "" || !relative13.startsWith("..") && !path40.isAbsolute(relative13);
 }
 function getHomeDirectory() {
   return normalizeAbsPath(process.env.HOME || homedir41());
@@ -461567,10 +461902,10 @@ function getProtectedHomeSegment(absPath) {
   const target2 = normalizeAbsPath(absPath);
   if (!isWithinOrEqual(home, target2))
     return null;
-  const relative14 = path40.relative(home, target2);
-  if (!relative14)
+  const relative13 = path40.relative(home, target2);
+  if (!relative13)
     return null;
-  const [firstSegment] = relative14.split(path40.sep);
+  const [firstSegment] = relative13.split(path40.sep);
   const normalized = firstSegment?.toLowerCase();
   return normalized && PROTECTED_HOME_NAMES.has(normalized) ? normalized : null;
 }
@@ -462684,7 +463019,7 @@ var init_init_command = __esm(() => {
 
 // src/cli/helpers/skill-name-frontmatter-repair.ts
 import { readdir as readdir12, readFile as readFile22, stat as stat14, writeFile as writeFile16 } from "node:fs/promises";
-import { basename as basename27, dirname as dirname30, join as join67, relative as relative14 } from "node:path";
+import { basename as basename27, dirname as dirname30, join as join67, relative as relative13 } from "node:path";
 async function pathExists(path41) {
   try {
     await stat14(path41);
@@ -462787,7 +463122,7 @@ async function repairMissingSkillNameFrontmatter(memoryDir) {
     return result;
   }
   for (const skillFile of skillFiles.sort()) {
-    const displayPath = relative14(memoryDir, skillFile).replace(/\\/g, "/");
+    const displayPath = relative13(memoryDir, skillFile).replace(/\\/g, "/");
     result.scanned++;
     try {
       const content = await readFile22(skillFile, "utf8");
@@ -463373,7 +463708,7 @@ async function handleReflectCommand(socket, conversationRuntime) {
     recompileByConversation: listener.systemPromptRecompileByConversation,
     recompileQueuedByConversation: listener.queuedSystemPromptRecompileByConversation,
     onCompletionMessage: async (completionMessage, reflectionResult) => {
-      const reflectionAgentIdTag = reflectionResult.reflectionAgentId ? `<reflection-agent-id>${escapeTaskNotificationSummary2(reflectionResult.reflectionAgentId)}</reflection-agent-id>` : "";
+      const reflectionAgentIdTag = reflectionResult.reflectionAgentId ? `<reflection-agent-id>${escapeTaskNotificationSummary(reflectionResult.reflectionAgentId)}</reflection-agent-id>` : "";
       emitCanonicalMessageDelta(socket, conversationRuntime, {
         type: "message",
         id: `user-msg-${crypto.randomUUID()}`,
@@ -463382,7 +463717,7 @@ async function handleReflectCommand(socket, conversationRuntime) {
         content: [
           {
             type: "text",
-            text: `<task-notification><summary>${escapeTaskNotificationSummary2(completionMessage)}</summary>${reflectionAgentIdTag}</task-notification>`
+            text: `<task-notification><summary>${escapeTaskNotificationSummary(completionMessage)}</summary>${reflectionAgentIdTag}</task-notification>`
           }
         ]
       }, { agent_id: agentId, conversation_id: conversationId });
@@ -471135,8 +471470,8 @@ function isRecord13(value) {
 function isPathInsideOrEqual2(childPath, parentPath) {
   const child = path41.resolve(childPath);
   const parent = path41.resolve(parentPath);
-  const relative15 = path41.relative(parent, child);
-  return relative15 === "" || !!relative15 && !relative15.startsWith("..") && !path41.isAbsolute(relative15);
+  const relative14 = path41.relative(parent, child);
+  return relative14 === "" || !!relative14 && !relative14.startsWith("..") && !path41.isAbsolute(relative14);
 }
 function readPackageJson(packageJsonPath) {
   let parsed;
@@ -472658,7 +472993,22 @@ var init_server = __esm(async () => {
 
 // src/auth/LettaLoginView.tsx
 import { hostname as hostname7 } from "node:os";
+async function completeLettaLogin(tokens, options3) {
+  const settings3 = options3.settings ?? settingsManager;
+  const now = options3.now?.() ?? Date.now();
+  settings3.updateSettings({
+    env: { LETTA_API_KEY: tokens.access_token },
+    refreshToken: tokens.refresh_token,
+    tokenExpiresAt: now + tokens.expires_in * 1000,
+    preferredBackendMode: "api"
+  });
+  await settings3.flush();
+  if (options3.activateCloudBackend) {
+    configureBackendMode("api");
+  }
+}
 function LettaLoginView({
+  activateCloudBackend,
   onComplete,
   onCancel,
   successMessage = "Signed in with Letta. Switch agents with /agents."
@@ -472703,15 +473053,7 @@ function LettaLoginView({
           return;
         }
         const tokens = await pollForToken2(deviceData.device_code, deviceData.interval, deviceData.expires_in, deviceId, deviceName, controller.signal);
-        const now = Date.now();
-        settingsManager.updateSettings({
-          env: { LETTA_API_KEY: tokens.access_token },
-          refreshToken: tokens.refresh_token,
-          tokenExpiresAt: now + tokens.expires_in * 1000,
-          preferredBackendMode: "api"
-        });
-        await settingsManager.flush();
-        configureBackendMode("api");
+        await completeLettaLogin(tokens, { activateCloudBackend });
         setDoneMessage(successMessage);
         setTimeout(() => onCompleteRef.current?.(), 500);
       } catch (err) {
@@ -472726,7 +473068,7 @@ function LettaLoginView({
       cancelledRef.current = true;
       abortControllerRef.current?.abort();
     };
-  }, [successMessage]);
+  }, [activateCloudBackend, successMessage]);
   if (doneMessage) {
     return /* @__PURE__ */ jsx_dev_runtime14.jsxDEV(Box_default, {
       flexDirection: "column",
@@ -472926,6 +473268,7 @@ function SetupUI({
           children: " "
         }, undefined, false, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(LettaLoginView, {
+          activateCloudBackend: true,
           onComplete: () => onComplete({ kind: "cloud-login" }),
           onCancel: () => setMode("menu"),
           successMessage: "Signed in with Letta. Starting Letta Code..."
@@ -473094,6 +473437,252 @@ var init_setup7 = __esm(async () => {
   await init_setup6();
 });
 
+// src/cli/subcommands/shared-memory.ts
+import { existsSync as existsSync57 } from "node:fs";
+import { join as join72 } from "node:path";
+import { parseArgs as parseArgs14 } from "node:util";
+function printUsage12() {
+  console.log(`
+Usage:
+  letta shared-memory list [--agent <id>]
+  letta shared-memory create --name <name>
+  letta shared-memory attach <name-or-id> [--agent <id>]
+  letta shared-memory detach <name-or-id> [--agent <id>]
+  letta shared-memory sync [--agent <id>]
+  letta shared-memory history <name-or-id> [--path <file>] [--limit <n>]
+
+Actions:
+  list      List org repositories, marking which are attached to the agent
+  create    Create a new shared memory repository
+  attach    Attach a repository to the agent, clone its local mount, and
+            recompile the agent's system prompt
+  detach    Detach a repository from the agent and recompile
+  sync      Clone/pull local mounts for every repository attached to the agent
+  history   List commits for a repository (optionally scoped to one path)
+
+Notes:
+  - Output is JSON only.
+  - Agent id comes from --agent or AGENT_ID/LETTA_AGENT_ID in the env.
+  - Uses CLI auth; override with LETTA_API_KEY/LETTA_BASE_URL if needed.
+  - Attached repositories mount at $MEMORY_DIR/../<name> as normal git
+    checkouts. Edit files and commit/push there like MemFS — no API calls
+    are needed for file content.
+
+Examples:
+  letta shared-memory list
+  letta shared-memory create --name shared-notes
+  letta shared-memory attach shared-notes
+  letta shared-memory history shared-notes --path docs/plan.md
+`.trim());
+}
+function parseSharedMemoryArgs(argv) {
+  return parseArgs14({
+    args: argv,
+    options: SHARED_MEMORY_OPTIONS,
+    strict: true,
+    allowPositionals: true
+  });
+}
+function resolveSharedMemoryAgentId(agent2, agentId, env5 = process.env) {
+  return (agent2 || agentId || env5.LETTA_AGENT_ID || env5.AGENT_ID || "").trim();
+}
+function parseLimit4(value, fallback) {
+  if (typeof value !== "string" || value.length === 0)
+    return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) || parsed <= 0 ? fallback : parsed;
+}
+async function listOrgRepositories(request) {
+  const repositories = [];
+  const limit3 = 50;
+  let offset = 0;
+  for (;; ) {
+    const page = await request("GET", `/v1/repositories?limit=${limit3}&offset=${offset}`);
+    repositories.push(...page.repositories);
+    if (!page.has_next_page)
+      break;
+    offset += limit3;
+  }
+  return repositories;
+}
+async function listAgentRepositories(request, agentId) {
+  const response = await request("GET", `/v1/agents/${encodeURIComponent(agentId)}/repositories`);
+  return response.repositories.filter((repository) => !repository.is_primary && repository.name !== "memory");
+}
+function resolveRepositoryReference(repositories, reference) {
+  const trimmed = reference.trim();
+  if (!trimmed)
+    return null;
+  return repositories.find((repository) => repository.id === trimmed) ?? repositories.find((repository) => repository.name === trimmed) ?? null;
+}
+async function waitForAttachedRepository(request, agentId, repositoryId, poll) {
+  for (let attempt = 0;attempt < poll.attempts; attempt += 1) {
+    const attached = await listAgentRepositories(request, agentId);
+    if (attached.some((repository) => repository.id === repositoryId)) {
+      return true;
+    }
+    await new Promise((resolvePoll) => setTimeout(resolvePoll, poll.intervalMs));
+  }
+  return false;
+}
+async function defaultRecompileAgent(agentId) {
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+  const client = await getClient2();
+  await client.agents.recompile(agentId, { update_timestamp: false });
+}
+async function recompileAndReportFailure(recompileAgent, agentId) {
+  try {
+    await recompileAgent(agentId);
+    return null;
+  } catch (error54) {
+    return error54 instanceof Error ? error54.message : String(error54);
+  }
+}
+function requireAgentId(parsed) {
+  const agentId = resolveSharedMemoryAgentId(parsed.values.agent, parsed.values["agent-id"]);
+  if (!agentId) {
+    console.error("Agent id required: pass --agent <id> or set AGENT_ID/LETTA_AGENT_ID.");
+    return null;
+  }
+  return agentId;
+}
+async function runSharedMemorySubcommand(argv, deps = {}) {
+  let parsed;
+  try {
+    parsed = parseSharedMemoryArgs(argv);
+  } catch (error54) {
+    console.error(error54 instanceof Error ? error54.message : String(error54));
+    printUsage12();
+    return 1;
+  }
+  const [action3, reference] = parsed.positionals;
+  if (parsed.values.help || !action3 || action3 === "help") {
+    printUsage12();
+    return 0;
+  }
+  if (isLocalBackendEnvEnabled()) {
+    console.error("Shared memory requires a Letta Cloud agent; the local backend does not support it.");
+    return 1;
+  }
+  await (deps.initializeSettings ?? (() => settingsManager.initialize()))();
+  const request = deps.request ?? apiRequest;
+  const syncRepositories = deps.syncRepositories ?? syncAttachedAgentRepositories;
+  const recompileAgent = deps.recompileAgent ?? defaultRecompileAgent;
+  try {
+    if (action3 === "list") {
+      const agentId = resolveSharedMemoryAgentId(parsed.values.agent, parsed.values["agent-id"]);
+      const repositories = await listOrgRepositories(request);
+      let attachedIds = new Set;
+      if (agentId && !isLocalAgentId(agentId)) {
+        const attached = await listAgentRepositories(request, agentId);
+        attachedIds = new Set(attached.map((repository) => repository.id));
+      }
+      console.log(JSON.stringify({
+        repositories: repositories.map((repository) => ({
+          ...repository,
+          ...agentId ? { attached: attachedIds.has(repository.id) } : {}
+        }))
+      }, null, 2));
+      return 0;
+    }
+    if (action3 === "create") {
+      const name = parsed.values.name?.trim();
+      if (!name) {
+        console.error("Usage: letta shared-memory create --name <name>");
+        return 1;
+      }
+      const repository = await request("POST", "/v1/repositories", { name });
+      console.log(JSON.stringify(repository, null, 2));
+      return 0;
+    }
+    if (action3 === "attach" || action3 === "detach" || action3 === "history") {
+      if (!reference) {
+        console.error(`Usage: letta shared-memory ${action3} <name-or-id>`);
+        return 1;
+      }
+      const repositories = await listOrgRepositories(request);
+      const repository = resolveRepositoryReference(repositories, reference);
+      if (!repository) {
+        console.error(`Repository not found: ${reference}. Run \`letta shared-memory list\` to see available repositories.`);
+        return 1;
+      }
+      if (action3 === "history") {
+        const limit3 = parseLimit4(parsed.values.limit, 20);
+        const query2 = new URLSearchParams({ limit: String(limit3) });
+        if (parsed.values.path) {
+          query2.set("path", parsed.values.path);
+        }
+        const versions2 = await request("GET", `/v1/repositories/${encodeURIComponent(repository.id)}/versions?${query2}`);
+        console.log(JSON.stringify({ repository: repository.name, ...versions2 }, null, 2));
+        return 0;
+      }
+      const agentId = requireAgentId(parsed);
+      if (!agentId)
+        return 1;
+      if (action3 === "attach") {
+        await request("POST", `/v1/agents/${encodeURIComponent(agentId)}/repositories`, { repository_id: repository.id });
+        const visible = await waitForAttachedRepository(request, agentId, repository.id, deps.attachPoll ?? DEFAULT_ATTACH_POLL);
+        if (!visible) {
+          console.error(`Attach accepted but ${repository.name} did not appear in the agent's repository list. Retry \`letta shared-memory sync\` shortly.`);
+          return 1;
+        }
+        const sync2 = await syncRepositories(agentId);
+        const recompileError = await recompileAndReportFailure(recompileAgent, agentId);
+        const mountDir = getRepositoryMountDir(agentId, repository.name);
+        const mounted = existsSync57(join72(mountDir, ".git"));
+        console.log(JSON.stringify({
+          attached: true,
+          repository: { id: repository.id, name: repository.name },
+          mount: mounted ? mountDir : null,
+          sync: sync2.summaries,
+          ...recompileError ? { recompile_failed: recompileError } : {},
+          note: mounted ? "Edit files under the mount and commit/push with git, like MemFS." : "The repository is attached but its local mount was not created — see `sync` above. Resolve the reported error, then re-run `letta shared-memory sync`."
+        }, null, 2));
+        return mounted ? 0 : 1;
+      }
+      await request("DELETE", `/v1/agents/${encodeURIComponent(agentId)}/repositories/${encodeURIComponent(repository.id)}`);
+      const detachRecompileError = await recompileAndReportFailure(recompileAgent, agentId);
+      console.log(JSON.stringify({
+        detached: true,
+        repository: { id: repository.id, name: repository.name },
+        ...detachRecompileError ? { recompile_failed: detachRecompileError } : {},
+        note: "The local mount was left in place; delete it manually if no longer needed."
+      }, null, 2));
+      return 0;
+    }
+    if (action3 === "sync") {
+      const agentId = requireAgentId(parsed);
+      if (!agentId)
+        return 1;
+      const result = await syncRepositories(agentId);
+      console.log(JSON.stringify(result, null, 2));
+      return result.failed > 0 ? 1 : 0;
+    }
+    console.error(`Unknown action: ${action3}`);
+    printUsage12();
+    return 1;
+  } catch (error54) {
+    console.error(error54 instanceof Error ? error54.message : String(error54));
+    return 1;
+  }
+}
+var SHARED_MEMORY_OPTIONS, DEFAULT_ATTACH_POLL;
+var init_shared_memory = __esm(() => {
+  init_memory_git();
+  init_request();
+  init_paths();
+  init_settings_manager();
+  SHARED_MEMORY_OPTIONS = {
+    help: { type: "boolean", short: "h" },
+    agent: { type: "string" },
+    "agent-id": { type: "string" },
+    name: { type: "string" },
+    path: { type: "string" },
+    limit: { type: "string" }
+  };
+  DEFAULT_ATTACH_POLL = { intervalMs: 1000, attempts: 15 };
+});
+
 // src/cli/components/AgentSelectorFooter.tsx
 function buildCloudPageText(params) {
   return `Page ${params.cloudPage + 1}${params.cloudHasMore ? "+" : `/${params.cloudTotalPages || 1}`}${params.cloudLoadingMore ? " (loading...)" : ""}`;
@@ -474567,7 +475156,7 @@ var init_AgentSelector = __esm(async () => {
 // src/cli/subcommands/skills.ts
 import {
   cpSync as cpSync2,
-  existsSync as existsSync57,
+  existsSync as existsSync58,
   mkdtempSync as mkdtempSync4,
   readFileSync as readFileSync38,
   rmSync as rmSync14,
@@ -474576,9 +475165,9 @@ import {
 } from "node:fs";
 import { mkdir as mkdir15, readdir as readdir14 } from "node:fs/promises";
 import { tmpdir as tmpdir10 } from "node:os";
-import { basename as basename28, dirname as dirname33, join as join72, normalize as normalize5, resolve as resolve33, sep as sep7 } from "node:path";
-import { parseArgs as parseArgs14, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
-function printUsage12() {
+import { basename as basename28, dirname as dirname33, join as join73, normalize as normalize5, resolve as resolve33, sep as sep7 } from "node:path";
+import { parseArgs as parseArgs15, TextDecoder as TextDecoder2, TextEncoder as TextEncoder2 } from "node:util";
+function printUsage13() {
   console.log(`
 Usage:
   letta install <thing> [--agent <id> | -n <agent name>] [--force]
@@ -474605,7 +475194,7 @@ Options:
 `.trim());
 }
 function parseSkillsArgs(argv) {
-  return parseArgs14({
+  return parseArgs15({
     args: argv,
     options: SKILLS_OPTIONS,
     strict: true,
@@ -474868,14 +475457,14 @@ async function resolveBranchAndSubdir(location) {
 }
 async function cloneSkillSource(location) {
   const resolvedLocation = await resolveBranchAndSubdir(location);
-  const tmpDir = mkdtempSync4(join72(tmpdir10(), "letta-skill-install-"));
+  const tmpDir = mkdtempSync4(join73(tmpdir10(), "letta-skill-install-"));
   const args = ["clone", "--depth", "1"];
   if (resolvedLocation.branch) {
     args.push("--branch", resolvedLocation.branch);
   }
   args.push(resolvedLocation.repoUrl, tmpDir);
   await execFile16("git", args, { timeout: 120000 });
-  const sourceDir = resolvedLocation.subdir ? join72(tmpDir, resolvedLocation.subdir) : tmpDir;
+  const sourceDir = resolvedLocation.subdir ? join73(tmpDir, resolvedLocation.subdir) : tmpDir;
   return { tmpDir, sourceDir };
 }
 function assertDirectSkillFileSize(receivedBytes, maxBytes) {
@@ -474930,11 +475519,11 @@ async function downloadDirectSkillFileSource(location, options3 = {}) {
     throw new Error(`Direct skill file download failed for ${location.url}: ${response.status}`);
   }
   const skillText = await readResponseTextWithLimit(response, MAX_DIRECT_SKILL_FILE_BYTES);
-  const tmpDir = mkdtempSync4(join72(tmpdir10(), "letta-direct-skill-"));
+  const tmpDir = mkdtempSync4(join73(tmpdir10(), "letta-direct-skill-"));
   try {
-    const sourceDir = join72(tmpDir, "skill");
+    const sourceDir = join73(tmpDir, "skill");
     await mkdir15(sourceDir, { recursive: true });
-    writeFileSync30(join72(sourceDir, "SKILL.md"), skillText, "utf8");
+    writeFileSync30(join73(sourceDir, "SKILL.md"), skillText, "utf8");
     return { tmpDir, sourceDir };
   } catch (error54) {
     rmSync14(tmpDir, { recursive: true, force: true });
@@ -474975,9 +475564,9 @@ function assertSafeZipMember(name) {
 }
 async function downloadClawHubSkillSource(location) {
   const version2 = await resolveClawHubVersion(location);
-  const tmpDir = mkdtempSync4(join72(tmpdir10(), "letta-clawhub-skill-"));
-  const zipPath = join72(tmpDir, "skill.zip");
-  const sourceDir = join72(tmpDir, "skill");
+  const tmpDir = mkdtempSync4(join73(tmpdir10(), "letta-clawhub-skill-"));
+  const zipPath = join73(tmpDir, "skill.zip");
+  const sourceDir = join73(tmpDir, "skill");
   await mkdir15(sourceDir, { recursive: true });
   const url2 = new URL(`${CLAWHUB_API_BASE_URL}/download`);
   url2.searchParams.set("slug", location.slug);
@@ -475016,7 +475605,7 @@ function sanitizeSkillName(name) {
   return trimmed;
 }
 function getSkillName(sourceDir) {
-  const skillMd = readFileSync38(join72(sourceDir, "SKILL.md"), "utf8");
+  const skillMd = readFileSync38(join73(sourceDir, "SKILL.md"), "utf8");
   const { frontmatter } = parseFrontmatter(skillMd);
   const frontmatterName = frontmatter.name;
   const name = typeof frontmatterName === "string" && frontmatterName.trim() ? frontmatterName : basename28(sourceDir);
@@ -475025,18 +475614,18 @@ function getSkillName(sourceDir) {
 async function installSkillDirectory(params) {
   const sourceDir = resolve33(params.sourceDir);
   const memoryDir = resolve33(params.memoryDir);
-  const skillMdPath = join72(sourceDir, "SKILL.md");
-  if (!existsSync57(skillMdPath)) {
+  const skillMdPath = join73(sourceDir, "SKILL.md");
+  if (!existsSync58(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
   if (!statSync20(sourceDir).isDirectory()) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
-  const skillsDir = join72(memoryDir, "skills");
-  const targetPath = join72(skillsDir, name);
+  const skillsDir = join73(memoryDir, "skills");
+  const targetPath = join73(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (existsSync57(targetPath)) {
+  if (existsSync58(targetPath)) {
     if (!params.force) {
       throw new Error(`Skill "${name}" already exists at ${targetPath}. Re-run with --force to replace it.`);
     }
@@ -475051,17 +475640,17 @@ async function installSkillDirectory(params) {
 }
 async function listSkillDirectories(params) {
   const memoryDir = resolve33(params.memoryDir);
-  const skillsDir = join72(memoryDir, "skills");
-  if (!existsSync57(skillsDir))
+  const skillsDir = join73(memoryDir, "skills");
+  if (!existsSync58(skillsDir))
     return [];
   const entries = await readdir14(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const skillDir = join72(skillsDir, entry.name);
-    const skillMdPath = join72(skillDir, "SKILL.md");
-    if (!existsSync57(skillMdPath))
+    const skillDir = join73(skillsDir, entry.name);
+    const skillMdPath = join73(skillDir, "SKILL.md");
+    if (!existsSync58(skillMdPath))
       continue;
     let name = entry.name;
     let description;
@@ -475081,11 +475670,11 @@ async function listSkillDirectories(params) {
 }
 async function deleteSkillDirectory(params) {
   const memoryDir = resolve33(params.memoryDir);
-  const skillsDir = join72(memoryDir, "skills");
+  const skillsDir = join73(memoryDir, "skills");
   const name = sanitizeSkillName(params.name);
-  const targetPath = join72(skillsDir, name);
+  const targetPath = join73(skillsDir, name);
   assertInside(skillsDir, targetPath);
-  if (!existsSync57(targetPath)) {
+  if (!existsSync58(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
   if (!statSync20(targetPath).isDirectory()) {
@@ -475134,7 +475723,7 @@ async function installSkill(specifier, agentId, force) {
     tmpDir = downloaded.tmpDir;
     const sourceDir = resolve33(downloaded.sourceDir);
     assertInside(tmpDir, sourceDir);
-    if (!existsSync57(sourceDir)) {
+    if (!existsSync58(sourceDir)) {
       const missingPath = source2.type === "git" ? source2.location.subdir ?? "." : source2.type === "direct-file" ? source2.location.url : source2.location.slug;
       throw new Error(`Skill path not found: ${missingPath}`);
     }
@@ -475253,17 +475842,17 @@ async function runInstall(argv, options3 = {}) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   const [specifier] = parsed.positionals;
   if (parsed.values.help || !specifier || specifier === "help") {
-    printUsage12();
+    printUsage13();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   if (specifier.startsWith("npm:")) {
@@ -475354,16 +475943,16 @@ async function runList2(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   if (parsed.values.help) {
-    printUsage12();
+    printUsage13();
     return 0;
   }
   if (parsed.positionals.length > 0) {
     console.error(`Unexpected argument: ${parsed.positionals[0]}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   try {
@@ -475384,17 +475973,17 @@ async function runDelete(argv) {
     parsed = parseSkillsArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   const [skillName] = parsed.positionals;
   if (parsed.values.help || !skillName || skillName === "help") {
-    printUsage12();
+    printUsage13();
     return 0;
   }
   if (parsed.positionals.length > 1) {
     console.error(`Unexpected argument: ${parsed.positionals[1]}`);
-    printUsage12();
+    printUsage13();
     return 1;
   }
   const agentId = getExplicitAgentId2(parsed.values);
@@ -475434,11 +476023,11 @@ async function runSkillsSubcommand(argv) {
     case "help":
     case "--help":
     case "-h":
-      printUsage12();
+      printUsage13();
       return 0;
     default:
       console.error(`Unknown action: ${action3}`);
-      printUsage12();
+      printUsage13();
       return 1;
   }
 }
@@ -475458,7 +476047,7 @@ var init_skills4 = __esm(() => {
 
 // src/cli/subcommands/trajectories/readers.ts
 import { readdir as readdir15, readFile as readFile24, stat as stat15 } from "node:fs/promises";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 async function loadSessionTranscript(item) {
   const stats = await stat15(item.path);
   if (stats.isDirectory()) {
@@ -475470,13 +476059,13 @@ async function loadSessionTranscript(item) {
   return readFile24(item.path, "utf-8");
 }
 async function assembleEventDirectory(sessionDir) {
-  const eventsSubdir = join73(sessionDir, "events");
+  const eventsSubdir = join74(sessionDir, "events");
   const eventsDir = (await stat15(eventsSubdir).catch(() => null))?.isDirectory() ? eventsSubdir : sessionDir;
   const names = (await readdir15(eventsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a2, b3) => Number.parseInt(a2, 10) - Number.parseInt(b3, 10) || a2.localeCompare(b3));
   if (names.length === 0) {
     throw new Error(`No event files found in ${eventsDir}`);
   }
-  const events = await Promise.all(names.map(async (name) => JSON.parse(await readFile24(join73(eventsDir, name), "utf-8"))));
+  const events = await Promise.all(names.map(async (name) => JSON.parse(await readFile24(join74(eventsDir, name), "utf-8"))));
   return JSON.stringify(events);
 }
 async function openReadOnlyDatabase(path43) {
@@ -475554,7 +476143,7 @@ import {
   stat as stat16,
   writeFile as writeFile18
 } from "node:fs/promises";
-import { basename as basename29, join as join74 } from "node:path";
+import { basename as basename29, join as join75 } from "node:path";
 function fileTimestamp(startedAt) {
   if (!startedAt)
     return "unknown-date";
@@ -475624,7 +476213,7 @@ async function prepareOutDir(outDir) {
       throw new Error(`--out ${outDir} is not empty and has no ${MANIFEST_NAME}; refusing to overwrite a directory this tool did not create`);
     }
     for (const entry of entries) {
-      await rm10(join74(outDir, entry), { recursive: true, force: true });
+      await rm10(join75(outDir, entry), { recursive: true, force: true });
     }
   } catch (error54) {
     if (error54.code !== "ENOENT")
@@ -475667,14 +476256,14 @@ async function runTrajectoryExport(options3) {
       }
       const sessionId = sessionHash(source2, id2);
       const base3 = `${fileTimestamp(stats.startedAt)}_${sessionId}`;
-      let file3 = join74(source2, `${base3}.json`);
+      let file3 = join75(source2, `${base3}.json`);
       for (let suffix = 2;usedFiles.has(file3); suffix += 1) {
-        file3 = join74(source2, `${base3}-${suffix}.json`);
+        file3 = join75(source2, `${base3}-${suffix}.json`);
       }
       usedFiles.add(file3);
       const body3 = JSON.stringify(records);
-      await mkdir16(join74(options3.outDir, source2), { recursive: true });
-      await writeFile18(join74(options3.outDir, file3), body3, "utf-8");
+      await mkdir16(join75(options3.outDir, source2), { recursive: true });
+      await writeFile18(join75(options3.outDir, file3), body3, "utf-8");
       counts.exported += 1;
       manifest2.sessions.push({
         source: source2,
@@ -475728,7 +476317,7 @@ async function runTrajectoryExport(options3) {
     await exportCheckpoint(checkpoint2, `${basename29(checkpoint2.path)}-${checkpoint2.threadId}`);
   }
   manifest2.sessions.sort((a2, b3) => (a2.startedAt ?? "").localeCompare(b3.startedAt ?? ""));
-  await writeFile18(join74(options3.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
+  await writeFile18(join75(options3.outDir, MANIFEST_NAME), JSON.stringify(manifest2, null, 2), "utf-8");
   return manifest2;
 }
 var MANIFEST_NAME = "manifest.json", FIRST_PROMPT_MAX_CHARS = 200, LIST_PAGE_LIMIT = 1000;
@@ -475740,13 +476329,13 @@ var init_export = __esm(() => {
 
 // src/cli/subcommands/trajectories/review.ts
 import { readFile as readFile26 } from "node:fs/promises";
-import { isAbsolute as isAbsolute27, join as join75 } from "node:path";
+import { isAbsolute as isAbsolute27, join as join76 } from "node:path";
 async function readManifest(dir) {
   let raw2;
   try {
-    raw2 = await readFile26(join75(dir, "manifest.json"), "utf-8");
+    raw2 = await readFile26(join76(dir, "manifest.json"), "utf-8");
   } catch {
-    throw new Error(`No manifest at ${join75(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
+    throw new Error(`No manifest at ${join76(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
   }
   return JSON.parse(raw2);
 }
@@ -475755,7 +476344,7 @@ function filterSessions(sessions, filter3) {
 }
 async function resolveSessionFile(dir, target2) {
   if (target2.endsWith(".json")) {
-    const direct = isAbsolute27(target2) ? target2 : join75(dir, target2);
+    const direct = isAbsolute27(target2) ? target2 : join76(dir, target2);
     try {
       await readFile26(direct, "utf-8");
       return direct;
@@ -475766,7 +476355,7 @@ async function resolveSessionFile(dir, target2) {
   if (!entry) {
     throw new Error(`No session "${target2}" in ${dir} (pass a file path, a manifest-relative file, or a sessionId)`);
   }
-  return join75(dir, entry.file);
+  return join76(dir, entry.file);
 }
 function stamp(timestamp) {
   return (timestamp ?? "").slice(0, 19);
@@ -475809,7 +476398,7 @@ async function searchSessions(dir, keyword, options3 = {}) {
   for (const session of filterSessions(manifest2.sessions, options3)) {
     let records;
     try {
-      records = JSON.parse(await readFile26(join75(dir, session.file), "utf-8"));
+      records = JSON.parse(await readFile26(join76(dir, session.file), "utf-8"));
     } catch {
       continue;
     }
@@ -475841,8 +476430,8 @@ var init_review = () => {};
 
 // src/cli/subcommands/trajectories.ts
 import { readFile as readFile27 } from "node:fs/promises";
-import { parseArgs as parseArgs15 } from "node:util";
-function printUsage13() {
+import { parseArgs as parseArgs16 } from "node:util";
+function printUsage14() {
   console.log(`
 Usage:
   letta trajectories export [options]
@@ -475980,7 +476569,7 @@ ${results.length} session(s) matched "${keyword}"`);
   return 0;
 }
 function parseTrajectoriesArgs(argv) {
-  return parseArgs15({
+  return parseArgs16({
     args: argv,
     options: TRAJECTORIES_OPTIONS,
     strict: true,
@@ -475993,12 +476582,12 @@ async function runTrajectoriesSubcommand(argv) {
     parsed = parseTrajectoriesArgs(argv);
   } catch (error54) {
     console.error(`Error: ${error54 instanceof Error ? error54.message : String(error54)}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   const [action3] = parsed.positionals;
   if (parsed.values.help || action3 === "help" || !action3) {
-    printUsage13();
+    printUsage14();
     return parsed.values.help || action3 === "help" ? 0 : 1;
   }
   const asJson = Boolean(parsed.values.json);
@@ -476030,7 +476619,7 @@ async function runTrajectoriesSubcommand(argv) {
   }
   if (action3 !== "export") {
     console.error(`Unknown command: ${action3}`);
-    printUsage13();
+    printUsage14();
     return 1;
   }
   const options3 = {
@@ -477763,7 +478352,7 @@ var init_gateway_core = __esm(() => {
 });
 
 // src/channels/custom/scaffolding.ts
-import { existsSync as existsSync58, mkdirSync as mkdirSync42, rmSync as rmSync15, writeFileSync as writeFileSync31 } from "node:fs";
+import { existsSync as existsSync59, mkdirSync as mkdirSync42, rmSync as rmSync15, writeFileSync as writeFileSync31 } from "node:fs";
 function removeUserPlugin(channelId) {
   if (FIRST_PARTY_SET.has(channelId)) {
     return;
@@ -477772,7 +478361,7 @@ function removeUserPlugin(channelId) {
     return;
   }
   const channelDir = getChannelDir(channelId);
-  if (!existsSync58(channelDir)) {
+  if (!existsSync59(channelDir)) {
     return;
   }
   try {
@@ -479037,14 +479626,14 @@ var exports_channel_gateway = {};
 __export(exports_channel_gateway, {
   runChannelGatewaySubcommand: () => runChannelGatewaySubcommand
 });
-import { parseArgs as parseArgs16 } from "node:util";
+import { parseArgs as parseArgs17 } from "node:util";
 function isGatewayCommandEnvelope(value) {
   return Boolean(value && typeof value === "object" && "type" in value && value.type === "command" && "requestId" in value && typeof value.requestId === "string" && "command" in value && value.command && typeof value.command === "object");
 }
 async function runChannelGatewaySubcommand(argv) {
   let values2;
   try {
-    ({ values: values2 } = parseArgs16({
+    ({ values: values2 } = parseArgs17({
       args: argv,
       strict: true,
       allowPositionals: false,
@@ -479181,6 +479770,7 @@ function subcommandNeedsEarlyBackendMode(command) {
     case "mods":
     case "remote":
     case "server":
+    case "shared-memory":
     case "skills":
       return true;
     default:
@@ -479225,6 +479815,8 @@ async function runSubcommand(argv) {
       return runSetupSubcommand(rest3);
     case "install":
       return runInstallSubcommand(rest3);
+    case "shared-memory":
+      return runSharedMemorySubcommand(rest3);
     case "skills":
       return runSkillsSubcommand(rest3);
     case "cron":
@@ -479255,6 +479847,7 @@ var init_router = __esm(async () => {
   init_local_backend2();
   init_memory7();
   init_messages10();
+  init_shared_memory();
   init_skills4();
   init_trajectories();
   await __promiseAll([
@@ -479489,17 +480082,17 @@ var exports_bootstrap_tools = {};
 __export(exports_bootstrap_tools, {
   bootstrapBaseToolsIfNeeded: () => bootstrapBaseToolsIfNeeded
 });
-import { existsSync as existsSync59, mkdirSync as mkdirSync43, writeFileSync as writeFileSync32 } from "node:fs";
+import { existsSync as existsSync60, mkdirSync as mkdirSync43, writeFileSync as writeFileSync32 } from "node:fs";
 import { homedir as homedir42 } from "node:os";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 async function bootstrapBaseToolsIfNeeded() {
-  if (existsSync59(MARKER_PATH))
+  if (existsSync60(MARKER_PATH))
     return;
   debugLog("bootstrap", "No marker found, bootstrapping base tools...");
   try {
     const success2 = await addBaseToolsToServer();
     if (success2) {
-      mkdirSync43(join76(homedir42(), ".letta"), { recursive: true });
+      mkdirSync43(join77(homedir42(), ".letta"), { recursive: true });
       writeFileSync32(MARKER_PATH, new Date().toISOString(), "utf-8");
     }
   } catch (err) {
@@ -479510,7 +480103,7 @@ var MARKER_PATH;
 var init_bootstrap_tools = __esm(() => {
   init_debug();
   init_create5();
-  MARKER_PATH = join76(homedir42(), ".letta", ".bootstrapped");
+  MARKER_PATH = join77(homedir42(), ".letta", ".bootstrapped");
 });
 
 // src/utils/headless-stdout-guard.ts
@@ -479856,8 +480449,17 @@ var init_local_backend_mod_events = __esm(() => {
   init_local_backend();
 });
 
+// src/headless-memfs-policy.ts
+function resolveHeadlessMemfsPolicy(options3) {
+  const isFreshStatelessSubagent = options3.isSubagentRole && options3.newAgentRequested;
+  return {
+    isFreshStatelessSubagent,
+    isStatelessSession: options3.statelessRequested || isFreshStatelessSubagent
+  };
+}
+
 // src/headless-mod-adapter.ts
-import { join as join77 } from "node:path";
+import { join as join78 } from "node:path";
 function isHeadlessMemfsEnabled(agentId) {
   try {
     return settingsManager.isMemfsEnabled(agentId);
@@ -479928,7 +480530,7 @@ function createHeadlessModContext(options3) {
   };
 }
 function createHeadlessModAdapter(options3) {
-  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join77(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
+  const agentModsDirectory = isHeadlessMemfsEnabled(options3.agent.id) ? join78(getScopedMemoryFilesystemRoot(options3.agent.id), "mods") : undefined;
   return createModAdapter({
     ...agentModsDirectory ? { agentModsDirectory } : {},
     ...options3.cacheDirectory ? { cacheDirectory: options3.cacheDirectory } : {},
@@ -486215,49 +486817,49 @@ var require_fast_uri = __commonJS((exports, module3) => {
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
-  function resolveComponent(base3, relative15, options3, skipNormalization) {
+  function resolveComponent(base3, relative14, options3, skipNormalization) {
     const target2 = {};
     if (!skipNormalization) {
       base3 = parse9(serialize(base3, options3), options3);
-      relative15 = parse9(serialize(relative15, options3), options3);
+      relative14 = parse9(serialize(relative14, options3), options3);
     }
     options3 = options3 || {};
-    if (!options3.tolerant && relative15.scheme) {
-      target2.scheme = relative15.scheme;
-      target2.userinfo = relative15.userinfo;
-      target2.host = relative15.host;
-      target2.port = relative15.port;
-      target2.path = removeDotSegments(relative15.path || "");
-      target2.query = relative15.query;
+    if (!options3.tolerant && relative14.scheme) {
+      target2.scheme = relative14.scheme;
+      target2.userinfo = relative14.userinfo;
+      target2.host = relative14.host;
+      target2.port = relative14.port;
+      target2.path = removeDotSegments(relative14.path || "");
+      target2.query = relative14.query;
     } else {
-      if (relative15.userinfo !== undefined || relative15.host !== undefined || relative15.port !== undefined) {
-        target2.userinfo = relative15.userinfo;
-        target2.host = relative15.host;
-        target2.port = relative15.port;
-        target2.path = removeDotSegments(relative15.path || "");
-        target2.query = relative15.query;
+      if (relative14.userinfo !== undefined || relative14.host !== undefined || relative14.port !== undefined) {
+        target2.userinfo = relative14.userinfo;
+        target2.host = relative14.host;
+        target2.port = relative14.port;
+        target2.path = removeDotSegments(relative14.path || "");
+        target2.query = relative14.query;
       } else {
-        if (!relative15.path) {
+        if (!relative14.path) {
           target2.path = base3.path;
-          if (relative15.query !== undefined) {
-            target2.query = relative15.query;
+          if (relative14.query !== undefined) {
+            target2.query = relative14.query;
           } else {
             target2.query = base3.query;
           }
         } else {
-          if (relative15.path[0] === "/") {
-            target2.path = removeDotSegments(relative15.path);
+          if (relative14.path[0] === "/") {
+            target2.path = removeDotSegments(relative14.path);
           } else {
             if ((base3.userinfo !== undefined || base3.host !== undefined || base3.port !== undefined) && !base3.path) {
-              target2.path = "/" + relative15.path;
+              target2.path = "/" + relative14.path;
             } else if (!base3.path) {
-              target2.path = relative15.path;
+              target2.path = relative14.path;
             } else {
-              target2.path = base3.path.slice(0, base3.path.lastIndexOf("/") + 1) + relative15.path;
+              target2.path = base3.path.slice(0, base3.path.lastIndexOf("/") + 1) + relative14.path;
             }
             target2.path = removeDotSegments(target2.path);
           }
-          target2.query = relative15.query;
+          target2.query = relative14.query;
         }
         target2.userinfo = base3.userinfo;
         target2.host = base3.host;
@@ -486265,7 +486867,7 @@ var require_fast_uri = __commonJS((exports, module3) => {
       }
       target2.scheme = base3.scheme;
     }
-    target2.fragment = relative15.fragment;
+    target2.fragment = relative14.fragment;
     return target2;
   }
   function equal3(uriA, uriB, options3) {
@@ -491284,7 +491886,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.30.4"
+    version: "0.30.5"
   };
 });
 
@@ -491706,8 +492308,8 @@ var init_mcp_runtime = __esm(async () => {
 });
 
 // src/skills/builtin/creating-skills/scripts/validate-skill.ts
-import { existsSync as existsSync60, readFileSync as readFileSync39 } from "node:fs";
-import { basename as basename30, join as join78, resolve as resolve34 } from "node:path";
+import { existsSync as existsSync61, readFileSync as readFileSync39 } from "node:fs";
+import { basename as basename30, join as join79, resolve as resolve34 } from "node:path";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
 function parseQuotedScalar(value) {
   if (value.startsWith('"')) {
@@ -491804,8 +492406,8 @@ function parseFrontmatter2(source2) {
   return parseFrontmatterFallback(source2);
 }
 function validateSkill(skillPath) {
-  const skillMdPath = join78(skillPath, "SKILL.md");
-  if (!existsSync60(skillMdPath)) {
+  const skillMdPath = join79(skillPath, "SKILL.md");
+  if (!existsSync61(skillMdPath)) {
     return { valid: false, message: "SKILL.md not found" };
   }
   const content = readFileSync39(skillMdPath, "utf-8");
@@ -491972,7 +492574,7 @@ __export(exports_import, {
 });
 import { createReadStream as createReadStream2 } from "node:fs";
 import { access as access2, chmod, mkdir as mkdir17, readFile as readFile28, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname34, isAbsolute as isAbsolute28, relative as relative15, resolve as resolve35, sep as sep8, win32 as win325 } from "node:path";
+import { dirname as dirname34, isAbsolute as isAbsolute28, relative as relative14, resolve as resolve35, sep as sep8, win32 as win325 } from "node:path";
 function validateImportedSkillName(name) {
   const trimmedName = name.trim();
   if (trimmedName !== name || trimmedName.length === 0 || trimmedName.length > MAX_SKILL_NAME_LENGTH || trimmedName === "." || trimmedName === ".." || !IMPORTED_SKILL_NAME_PATTERN.test(trimmedName)) {
@@ -491983,7 +492585,7 @@ function validateImportedSkillName(name) {
 function assertPathInside(parent, child) {
   const parentPath = resolve35(parent);
   const childPath = resolve35(child);
-  const relativePath = relative15(parentPath, childPath);
+  const relativePath = relative14(parentPath, childPath);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep8}`) || isAbsolute28(relativePath)) {
     throw new Error(`Imported skill file path escapes skill directory: ${child}`);
   }
@@ -492153,7 +492755,7 @@ function parseRegistryHandle(handle2) {
 }
 async function importAgentFromRegistry(options3) {
   const { tmpdir: tmpdir11 } = await import("node:os");
-  const { join: join79 } = await import("node:path");
+  const { join: join80 } = await import("node:path");
   const { writeFile: writeFile20, unlink: unlink6 } = await import("node:fs/promises");
   const { author, name } = parseRegistryHandle(options3.handle);
   const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
@@ -492165,7 +492767,7 @@ async function importAgentFromRegistry(options3) {
     throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
   }
   const afContent = await response.text();
-  const tempPath = join79(tmpdir11(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  const tempPath = join80(tmpdir11(), `letta-import-${author}-${name}-${Date.now()}.af`);
   await writeFile20(tempPath, afContent, "utf-8");
   try {
     const result = await importAgentFromFile({
@@ -492424,6 +493026,7 @@ function hasReflectionOverrides(overrides) {
 async function applyReflectionOverrides(agentId, overrides) {
   const current = getReflectionSettings(agentId);
   const merged = {
+    ...current,
     trigger: overrides.trigger ?? current.trigger,
     stepCount: overrides.stepCount ?? current.stepCount
   };
@@ -492815,9 +493418,14 @@ In headless mode, use:
   const noBundledSkillsFlag = values2["no-bundled-skills"];
   const skillSourcesRaw = values2["skill-sources"];
   const memfsFlag = values2.memfs;
+  const statelessFlag = values2.stateless;
   const isSubagentRole = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
-  const isStatelessSubagent = isSubagentRole && Boolean(values2["new-agent"]);
-  if (isStatelessSubagent && backend3.capabilities.localMemfs) {
+  const { isFreshStatelessSubagent, isStatelessSession } = resolveHeadlessMemfsPolicy({
+    statelessRequested: Boolean(statelessFlag),
+    isSubagentRole,
+    newAgentRequested: Boolean(forceNew)
+  });
+  if (isStatelessSession && backend3.capabilities.localMemfs) {
     const { disableLocalBackendMemfsForProcess: disableLocalBackendMemfsForProcess2 } = await Promise.resolve().then(() => (init_paths(), exports_paths));
     disableLocalBackendMemfsForProcess2();
   }
@@ -492829,7 +493437,7 @@ In headless mode, use:
     console.error("Error: --memfs is not supported by this backend yet");
     process.exit(1);
   }
-  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !isStatelessSubagent;
+  const shouldAutoEnableMemfsForNewAgent = !memfsFlag && !isStatelessSession;
   const fromAfFile = resolveImportFlagAlias({
     importFlagValue: values2.import,
     fromAfFlagValue: values2["from-af"]
@@ -492917,35 +493525,17 @@ In headless mode, use:
     }
   }
   try {
-    validateFlagConflicts({
-      guard: specifiedConversationId && specifiedConversationId !== "default",
-      checks: [
-        {
-          when: specifiedAgentId,
-          message: "--conversation cannot be used with --agent"
-        },
-        {
-          when: specifiedAgentName,
-          message: "--conversation cannot be used with --name"
-        },
-        {
-          when: forceNew,
-          message: "--conversation cannot be used with --new-agent"
-        },
-        {
-          when: fromAfFile,
-          message: "--conversation cannot be used with --import"
-        }
-      ]
-    });
-    validateFlagConflicts({
-      guard: forceNewConversation,
-      checks: [
-        {
-          when: specifiedConversationId,
-          message: "--new cannot be used with --conversation"
-        }
-      ]
+    validatePrimaryStartupFlagConflicts({
+      specifiedConversationId,
+      specifiedAgentId,
+      specifiedAgentName,
+      forceNewAgent: forceNew,
+      forceNewConversation,
+      importFile: fromAfFile,
+      stateless: statelessFlag,
+      isHeadless: true,
+      memfs: memfsFlag,
+      memfsStartup: values2["memfs-startup"]
     });
   } catch (error54) {
     return reportAndExitHeadless("headless_flag_conflict_validation_failed", error54, "headless_startup_flag_conflicts");
@@ -493076,7 +493666,7 @@ In headless mode, use:
   if (!agent2 && forceNew) {
     const { isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
     const willAutoEnableMemfs = backend3.capabilities.remoteMemfs && shouldAutoEnableMemfsForNewAgent && await isLettaCloud2();
-    const effectiveMemoryMode = backend3.capabilities.localMemfs ? isStatelessSubagent ? "standard" : "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
+    const effectiveMemoryMode = backend3.capabilities.localMemfs ? isFreshStatelessSubagent ? "standard" : "local-memfs" : requestedMemoryPromptMode ?? (willAutoEnableMemfs ? "memfs" : undefined);
     const personalityOptions = personality ? await buildCreateAgentOptionsForPersonality({
       personalityId: personality,
       model,
@@ -493178,19 +493768,21 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   let effectiveReflectionSettings;
   const isSubagent = process.env.LETTA_CODE_AGENT_ROLE === "subagent";
   let startupMemfsFlag = autoEnableMemfsForFreshAgent ? true : memfsFlag;
-  if (backend3.capabilities.remoteMemfs && !autoEnableMemfsForFreshAgent) {
+  if (!isStatelessSession && backend3.capabilities.remoteMemfs && !autoEnableMemfsForFreshAgent) {
     const { hydrateMemfsSettingFromAgent: hydrateMemfsSettingFromAgent2, isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
     const memfsEnabled = await hydrateMemfsSettingFromAgent2(agent2);
-    if (!memfsEnabled && !isStatelessSubagent && await isLettaCloud2()) {
+    if (!memfsEnabled && await isLettaCloud2()) {
       startupMemfsFlag = true;
     }
   }
   let memfsBgPromise;
   const secretsAgentId = agent2?.id;
   const secretsInitPromise = secretsAgentId ? Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store)).then(({ initSecretsFromServer: initSecretsFromServer2 }) => initSecretsFromServer2(secretsAgentId, agent2 ?? undefined)) : Promise.resolve();
-  if (!backend3.capabilities.remoteMemfs) {
+  if (isStatelessSession) {
+    settingsManager.setMemfsEnabled(agent2.id, false);
+  } else if (!backend3.capabilities.remoteMemfs) {
     if (backend3.capabilities.localMemfs) {
-      settingsManager.setMemfsEnabled(agent2.id, !isStatelessSubagent);
+      settingsManager.setMemfsEnabled(agent2.id, true);
     }
   } else if (memfsStartupPolicy === "skip") {
     try {
@@ -493281,7 +493873,8 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     debugWarn("headless startup", `Failed to clear persisted client tool rules for ${startupAgentId}: ${error54 instanceof Error ? error54.message : String(error54)}`);
   });
   try {
-    effectiveReflectionSettings = await applyReflectionOverrides(agent2.id, reflectionOverrides);
+    const resolvedReflectionSettings = await applyReflectionOverrides(agent2.id, reflectionOverrides);
+    effectiveReflectionSettings = isStatelessSession ? { ...resolvedReflectionSettings, trigger: "off" } : resolvedReflectionSettings;
   } catch (error54) {
     console.error(`Failed to apply sleeptime settings: ${error54 instanceof Error ? error54.message : String(error54)}`);
     process.exit(1);
@@ -496935,10 +497528,10 @@ var init_queued_message_parts = __esm(() => {
 
 // src/cli/helpers/reflection-arena-hf-upload.ts
 import { execFile as execFileCb5 } from "node:child_process";
-import { existsSync as existsSync62 } from "node:fs";
+import { existsSync as existsSync63 } from "node:fs";
 import { appendFile as appendFile2, chmod as chmod2, mkdir as mkdir18, writeFile as writeFile20 } from "node:fs/promises";
 import { homedir as homedir45 } from "node:os";
-import { join as join80 } from "node:path";
+import { join as join81 } from "node:path";
 import { promisify as promisify15 } from "node:util";
 function buildGitEnv(token2, askpassPath) {
   return {
@@ -496974,7 +497567,7 @@ async function runGit6(cwd2, args, env5) {
   }
 }
 async function writeGitAskpass(repoRoot) {
-  const askpassPath = join80(repoRoot, "hf-askpass.sh");
+  const askpassPath = join81(repoRoot, "hf-askpass.sh");
   await writeFile20(askpassPath, [
     "#!/bin/sh",
     'case "$1" in',
@@ -496989,7 +497582,7 @@ async function writeGitAskpass(repoRoot) {
 }
 async function prepareHfRepo(env5) {
   await mkdir18(HF_CACHE_ROOT, { recursive: true });
-  if (!existsSync62(join80(HF_REPO_DIR, ".git"))) {
+  if (!existsSync63(join81(HF_REPO_DIR, ".git"))) {
     await runGit6(HF_CACHE_ROOT, ["clone", "--depth", "1", HF_REPO_URL, HF_REPO_DIR], env5);
     return HF_REPO_DIR;
   }
@@ -497024,8 +497617,8 @@ async function maybeUploadReflectionArenaChoiceToHf(row) {
   const env5 = buildGitEnv(token2, askpassPath);
   try {
     const repoDir = await prepareHfRepo(env5);
-    await mkdir18(join80(repoDir, "data"), { recursive: true });
-    await appendFile2(join80(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
+    await mkdir18(join81(repoDir, "data"), { recursive: true });
+    await appendFile2(join81(repoDir, HF_DATASET_PATH), `${JSON.stringify(row)}
 `, {
       encoding: "utf-8"
     });
@@ -497053,8 +497646,8 @@ var init_reflection_arena_hf_upload = __esm(() => {
   init_version();
   execFile17 = promisify15(execFileCb5);
   HF_REPO_URL = `https://huggingface.co/datasets/${HF_REPO_ID}`;
-  HF_CACHE_ROOT = join80(homedir45(), ".letta", "reflection-arena", "hf-upload");
-  HF_REPO_DIR = join80(HF_CACHE_ROOT, "repo");
+  HF_CACHE_ROOT = join81(homedir45(), ".letta", "reflection-arena", "hf-upload");
+  HF_REPO_DIR = join81(HF_CACHE_ROOT, "repo");
 });
 
 // src/cli/helpers/reflection-arena.ts
@@ -497062,7 +497655,7 @@ import { execFile as execFileCb6 } from "node:child_process";
 import { randomInt as randomInt2, randomUUID as randomUUID34 } from "node:crypto";
 import { appendFile as appendFile3, mkdir as mkdir19, readFile as readFile29, writeFile as writeFile21 } from "node:fs/promises";
 import { homedir as homedir46 } from "node:os";
-import { join as join81 } from "node:path";
+import { join as join82 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
   const excluded = new Set(excludedModels);
@@ -497078,30 +497671,49 @@ function sampleReflectionArenaComparisonModel(excludedModels = []) {
   }
   return candidates2[0]?.model ?? "letta/auto";
 }
-async function getGitHead(cwd2) {
+async function getGitOutput(cwd2, args) {
   try {
-    const { stdout } = await execFile18("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await execFile18("git", args, {
       cwd: cwd2,
       encoding: "utf-8",
       timeout: 30000,
       maxBuffer: 1024 * 1024
     });
-    return stdout.trim() || null;
+    return stdout.trim();
   } catch {
     return null;
   }
 }
+async function getGitHead(cwd2) {
+  return await getGitOutput(cwd2, ["rev-parse", "HEAD"]) || null;
+}
+async function reflectionMemoryWorktreeHasNoChanges(worktree) {
+  const [count, status] = await Promise.all([
+    getGitOutput(worktree.worktreeDir, [
+      "rev-list",
+      "--count",
+      `${worktree.baseHead}..HEAD`
+    ]),
+    getGitOutput(worktree.worktreeDir, ["status", "--porcelain"])
+  ]);
+  if (count === null || status === null)
+    return;
+  return count === "0" && status.length === 0;
+}
+function candidateIsConfirmedNoOp(candidate) {
+  return candidate.result?.success === true && candidate.result.memoryNoChanges === true && candidate.result.memoryHead === candidate.worktree.baseHead;
+}
 function getReflectionArenaRoot() {
-  return join81(homedir46(), ".letta", "reflection-arena");
+  return join82(homedir46(), ".letta", "reflection-arena");
 }
 function getReflectionArenaRunsDir() {
-  return join81(getReflectionArenaRoot(), "runs");
+  return join82(getReflectionArenaRoot(), "runs");
 }
 function getReflectionArenaChoiceLogPath() {
-  return join81(getReflectionArenaRoot(), "choices.jsonl");
+  return join82(getReflectionArenaRoot(), "choices.jsonl");
 }
 function getReflectionArenaRunPath(runId) {
-  return join81(getReflectionArenaRunsDir(), `${runId}.json`);
+  return join82(getReflectionArenaRunsDir(), `${runId}.json`);
 }
 async function saveReflectionArenaRun(run) {
   await mkdir19(getReflectionArenaRunsDir(), { recursive: true });
@@ -497393,6 +498005,11 @@ async function markCandidateComplete(params) {
   });
 }
 async function launchReflectionArena(options3) {
+  const memoryDir = getScopedMemoryFilesystemRoot(options3.agentId);
+  if (await reflectionMemoryParentHasChanges(memoryDir)) {
+    debugLog("memory", `Skipping reflection arena launch (${options3.triggerSource}) because parent memory has uncommitted changes`);
+    return { launched: false, reason: "parent_dirty" };
+  }
   const payload = await buildAutoReflectionPayload(options3.agentId, options3.conversationId);
   if (!payload) {
     return { launched: false, reason: "no_payload" };
@@ -497439,7 +498056,8 @@ async function startReflectionArenaRun(options3) {
       payloadPath: options3.payload.payloadPath,
       runId,
       startMessageId: options3.payload.startMessageId,
-      status: "running"
+      status: "running",
+      triggerSource: options3.triggerSource
     };
     await saveReflectionArenaRun(run);
     const { spawnBackgroundSubagentTask: spawnBackgroundSubagentTask2, waitForBackgroundSubagentAgentId: waitForBackgroundSubagentAgentId2 } = await Promise.resolve().then(() => (init_task(), exports_task));
@@ -497464,11 +498082,16 @@ async function startReflectionArenaRun(options3) {
             error: error54,
             agentId,
             conversationId,
+            model: resolvedModel,
             stepCount,
             durationMs,
             report
           }) => {
             try {
+              const [memoryHead, memoryNoChanges] = await Promise.all([
+                getGitHead(candidate.worktree.worktreeDir),
+                reflectionMemoryWorktreeHasNoChanges(candidate.worktree)
+              ]);
               emitReflectionRunEnd({
                 parentAgentId: options3.agentId,
                 triggerSource: options3.triggerSource,
@@ -497478,9 +498101,9 @@ async function startReflectionArenaRun(options3) {
                 error: error54,
                 stepCount,
                 durationMs,
+                model: resolvedModel ?? model,
                 feedbackContext: {
-                  ...options3.feedbackContext,
-                  model
+                  ...options3.feedbackContext
                 }
               });
               if (!success2 && model !== REFLECTION_ARENA_MODEL_A_DEFAULT && isRetryableArenaModelError(error54)) {
@@ -497501,9 +498124,12 @@ async function startReflectionArenaRun(options3) {
                   error: error54,
                   agentId,
                   conversationId,
+                  model: resolvedModel ?? model,
                   stepCount,
                   durationMs,
-                  report
+                  report,
+                  ...memoryHead ? { memoryHead } : {},
+                  ...memoryNoChanges !== undefined ? { memoryNoChanges } : {}
                 }
               });
               if (updated.status === "awaiting_choice") {
@@ -497561,14 +498187,19 @@ async function finalizeReflectionArenaChoice(options3) {
       throw new Error(`Unknown reflection arena label: ${options3.choice}`);
     }
     memoryBaseCommit = chosen.worktree.baseHead;
-    memoryCandidateCommit = await getGitHead(chosen.worktree.worktreeDir);
+    memoryCandidateCommit = await getGitHead(chosen.worktree.worktreeDir) ?? chosen.result?.memoryHead ?? null;
     const finalized = await finalizeReflectionMemoryWorktreeLaunch({
       worktree: chosen.worktree,
       subagentSuccess: chosen.result?.success ?? false,
       subagentError: chosen.result?.error,
-      agentId: run.agentId,
+      knownNoChanges: candidateIsConfirmedNoOp(chosen),
+      ...getReflectionFinalizationContext(run.agentId),
       conversationId: run.conversationId,
       subagentAgentId: chosen.result?.agentId,
+      model: chosen.result?.model ?? chosen.model,
+      telemetryContext: {
+        triggerSource: run.triggerSource ?? "compaction-event"
+      },
       recompileByConversation: options3.recompileByConversation,
       recompileQueuedByConversation: options3.recompileQueuedByConversation,
       logRecompileFailure: (message) => debugWarn("memory", message)
@@ -497581,7 +498212,8 @@ async function finalizeReflectionArenaChoice(options3) {
     }
     discarded.push(candidate.label);
     await finalizeReflectionMemoryWorktree(candidate.worktree, {
-      shouldMerge: false
+      shouldMerge: false,
+      knownNoChanges: candidateIsConfirmedNoOp(candidate)
     });
   }
   await finalizeAutoReflectionPayload(run.agentId, run.conversationId, run.payloadPath, run.endSnapshotLine, integration ? reflectionIntegrationConsumesTranscript(integration) : false);
@@ -497621,6 +498253,7 @@ async function finalizeReflectionArenaChoice(options3) {
 }
 var execFile18, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS = 1e6, REFLECTION_ARENA_MODEL_A_DEFAULT = "letta/auto-memory", REFLECTION_ARENA_COMPARISON_MODEL_POOL, ANSI_BOLD = "\x1B[1m", ANSI_CYAN = "\x1B[36m", ANSI_MAGENTA = "\x1B[35m", ANSI_RESET_BOLD = "\x1B[22m", ANSI_RESET_FOREGROUND = "\x1B[39m", REFLECTION_ARENA_CANDIDATE_COUNT = 2, REFLECTION_ARENA_CHOICE_QUESTION = "Which reflection should be merged?", REFLECTION_ARENA_NOTES_QUESTION = "Optional feedback for this choice?", updateLocks;
 var init_reflection_arena = __esm(() => {
+  init_memory_filesystem2();
   init_memory_worktree();
   init_app_urls();
   init_reflection_arena_hf_upload();
@@ -498192,13 +498825,13 @@ __export(exports_terminal_keybinding_installer, {
 });
 import {
   copyFileSync as copyFileSync6,
-  existsSync as existsSync63,
+  existsSync as existsSync64,
   mkdirSync as mkdirSync45,
   readFileSync as readFileSync41,
   writeFileSync as writeFileSync34
 } from "node:fs";
 import { homedir as homedir47, platform as platform10 } from "node:os";
-import { dirname as dirname35, join as join82 } from "node:path";
+import { dirname as dirname35, join as join83 } from "node:path";
 function detectTerminalType() {
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_CHANNEL) {
     return "cursor";
@@ -498230,16 +498863,16 @@ function getKeybindingsPath(terminal) {
   }[terminal];
   const os8 = platform10();
   if (os8 === "darwin") {
-    return join82(homedir47(), "Library", "Application Support", appName, "User", "keybindings.json");
+    return join83(homedir47(), "Library", "Application Support", appName, "User", "keybindings.json");
   }
   if (os8 === "win32") {
     const appData = process.env.APPDATA;
     if (!appData)
       return null;
-    return join82(appData, appName, "User", "keybindings.json");
+    return join83(appData, appName, "User", "keybindings.json");
   }
   if (os8 === "linux") {
-    return join82(homedir47(), ".config", appName, "User", "keybindings.json");
+    return join83(homedir47(), ".config", appName, "User", "keybindings.json");
   }
   return null;
 }
@@ -498261,7 +498894,7 @@ function parseKeybindings(content) {
   }
 }
 function keybindingExists(keybindingsPath) {
-  if (!existsSync63(keybindingsPath))
+  if (!existsSync64(keybindingsPath))
     return false;
   try {
     const content = readFileSync41(keybindingsPath, { encoding: "utf-8" });
@@ -498274,7 +498907,7 @@ function keybindingExists(keybindingsPath) {
   }
 }
 function createBackup(keybindingsPath) {
-  if (!existsSync63(keybindingsPath))
+  if (!existsSync64(keybindingsPath))
     return null;
   const backupPath = `${keybindingsPath}.letta-backup`;
   try {
@@ -498290,12 +498923,12 @@ function installKeybinding(keybindingsPath) {
       return { success: true, alreadyExists: true };
     }
     const parentDir = dirname35(keybindingsPath);
-    if (!existsSync63(parentDir)) {
+    if (!existsSync64(parentDir)) {
       mkdirSync45(parentDir, { recursive: true });
     }
     let keybindings = [];
     let backupPath = null;
-    if (existsSync63(keybindingsPath)) {
+    if (existsSync64(keybindingsPath)) {
       backupPath = createBackup(keybindingsPath);
       const content = readFileSync41(keybindingsPath, { encoding: "utf-8" });
       const parsed = parseKeybindings(content);
@@ -498325,7 +498958,7 @@ function installKeybinding(keybindingsPath) {
 }
 function removeKeybinding(keybindingsPath) {
   try {
-    if (!existsSync63(keybindingsPath)) {
+    if (!existsSync64(keybindingsPath)) {
       return { success: true };
     }
     const content = readFileSync41(keybindingsPath, { encoding: "utf-8" });
@@ -498392,14 +499025,14 @@ function getWezTermConfigPath() {
   }
   const xdgConfig = process.env.XDG_CONFIG_HOME;
   if (xdgConfig) {
-    const xdgPath = join82(xdgConfig, "wezterm", "wezterm.lua");
-    if (existsSync63(xdgPath))
+    const xdgPath = join83(xdgConfig, "wezterm", "wezterm.lua");
+    if (existsSync64(xdgPath))
       return xdgPath;
   }
-  const configPath = join82(homedir47(), ".config", "wezterm", "wezterm.lua");
-  if (existsSync63(configPath))
+  const configPath = join83(homedir47(), ".config", "wezterm", "wezterm.lua");
+  if (existsSync64(configPath))
     return configPath;
-  return join82(homedir47(), ".wezterm.lua");
+  return join83(homedir47(), ".wezterm.lua");
 }
 function stripLuaCommentsFromLine(line, blockCommentEnd) {
   let code2 = "";
@@ -498502,7 +499135,7 @@ ${WEZTERM_DELETE_FIX}
 `;
 }
 function wezTermDeleteFixExists(configPath) {
-  if (!existsSync63(configPath))
+  if (!existsSync64(configPath))
     return false;
   try {
     const content = readFileSync41(configPath, { encoding: "utf-8" });
@@ -498519,14 +499152,14 @@ function installWezTermDeleteFix() {
     }
     let content = "";
     let backupPath = null;
-    if (existsSync63(configPath)) {
+    if (existsSync64(configPath)) {
       backupPath = `${configPath}.letta-backup`;
       copyFileSync6(configPath, backupPath);
       content = readFileSync41(configPath, { encoding: "utf-8" });
     }
     content = injectWezTermDeleteFix(content);
     const parentDir = dirname35(configPath);
-    if (!existsSync63(parentDir)) {
+    if (!existsSync64(parentDir)) {
       mkdirSync45(parentDir, { recursive: true });
     }
     writeFileSync34(configPath, content, { encoding: "utf-8" });
@@ -498578,9 +499211,9 @@ __export(exports_settings2, {
   getSetting: () => getSetting
 });
 import { homedir as homedir48 } from "node:os";
-import { join as join83 } from "node:path";
+import { join as join84 } from "node:path";
 function getSettingsPath() {
-  return join83(homedir48(), ".letta", "settings.json");
+  return join84(homedir48(), ".letta", "settings.json");
 }
 async function loadSettings() {
   const settingsPath = getSettingsPath();
@@ -498617,7 +499250,7 @@ async function getSetting(key2) {
   return settings3[key2];
 }
 function getProjectSettingsPath() {
-  return join83(process.cwd(), ".letta", "settings.local.json");
+  return join84(process.cwd(), ".letta", "settings.local.json");
 }
 async function loadProjectSettings() {
   const settingsPath = getProjectSettingsPath();
@@ -498635,7 +499268,7 @@ async function loadProjectSettings() {
 }
 async function saveProjectSettings(settings3) {
   const settingsPath = getProjectSettingsPath();
-  const dirPath = join83(process.cwd(), ".letta");
+  const dirPath = join84(process.cwd(), ".letta");
   try {
     if (!exists(dirPath)) {
       await mkdir(dirPath, { recursive: true });
@@ -498806,7 +499439,7 @@ var init_registry2 = __esm(() => {
       }
     },
     "/sleeptime": {
-      desc: "Configure sleep-time reflection trigger settings",
+      desc: "Configure sleep-time reflection trigger and merge settings",
       order: 15.5,
       noArgs: true,
       handler: () => {
@@ -499674,10 +500307,10 @@ var init_InlineBashApproval = __esm(async () => {
 });
 
 // src/cli/components/DiffRenderer.tsx
-import { relative as relative16 } from "node:path";
+import { relative as relative15 } from "node:path";
 function formatDisplayPath4(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative16(cwd2, filePath);
+  const relativePath = relative15(cwd2, filePath);
   if (relativePath.startsWith("..")) {
     return filePath;
   }
@@ -500036,10 +500669,10 @@ var init_DiffRenderer = __esm(async () => {
 });
 
 // src/cli/components/AdvancedDiffRenderer.tsx
-import { relative as relative17 } from "node:path";
+import { relative as relative16 } from "node:path";
 function formatRelativePath(filePath) {
   const cwd2 = process.cwd();
-  const relativePath = relative17(cwd2, filePath);
+  const relativePath = relative16(cwd2, filePath);
   return relativePath.startsWith("..") ? relativePath : `./${relativePath}`;
 }
 function padLeft(n, width) {
@@ -500321,7 +500954,7 @@ function AdvancedDiffRenderer(props) {
   }
   const { hunks } = result;
   const filePath = props.filePath;
-  const relative18 = formatRelativePath(filePath);
+  const relative17 = formatRelativePath(filePath);
   const lang41 = languageFromPath(filePath);
   const shouldHighlight = lang41 && !exceedsAdvancedDiffHighlightLimits(hunks);
   const hunkSyntaxLines = [];
@@ -500344,7 +500977,7 @@ function AdvancedDiffRenderer(props) {
   const rows = buildAdvancedDiffRows(hunks, hunkSyntaxLines);
   const maxDisplayNo = rows.reduce((m4, r5) => Math.max(m4, r5.displayNo), 1);
   const gutterWidth = String(maxDisplayNo).length;
-  const header = props.kind === "write" ? `Wrote changes to ${relative18}` : `Updated ${relative18}`;
+  const header = props.kind === "write" ? `Wrote changes to ${relative17}` : `Updated ${relative17}`;
   if (rows.length === 0) {
     const noChangesGutter = 4;
     return /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
@@ -500395,7 +501028,7 @@ function AdvancedDiffRenderer(props) {
                   "No changes to ",
                   /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Text2, {
                     bold: true,
-                    children: relative18
+                    children: relative17
                   }, undefined, false, undefined, this),
                   " (file content identical)"
                 ]
@@ -500501,9 +501134,9 @@ function getHeaderText(fileEdit) {
       } else if (operations.length === 1) {
         const op = operations[0];
         if (op) {
-          const { relative: relative19 } = __require("node:path");
+          const { relative: relative18 } = __require("node:path");
           const cwd3 = process.cwd();
-          const relPath2 = relative19(cwd3, op.path);
+          const relPath2 = relative18(cwd3, op.path);
           const displayPath2 = relPath2.startsWith("..") ? op.path : relPath2;
           if (op.kind === "add") {
             return `Write to ${displayPath2}?`;
@@ -500517,14 +501150,14 @@ function getHeaderText(fileEdit) {
     }
     return "Apply patch?";
   }
-  const { relative: relative18 } = __require("node:path");
+  const { relative: relative17 } = __require("node:path");
   const cwd2 = process.cwd();
-  const relPath = relative18(cwd2, fileEdit.filePath);
+  const relPath = relative17(cwd2, fileEdit.filePath);
   const displayPath = relPath.startsWith("..") ? fileEdit.filePath : relPath;
   if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
-    const { existsSync: existsSync64 } = __require("node:fs");
+    const { existsSync: existsSync65 } = __require("node:fs");
     try {
-      if (existsSync64(fileEdit.filePath)) {
+      if (existsSync65(fileEdit.filePath)) {
         return `Overwrite ${displayPath}?`;
       }
     } catch {}
@@ -500702,9 +501335,9 @@ var init_InlineFileEditApproval = __esm(async () => {
           children: fileEdit.patchInput ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
             flexDirection: "column",
             children: parsePatchOperations2(fileEdit.patchInput).map((op, idx) => {
-              const { relative: relative18 } = __require("node:path");
+              const { relative: relative17 } = __require("node:path");
               const cwd2 = process.cwd();
-              const relPath = relative18(cwd2, op.path);
+              const relPath = relative17(cwd2, op.path);
               const displayPath = relPath.startsWith("..") ? op.path : relPath;
               const diffKey = fileEdit.toolCallId ? `${fileEdit.toolCallId}:${op.path}` : undefined;
               const opDiff = diffKey && allDiffs ? allDiffs.get(diffKey) : undefined;
@@ -510019,7 +510652,7 @@ var init_agents8 = __esm(() => {
 // src/cli/commands/install-github-app.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
 import {
-  existsSync as existsSync64,
+  existsSync as existsSync65,
   mkdirSync as mkdirSync46,
   mkdtempSync as mkdtempSync5,
   readFileSync as readFileSync42,
@@ -510027,7 +510660,7 @@ import {
   writeFileSync as writeFileSync35
 } from "node:fs";
 import { tmpdir as tmpdir11 } from "node:os";
-import { dirname as dirname36, join as join84 } from "node:path";
+import { dirname as dirname36, join as join85 } from "node:path";
 function runCommand(command, args, cwd2, input) {
   try {
     return execFileSync8(command, args, {
@@ -510248,8 +510881,8 @@ async function createLettaAgent(apiKey, name) {
   return createMinimalAgent(apiKey, name);
 }
 function cloneRepoToTemp(repo) {
-  const tempDir = mkdtempSync5(join84(tmpdir11(), "letta-install-github-app-"));
-  const repoDir = join84(tempDir, "repo");
+  const tempDir = mkdtempSync5(join85(tmpdir11(), "letta-install-github-app-"));
+  const repoDir = join85(tempDir, "repo");
   runCommand("gh", ["repo", "clone", repo, repoDir, "--", "--depth=1"]);
   return { tempDir, repoDir };
 }
@@ -510260,13 +510893,13 @@ function runGit7(args, cwd2) {
   return runCommand("git", args, cwd2);
 }
 function writeWorkflow(repoDir, workflowPath, content) {
-  const absolutePath = join84(repoDir, workflowPath);
-  if (!existsSync64(dirname36(absolutePath))) {
+  const absolutePath = join85(repoDir, workflowPath);
+  if (!existsSync65(dirname36(absolutePath))) {
     mkdirSync46(dirname36(absolutePath), { recursive: true });
   }
   const next = `${content.trimEnd()}
 `;
-  if (existsSync64(absolutePath)) {
+  if (existsSync65(absolutePath)) {
     const previous = readFileSync42(absolutePath, "utf8");
     if (previous === next) {
       return false;
@@ -511223,6 +511856,7 @@ function LettaLoginOverlay({
     command: "/login",
     title: "Sign in with Letta",
     children: /* @__PURE__ */ jsx_dev_runtime63.jsxDEV(LettaLoginView, {
+      activateCloudBackend: false,
       onComplete,
       onCancel
     }, undefined, false, undefined, this)
@@ -514155,9 +514789,9 @@ __export(exports_generate_memory_viewer, {
   generateAndOpenMemoryViewer: () => generateAndOpenMemoryViewer
 });
 import { execFile as execFileCb7 } from "node:child_process";
-import { chmodSync as chmodSync7, existsSync as existsSync65, mkdirSync as mkdirSync47, writeFileSync as writeFileSync36 } from "node:fs";
+import { chmodSync as chmodSync7, existsSync as existsSync66, mkdirSync as mkdirSync47, writeFileSync as writeFileSync36 } from "node:fs";
 import { homedir as homedir50 } from "node:os";
-import { join as join85 } from "node:path";
+import { join as join86 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 function messagesFromOverview(overview) {
   return overview.messages?.map((message) => ({
@@ -514466,7 +515100,7 @@ ${m4.body}` : m4.subject;
 async function generateAndOpenMemoryViewer(agentId, options3) {
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
   const repoDir = memoryRoot;
-  if (!existsSync65(join85(repoDir, ".git"))) {
+  if (!existsSync66(join86(repoDir, ".git"))) {
     throw new Error("Memory viewer requires memfs. Run /memfs enable first.");
   }
   const data = await collectMemoryData(agentId, repoDir, memoryRoot, options3?.conversationId);
@@ -514476,13 +515110,13 @@ async function generateAndOpenMemoryViewer(agentId, options3) {
   data.context = applyContextUsageSnapshot(data.context, options3?.contextUsage);
   const jsonPayload = JSON.stringify(data).replace(/</g, "\\u003c");
   const html5 = memory_viewer_template_default.replace("<!--LETTA_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync65(VIEWERS_DIR)) {
+  if (!existsSync66(VIEWERS_DIR)) {
     mkdirSync47(VIEWERS_DIR, { recursive: true, mode: 448 });
   }
   try {
     chmodSync7(VIEWERS_DIR, 448);
   } catch {}
-  const filePath = join85(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
+  const filePath = join86(VIEWERS_DIR, `memory-${encodeURIComponent(agentId)}.html`);
   writeFileSync36(filePath, html5);
   chmodSync7(filePath, 384);
   const skipOpen = Boolean(process.env.TMUX) || Boolean(process.env.SSH_CONNECTION) || Boolean(process.env.SSH_TTY);
@@ -514507,13 +515141,13 @@ var init_generate_memory_viewer = __esm(() => {
   init_local_memory_context();
   init_memory_viewer_template();
   execFile19 = promisify17(execFileCb7);
-  VIEWERS_DIR = join85(homedir50(), ".letta", "viewers");
+  VIEWERS_DIR = join86(homedir50(), ".letta", "viewers");
   REFLECTION_PATTERN = /\(reflection\)|🔮|reflection:/i;
 });
 
 // src/cli/components/MemfsTreeViewer.tsx
-import { existsSync as existsSync66 } from "node:fs";
-import { join as join86 } from "node:path";
+import { existsSync as existsSync67 } from "node:fs";
+import { join as join87 } from "node:path";
 function renderTreePrefix(node) {
   let prefix = "";
   for (let i4 = 0;i4 < node.depth; i4++) {
@@ -514541,8 +515175,8 @@ function MemfsTreeViewer({
   const [status, setStatus] = import_react87.useState(null);
   const statusTimerRef = import_react87.useRef(null);
   const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
-  const memoryExists = existsSync66(memoryRoot);
-  const hasGitRepo = import_react87.useMemo(() => existsSync66(join86(memoryRoot, ".git")), [memoryRoot]);
+  const memoryExists = existsSync67(memoryRoot);
+  const hasGitRepo = import_react87.useMemo(() => existsSync67(join87(memoryRoot, ".git")), [memoryRoot]);
   function showStatus(msg, durationMs) {
     if (statusTimerRef.current)
       clearTimeout(statusTimerRef.current);
@@ -516919,10 +517553,10 @@ var init_PersonalitySelector = __esm(async () => {
 // src/utils/aws-credentials.ts
 import { readFile as readFile30 } from "node:fs/promises";
 import { homedir as homedir51 } from "node:os";
-import { join as join87 } from "node:path";
+import { join as join88 } from "node:path";
 async function parseAwsCredentials() {
-  const credentialsPath = join87(homedir51(), ".aws", "credentials");
-  const configPath = join87(homedir51(), ".aws", "config");
+  const credentialsPath = join88(homedir51(), ".aws", "credentials");
+  const configPath = join88(homedir51(), ".aws", "config");
   const profiles = new Map;
   try {
     const content = await readFile30(credentialsPath, "utf-8");
@@ -518501,8 +519135,8 @@ function SkillsDialog({ onClose, agentId }) {
       try {
         const { discoverSkills: discoverSkills2, SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
         const { getSkillsDirectory: getSkillsDirectory2, getSkillSources: getSkillSources2 } = await Promise.resolve().then(() => (init_context(), exports_context));
-        const { join: join88 } = await import("node:path");
-        const skillsDir = getSkillsDirectory2() || join88(process.cwd(), SKILLS_DIR2);
+        const { join: join89 } = await import("node:path");
+        const skillsDir = getSkillsDirectory2() || join89(process.cwd(), SKILLS_DIR2);
         const result = await discoverSkills2(skillsDir, agentId, {
           sources: getSkillSources2()
         });
@@ -518717,6 +519351,36 @@ var init_SkillsDialog = __esm(async () => {
 });
 
 // src/cli/components/SleeptimeSelector.tsx
+function triggerFocusRow(trigger) {
+  switch (trigger) {
+    case "off":
+      return "trigger-off";
+    case "step-count":
+      return "trigger-step-count";
+    case "compaction-event":
+      return "trigger-compaction";
+  }
+}
+function mergeFocusRow(merge3) {
+  return merge3 === "explicit" ? "merge-explicit" : "merge-auto";
+}
+function ChoiceRow(props) {
+  const { focused, selected, children } = props;
+  return /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
+    flexDirection: "row",
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
+        children: focused ? "> " : "  "
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
+        backgroundColor: selected ? colors.selector.itemHighlighted : undefined,
+        color: selected ? "black" : undefined,
+        bold: selected,
+        children
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
 function cycleOption(options3, current, direction) {
   if (options3.length === 0) {
     return current;
@@ -518729,7 +519393,9 @@ function cycleOption(options3, current, direction) {
 function parseInitialState(initialSettings) {
   return {
     trigger: initialSettings.trigger === "off" || initialSettings.trigger === "step-count" || initialSettings.trigger === "compaction-event" ? initialSettings.trigger : "step-count",
-    stepCount: String(Number.isInteger(initialSettings.stepCount) && initialSettings.stepCount > 0 ? initialSettings.stepCount : Number(DEFAULT_STEP_COUNT2))
+    stepCount: String(Number.isInteger(initialSettings.stepCount) && initialSettings.stepCount > 0 ? initialSettings.stepCount : Number(DEFAULT_STEP_COUNT2)),
+    merge: initialSettings.merge === "explicit" ? "explicit" : "auto",
+    mergeInstructions: initialSettings.mergeInstructions ?? ""
   };
 }
 function parseStepCount(raw2) {
@@ -518752,19 +519418,28 @@ function SleeptimeSelector({
   const initialState = import_react96.useMemo(() => parseInitialState(initialSettings), [initialSettings]);
   const [trigger, setTrigger] = import_react96.useState(initialState.trigger);
   const [stepCountInput, setStepCountInput] = import_react96.useState(initialState.stepCount);
-  const [focusRow, setFocusRow] = import_react96.useState("trigger");
+  const [merge3, setMerge] = import_react96.useState(initialState.merge);
+  const [mergeInstructions, setMergeInstructions] = import_react96.useState(initialState.mergeInstructions);
+  const [focusRow, setFocusRow] = import_react96.useState(() => triggerFocusRow(initialState.trigger));
   const [validationError, setValidationError] = import_react96.useState(null);
   const visibleRows = import_react96.useMemo(() => {
-    const rows = ["trigger"];
-    if (trigger === "step-count") {
-      rows.push("step-count");
+    const rows = [
+      "trigger-off",
+      "trigger-step-count",
+      "trigger-compaction",
+      "merge-auto",
+      "merge-explicit"
+    ];
+    if (merge3 === "explicit") {
+      rows.push("merge-instructions");
     }
     return rows;
-  }, [trigger]);
-  const isEditingStepCount = focusRow === "step-count" && trigger === "step-count";
+  }, [merge3]);
+  const isEditingStepCount = focusRow === "trigger-step-count";
+  const isEditingMergeInstructions = focusRow === "merge-instructions" && merge3 === "explicit";
   import_react96.useEffect(() => {
     if (!visibleRows.includes(focusRow)) {
-      setFocusRow(visibleRows[visibleRows.length - 1] ?? "trigger");
+      setFocusRow(visibleRows[visibleRows.length - 1] ?? "trigger-off");
     }
   }, [focusRow, visibleRows]);
   const saveSelection = () => {
@@ -518776,16 +519451,42 @@ function SleeptimeSelector({
       }
       onSave({
         trigger,
-        stepCount
+        stepCount,
+        merge: merge3,
+        mergeInstructions
       });
       return;
     }
     const fallbackStepCount = parseStepCount(stepCountInput) ?? Number(DEFAULT_STEP_COUNT2);
     onSave({
       trigger,
-      stepCount: fallbackStepCount
+      stepCount: fallbackStepCount,
+      merge: merge3,
+      mergeInstructions
     });
   };
+  const selectFocusedOption = () => {
+    switch (focusRow) {
+      case "trigger-off":
+        setTrigger("off");
+        break;
+      case "trigger-step-count":
+        setTrigger("step-count");
+        break;
+      case "trigger-compaction":
+        setTrigger("compaction-event");
+        break;
+      case "merge-auto":
+        setMerge("auto");
+        break;
+      case "merge-explicit":
+        setMerge("explicit");
+        break;
+      case "merge-instructions":
+        break;
+    }
+    setValidationError(null);
+  };
   use_input_default((input, key2) => {
     if (key2.ctrl && input === "c") {
       onCancel();
@@ -518805,35 +519506,55 @@ function SleeptimeSelector({
       saveSelection();
       return;
     }
-    if (key2.upArrow || key2.downArrow) {
+    if (key2.upArrow || key2.downArrow || key2.tab) {
       if (visibleRows.length === 0)
         return;
       setValidationError(null);
-      const direction = key2.downArrow ? 1 : -1;
+      const direction = key2.upArrow ? -1 : 1;
       const currentIndex = visibleRows.indexOf(focusRow);
       const safeIndex = currentIndex >= 0 ? currentIndex : 0;
       const nextIndex = (safeIndex + direction + visibleRows.length) % visibleRows.length;
-      const nextRow = visibleRows[nextIndex] ?? "trigger";
+      const nextRow = visibleRows[nextIndex] ?? "trigger-off";
       setFocusRow(nextRow);
       return;
     }
-    if (key2.leftArrow || key2.rightArrow || key2.tab) {
+    if (input === " " && !isEditingMergeInstructions) {
+      selectFocusedOption();
+      return;
+    }
+    if (key2.leftArrow || key2.rightArrow) {
       setValidationError(null);
       const direction = key2.leftArrow ? -1 : 1;
-      if (focusRow === "trigger") {
-        setTrigger((prev) => cycleOption(TRIGGER_OPTIONS, prev, direction));
+      if (focusRow.startsWith("trigger-")) {
+        const nextTrigger = cycleOption(TRIGGER_OPTIONS, trigger, direction);
+        setTrigger(nextTrigger);
+        setFocusRow(triggerFocusRow(nextTrigger));
+      } else if (focusRow.startsWith("merge-")) {
+        const nextMerge = cycleOption(MERGE_OPTIONS, merge3, direction);
+        setMerge(nextMerge);
+        setFocusRow(mergeFocusRow(nextMerge));
       }
       return;
     }
-    if (!isEditingStepCount)
+    if (!isEditingStepCount && !isEditingMergeInstructions)
       return;
     if (key2.backspace || key2.delete) {
-      setStepCountInput((prev) => prev.slice(0, -1));
+      if (isEditingStepCount) {
+        setTrigger("step-count");
+        setStepCountInput((prev) => prev.slice(0, -1));
+      } else {
+        setMergeInstructions((prev) => prev.slice(0, -1));
+      }
       setValidationError(null);
       return;
     }
     if (input && input.length > 0 && !key2.ctrl && !key2.meta && !key2.tab && !key2.upArrow && !key2.downArrow && !key2.leftArrow && !key2.rightArrow) {
-      setStepCountInput((prev) => `${prev}${input}`);
+      if (isEditingStepCount) {
+        setTrigger("step-count");
+        setStepCountInput((prev) => `${prev}${input}`);
+      } else {
+        setMergeInstructions((prev) => `${prev}${input}`);
+      }
       setValidationError(null);
     }
   });
@@ -518851,79 +519572,73 @@ function SleeptimeSelector({
       /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
         height: 1
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-        bold: true,
-        color: colors.selector.title,
-        children: "Configure your sleep-time (dream) settings"
-      }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
-        height: 1
-      }, undefined, false, undefined, this),
       memfsEnabled ? /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(jsx_dev_runtime74.Fragment, {
         children: [
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
+            bold: true,
+            color: colors.selector.title,
+            children: "Dream Settings"
+          }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
-            flexDirection: "row",
+            height: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(ChoiceRow, {
+            focused: focusRow === "trigger-off",
+            selected: trigger === "off",
+            children: " Off "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(ChoiceRow, {
+            focused: focusRow === "trigger-step-count",
+            selected: trigger === "step-count",
+            children: ` Every [${stepCountInput}${isEditingStepCount ? "█" : ""}] steps `
+          }, undefined, false, undefined, this),
+          validationError && /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
+            color: colors.error.text,
+            children: `    Error: ${validationError}`
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(ChoiceRow, {
+            focused: focusRow === "trigger-compaction",
+            selected: trigger === "compaction-event",
+            children: " On compaction "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
+            height: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
+            bold: true,
+            color: colors.selector.title,
+            children: "Memory updates"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
+            height: 1
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(ChoiceRow, {
+            focused: focusRow === "merge-auto",
+            selected: merge3 === "auto",
+            children: " Apply automatically "
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(ChoiceRow, {
+            focused: focusRow === "merge-explicit",
+            selected: merge3 === "explicit",
+            children: " Agent reviews before applying "
+          }, undefined, false, undefined, this),
+          merge3 === "explicit" && /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(jsx_dev_runtime74.Fragment, {
             children: [
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                children: focusRow === "trigger" ? "> " : "  "
+              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
+                height: 1
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
                 bold: true,
-                children: "Trigger event:"
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                children: "   "
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                backgroundColor: trigger === "off" ? colors.selector.itemHighlighted : undefined,
-                color: trigger === "off" ? "black" : undefined,
-                bold: trigger === "off",
-                children: " Off "
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                children: " "
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                backgroundColor: trigger === "step-count" ? colors.selector.itemHighlighted : undefined,
-                color: trigger === "step-count" ? "black" : undefined,
-                bold: trigger === "step-count",
-                children: " Step count "
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                children: " "
-              }, undefined, false, undefined, this),
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                backgroundColor: trigger === "compaction-event" ? colors.selector.itemHighlighted : undefined,
-                color: trigger === "compaction-event" ? "black" : undefined,
-                bold: trigger === "compaction-event",
-                children: " Compaction event "
-              }, undefined, false, undefined, this)
-            ]
-          }, undefined, true, undefined, this),
-          trigger === "step-count" && /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(jsx_dev_runtime74.Fragment, {
-            children: [
-              /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
-                height: 1
+                children: "  Review instructions"
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
                 flexDirection: "row",
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                    children: focusRow === "step-count" ? "> " : "  "
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                    bold: true,
-                    children: "Step count: "
+                    children: focusRow === "merge-instructions" ? "> " : "  "
                   }, undefined, false, undefined, this),
                   /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                    children: stepCountInput
-                  }, undefined, false, undefined, this),
-                  isEditingStepCount && /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                    children: "█"
-                  }, undefined, false, undefined, this),
-                  validationError && /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-                    color: colors.error.text,
-                    children: ` (error: ${validationError})`
+                    children: `[${mergeInstructions}${isEditingMergeInstructions ? "█" : ""}]`
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this)
@@ -518934,13 +519649,13 @@ function SleeptimeSelector({
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
             dimColor: true,
-            children: "  Enter to save · ↑↓ rows · ←→/Tab options · Esc cancel"
+            children: "  Enter save · ↑↓/Tab move · Space select · ←→ options · Esc cancel"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(jsx_dev_runtime74.Fragment, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Text2, {
-            children: "Sleep-time reflection requires the memory filesystem (memfs) to be enabled for this agent."
+            children: "Dream settings require the memory filesystem (MemFS) to be enabled for this agent."
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime74.jsxDEV(Box_default, {
             height: 1
@@ -518954,7 +519669,7 @@ function SleeptimeSelector({
     ]
   }, undefined, true, undefined, this);
 }
-var import_react96, jsx_dev_runtime74, SOLID_LINE18 = "─", DEFAULT_STEP_COUNT2 = "25", TRIGGER_OPTIONS;
+var import_react96, jsx_dev_runtime74, SOLID_LINE18 = "─", DEFAULT_STEP_COUNT2 = "25", TRIGGER_OPTIONS, MERGE_OPTIONS;
 var init_SleeptimeSelector = __esm(async () => {
   init_use_terminal_width();
   init_colors();
@@ -518969,6 +519684,7 @@ var init_SleeptimeSelector = __esm(async () => {
     "step-count",
     "compaction-event"
   ];
+  MERGE_OPTIONS = ["auto", "explicit"];
 });
 
 // src/cli/components/StatusMessage.tsx
@@ -519683,7 +520399,8 @@ function parseEnterWorktreeResult(text2) {
 `);
   const firstLine = normalized.split(`
 `).find((line) => line.trim());
-  if (firstLine?.trim() !== "Created worktree.") {
+  const action3 = firstLine?.trim() === "Created worktree." ? "created" : firstLine?.trim() === "Switched to existing worktree." ? "switched" : null;
+  if (!action3) {
     return null;
   }
   const field = (name) => {
@@ -519691,11 +520408,12 @@ function parseEnterWorktreeResult(text2) {
     return match4?.[1]?.trim();
   };
   const result = {
+    action: action3,
     path: field("Path"),
     branch: field("Branch"),
     base: field("Base")
   };
-  if (normalized.includes("This conversation's working directory is now the new worktree.")) {
+  if (normalized.includes("This conversation's working directory is now the new worktree.") || normalized.includes("This conversation's working directory is now this worktree.")) {
     result.switchedCwd = true;
   } else if (normalized.includes("The conversation working directory was left unchanged.")) {
     result.switchedCwd = false;
@@ -519775,7 +520493,7 @@ function EnterWorktreeResultRenderer({
             flexGrow: 1,
             width: contentWidth,
             children: /* @__PURE__ */ jsx_dev_runtime79.jsxDEV(Text2, {
-              children: "Created worktree"
+              children: parsed.action === "created" ? "Created worktree" : "Switched to existing worktree"
             }, undefined, false, undefined, this)
           }, undefined, false, undefined, this)
         ]
@@ -520833,7 +521551,7 @@ var init_ToolCallMessageRich = __esm(async () => {
       let shellSemanticKind = null;
       let hasShellDescription = false;
       if (!isQuestionTool(rawName)) {
-        const parseArgs17 = () => {
+        const parseArgs18 = () => {
           if (!argsText.trim()) {
             return { formatted: null, parseable: true };
           }
@@ -520847,7 +521565,7 @@ var init_ToolCallMessageRich = __esm(async () => {
             return { formatted: null, parseable: false };
           }
         };
-        const { formatted, parseable } = parseArgs17();
+        const { formatted, parseable } = parseArgs18();
         const argsComplete = parseable || line.phase === "running" || line.phase === "finished" || !isStreaming;
         if (!argsComplete) {
           args = "(…)";
@@ -522407,9 +523125,9 @@ function getFileEditHeader(toolName, toolArgs) {
         } else if (operations.length === 1) {
           const op = operations[0];
           if (op) {
-            const { relative: relative19 } = __require("node:path");
+            const { relative: relative18 } = __require("node:path");
             const cwd3 = process.cwd();
-            const relPath2 = relative19(cwd3, op.path);
+            const relPath2 = relative18(cwd3, op.path);
             const displayPath3 = relPath2.startsWith("..") ? op.path : relPath2;
             if (op.kind === "add")
               return `Write to ${displayPath3}?`;
@@ -522423,14 +523141,14 @@ function getFileEditHeader(toolName, toolArgs) {
       return "Apply patch?";
     }
     const filePath = args.file_path || "";
-    const { relative: relative18 } = __require("node:path");
+    const { relative: relative17 } = __require("node:path");
     const cwd2 = process.cwd();
-    const relPath = relative18(cwd2, filePath);
+    const relPath = relative17(cwd2, filePath);
     const displayPath2 = relPath.startsWith("..") ? filePath : relPath;
     if (t2 === "write" || t2 === "write_file" || t2 === "writefile" || t2 === "write_file_gemini" || t2 === "writefilegemini") {
-      const { existsSync: existsSync67 } = __require("node:fs");
+      const { existsSync: existsSync68 } = __require("node:fs");
       try {
-        if (existsSync67(filePath)) {
+        if (existsSync68(filePath)) {
           return `Overwrite ${displayPath2}?`;
         }
       } catch {}
@@ -522513,9 +523231,9 @@ var init_ApprovalPreview = __esm(async () => {
               /* @__PURE__ */ jsx_dev_runtime90.jsxDEV(Box_default, {
                 flexDirection: "column",
                 children: operations.map((op, idx) => {
-                  const { relative: relative18 } = __require("node:path");
+                  const { relative: relative17 } = __require("node:path");
                   const cwd2 = process.cwd();
-                  const relPath = relative18(cwd2, op.path);
+                  const relPath = relative17(cwd2, op.path);
                   const displayPath2 = relPath.startsWith("..") ? op.path : relPath;
                   const diffKey = toolCallId ? `${toolCallId}:${op.path}` : undefined;
                   const opDiff = diffKey && allDiffs ? allDiffs.get(diffKey) : undefined;
@@ -523064,7 +523782,7 @@ function updateCommandResult(buffersRef, refreshDerived, cmdId, input, output, s
   buffersRef.current.byId.set(cmdId, line);
   refreshDerived();
 }
-function parseArgs17(msg) {
+function parseArgs18(msg) {
   return msg.trim().split(/\s+/).filter(Boolean);
 }
 function formatConnectUsage() {
@@ -523419,7 +524137,7 @@ ${formatBedrockUsage2()}`, false);
   }
 }
 async function handleConnect(ctx, msg) {
-  const parts = parseArgs17(msg);
+  const parts = parseArgs18(msg);
   const providerToken = parts[1];
   if (!providerToken) {
     addCommandResult(ctx.buffersRef, ctx.refreshDerived, msg, formatConnectUsage(), false);
@@ -537770,9 +538488,9 @@ __export(exports_generate_diff_viewer, {
   generateAndOpenDiffViewer: () => generateAndOpenDiffViewer
 });
 import { execFile as execFileCb8 } from "node:child_process";
-import { chmodSync as chmodSync8, existsSync as existsSync67, mkdirSync as mkdirSync48, writeFileSync as writeFileSync37 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync68, mkdirSync as mkdirSync48, writeFileSync as writeFileSync37 } from "node:fs";
 import { homedir as homedir52 } from "node:os";
-import { isAbsolute as isAbsolute29, join as join88, resolve as resolve38 } from "node:path";
+import { isAbsolute as isAbsolute29, join as join89, resolve as resolve38 } from "node:path";
 import { promisify as promisify18 } from "node:util";
 async function runGit8(cwd2, args) {
   try {
@@ -537991,13 +538709,13 @@ async function generateAndOpenDiffViewer(targetPath) {
   };
   const jsonPayload = JSON.stringify(payload).replace(/</g, "\\u003c");
   const html5 = diff_viewer_template_default.replace("<!--LETTA_DIFF_DATA_PLACEHOLDER-->", () => jsonPayload);
-  if (!existsSync67(VIEWERS_DIR2)) {
+  if (!existsSync68(VIEWERS_DIR2)) {
     mkdirSync48(VIEWERS_DIR2, { recursive: true, mode: 448 });
   }
   try {
     chmodSync8(VIEWERS_DIR2, 448);
   } catch {}
-  const filePath = join88(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
+  const filePath = join89(VIEWERS_DIR2, `diff-${encodeURIComponent(worktreePath)}.html`);
   writeFileSync37(filePath, html5);
   chmodSync8(filePath, 384);
   const skipOpen = shouldSkipOpen();
@@ -538068,7 +538786,7 @@ var init_generate_diff_viewer = __esm(() => {
   init_ssr();
   init_diff_viewer_template();
   execFile20 = promisify18(execFileCb8);
-  VIEWERS_DIR2 = join88(homedir52(), ".letta", "viewers");
+  VIEWERS_DIR2 = join89(homedir52(), ".letta", "viewers");
   GIT_MAX_BUFFER = 50 * 1024 * 1024;
 });
 
@@ -540056,12 +540774,12 @@ __export(exports_shell_aliases, {
   expandAliases: () => expandAliases,
   clearAliasCache: () => clearAliasCache
 });
-import { existsSync as existsSync68, readFileSync as readFileSync43 } from "node:fs";
+import { existsSync as existsSync69, readFileSync as readFileSync43 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
-import { join as join89 } from "node:path";
+import { join as join90 } from "node:path";
 function parseAliasesFromFile(filePath) {
   const aliases = new Map;
-  if (!existsSync68(filePath)) {
+  if (!existsSync69(filePath)) {
     return aliases;
   }
   try {
@@ -540130,7 +540848,7 @@ function loadAliases(forceReload = false) {
   const home = homedir53();
   const allAliases = new Map;
   for (const file3 of ALIAS_FILES) {
-    const filePath = join89(home, file3);
+    const filePath = join90(home, file3);
     const fileAliases = parseAliasesFromFile(filePath);
     for (const [name, value] of fileAliases) {
       allAliases.set(name, value);
@@ -540312,13 +541030,14 @@ var init_use_bash_handlers = __esm(async () => {
 
 // src/cli/app/reflection.ts
 function formatReflectionSettings(settings3) {
+  const memoryUpdates = settings3.merge === "explicit" ? "agent reviews before applying" : "apply automatically";
   if (settings3.trigger === "off") {
-    return "Off";
+    return `Off, ${memoryUpdates}`;
   }
   if (settings3.trigger === "compaction-event") {
-    return "Compaction event";
+    return `On compaction, ${memoryUpdates}`;
   }
-  return `Step count (every ${settings3.stepCount} turns)`;
+  return `Every ${settings3.stepCount} steps, ${memoryUpdates}`;
 }
 
 // src/cli/app/use-configuration-handlers.ts
@@ -540472,7 +541191,7 @@ function useConfigurationHandlers(ctx) {
       const rawReasoningEffort = modelUpdateArgs?.reasoning_effort;
       const providerType = providerTypeFromUpdateArgs(modelUpdateArgs);
       const isOpenAICompatibleProxy = modelUpdateArgs?.[OPENAI_COMPATIBLE_PROXY_UPDATE_ARG] === true && providerType === "openai";
-      const usesDistinctXHighLabel = /Fable 5|Opus 4\.[78]|GPT-5\.6/.test(model2.label);
+      const usesDistinctXHighLabel = /Fable 5|Opus 4\.[78]|Opus 5|Sonnet 5|GPT-5\.6/.test(model2.label);
       const reasoningLevel = isOpenAICompatibleProxy && rawReasoningEffort === null ? "default" : typeof rawReasoningEffort === "string" ? rawReasoningEffort === "none" ? "no" : rawReasoningEffort === "xhigh" ? usesDistinctXHighLabel ? "extra-high" : "max" : rawReasoningEffort : modelUpdateArgs?.enable_reasoner === false ? "no" : null;
       const selectedContextWindow = Number(model2.updateArgs?.context_window) || undefined;
       const capabilitiesMap = getCachedModelReasoningCapabilities();
@@ -543840,7 +544559,7 @@ var init_use_queued_approval_submit = __esm(() => {
 
 // src/cli/app/use-reasoning-cycle.ts
 function supportsDistinctAnthropicXHighEffort2(modelHandle) {
-  return modelHandle.includes("claude-fable-5") || modelHandle.includes("claude-opus-4-7") || modelHandle.includes("claude-opus-4-8");
+  return modelHandle.includes("claude-fable-5") || modelHandle.includes("claude-opus-5") || modelHandle.includes("claude-sonnet-5") || modelHandle.includes("claude-opus-4-7") || modelHandle.includes("claude-opus-4-8");
 }
 function serviceTierForReasoningCycle(modelHandle, modelSettings) {
   if (!getChatGptFastRegistryHandleForModelHandle(modelHandle)) {
@@ -546424,7 +547143,7 @@ var init_mods2 = __esm(async () => {
 });
 
 // src/cli/helpers/chdir-command.ts
-import { realpath as realpath6, stat as stat17 } from "node:fs/promises";
+import { realpath as realpath5, stat as stat17 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
 import path46 from "node:path";
 function parseChdirCommand(input) {
@@ -546462,7 +547181,7 @@ function expandHome(value) {
 async function resolveChdirTarget(pathArg, currentWorkingDirectory) {
   const expanded = expandHome(pathArg);
   const resolved = path46.isAbsolute(expanded) ? expanded : path46.resolve(currentWorkingDirectory, expanded);
-  const normalized = await realpath6(resolved);
+  const normalized = await realpath5(resolved);
   const stats = await stat17(normalized);
   if (!stats.isDirectory()) {
     throw new Error(`Not a directory: ${normalized}`);
@@ -548252,7 +548971,7 @@ __export(exports_export, {
   packageSkills: () => packageSkills
 });
 import { readdir as readdir17, readFile as readFile32 } from "node:fs/promises";
-import { relative as relative18, resolve as resolve39 } from "node:path";
+import { relative as relative17, resolve as resolve39 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
   const skillNames = new Set;
@@ -548305,7 +549024,7 @@ async function readSkillFiles(skillDir) {
         await walk(fullPath);
       } else {
         const content = await readFile32(fullPath, "utf-8");
-        const relativePath = relative18(skillDir, fullPath).replace(/\\/g, "/");
+        const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
     }
@@ -548440,9 +549159,9 @@ var init_conversation_switch_alert = __esm(() => {
 
 // src/cli/app/use-submit-handler.ts
 import { randomUUID as randomUUID39 } from "node:crypto";
-import { existsSync as existsSync69, readFileSync as readFileSync44, renameSync as renameSync8, writeFileSync as writeFileSync38 } from "node:fs";
+import { existsSync as existsSync70, readFileSync as readFileSync44, renameSync as renameSync8, writeFileSync as writeFileSync38 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
-import { join as join90 } from "node:path";
+import { join as join91 } from "node:path";
 async function findCustomCommandByName(commandName) {
   const { findCustomCommand: findCustomCommand2 } = await Promise.resolve().then(() => (init_custom(), exports_custom));
   return findCustomCommand2(commandName);
@@ -549137,10 +549856,10 @@ ${SYSTEM_REMINDER_CLOSE}`),
           try {
             const memoryRoot = getScopedMemoryFilesystemRoot(agentId);
             const personaCandidates = [
-              join90(memoryRoot, "system", "persona.md"),
-              join90(memoryRoot, "memory", "system", "persona.md")
+              join91(memoryRoot, "system", "persona.md"),
+              join91(memoryRoot, "memory", "system", "persona.md")
             ];
-            const personaPath = personaCandidates.find((candidate) => existsSync69(candidate));
+            const personaPath = personaCandidates.find((candidate) => existsSync70(candidate));
             if (personaPath) {
               const personaContent = readFileSync44(personaPath, "utf-8");
               setCurrentPersonalityId(detectPersonalityFromPersonaFile(personaContent));
@@ -549650,8 +550369,7 @@ Tip: Use /clear instead to clear the current message buffer.`;
                   feedbackContext: {
                     parentAgentName: agentName,
                     parentAgentDescription: agentDescription,
-                    surface: "letta_code_tui",
-                    model: currentModelId
+                    surface: "letta_code_tui"
                   },
                   onReady: (message2, readyRun) => {
                     appendTaskNotificationEvents([message2]);
@@ -549669,7 +550387,6 @@ Tip: Use /clear instead to clear the current message buffer.`;
                   conversationId: compactConversationId,
                   memfsEnabled: isActiveMemfsEnabled(agentId),
                   triggerSource: "compaction-event",
-                  skipPendingWorktreeReminderScan: true,
                   description: AUTO_REFLECTION_DESCRIPTION,
                   completionConversationId: () => conversationIdRef.current,
                   recompileByConversation: systemPromptRecompileByConversationRef.current,
@@ -549680,8 +550397,7 @@ Tip: Use /clear instead to clear the current message buffer.`;
                   feedbackContext: {
                     parentAgentName: agentName,
                     parentAgentDescription: agentDescription,
-                    surface: "letta_code_tui",
-                    model: currentModelId
+                    surface: "letta_code_tui"
                   }
                 });
               }
@@ -550020,11 +550736,11 @@ Path: ${memoryDir}`, true);
           setCommandRunning(true);
           try {
             const memoryDir = getScopedMemoryFilesystemRoot(agentId);
-            if (!existsSync69(memoryDir)) {
+            if (!existsSync70(memoryDir)) {
               updateMemorySyncCommand(cmdId, "No local memory filesystem found to reset.", true, msg);
               return { submitted: true };
             }
-            const backupDir = join90(tmpdir12(), `letta-memfs-reset-${agentId}-${Date.now()}`);
+            const backupDir = join91(tmpdir12(), `letta-memfs-reset-${agentId}-${Date.now()}`);
             renameSync8(memoryDir, backupDir);
             if (getBackend().capabilities.localMemfs) {
               const { initializeLocalMemoryRepo: initializeLocalMemoryRepo2 } = await Promise.resolve().then(() => (init_memory_git(), exports_memory_git));
@@ -550193,8 +550909,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
             feedbackContext: {
               parentAgentName: agentName,
               parentAgentDescription: agentDescription,
-              surface: "letta_code_tui",
-              model: currentModelId
+              surface: "letta_code_tui"
             },
             onReady: (message2, readyRun) => {
               appendTaskNotificationEvents([message2]);
@@ -550242,8 +550957,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                 feedbackContext: {
                   parentAgentName: agentName,
                   parentAgentDescription: agentDescription,
-                  surface: "letta_code_tui",
-                  model: currentModelId
+                  surface: "letta_code_tui"
                 },
                 onReady: (message2, readyRun) => {
                   appendTaskNotificationEvents([message2]);
@@ -550254,7 +550968,7 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                 }
               });
               if (!arenaResult.launched) {
-                cmd.fail("No new transcript content to reflect on.");
+                cmd.fail(getReflectionLaunchSkippedMessage(arenaResult.reason) ?? "Failed to start reflection arena.");
                 return { submitted: true };
               }
               cmd.finish(`Started reflection arena run ${arenaResult.run.runId}. View the transcript payload here: ${arenaResult.payloadPath}`, true);
@@ -550276,17 +550990,13 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
               feedbackContext: {
                 parentAgentName: agentName,
                 parentAgentDescription: agentDescription,
-                surface: "letta_code_tui",
-                model: currentModelId
+                surface: "letta_code_tui"
               }
             });
             if (!result2.launched) {
-              if (result2.reason === "already_active") {
-                cmd.fail("A reflection agent is already running in the background.");
-              } else if (result2.reason === "no_payload") {
-                cmd.fail("No new transcript content to reflect on.");
-              } else if (result2.reason === "memfs_disabled") {
-                cmd.fail("Memory filesystem is not enabled. Use /remember instead.");
+              const skippedMessage = getReflectionLaunchSkippedMessage(result2.reason);
+              if (skippedMessage) {
+                cmd.fail(skippedMessage);
               } else {
                 const errorDetails = formatErrorDetails2(result2.error ?? "Unknown error", agentId);
                 cmd.fail(`Failed to start reflection agent: ${errorDetails}`);
@@ -550380,13 +551090,15 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                     onComplete: async ({
                       success: reflectionSuccess,
                       error: reflectionError,
-                      agentId: reflectionAgentId2
+                      agentId: reflectionAgentId2,
+                      model: reflectionModel
                     }) => {
                       try {
                         telemetry.trackReflectionEnd("manual", reflectionSuccess, {
                           subagentId: reflectionAgentId2 ?? undefined,
                           conversationId: reflectionConversationId,
-                          error: reflectionError
+                          error: reflectionError,
+                          model: reflectionModel
                         });
                         const { completionSuccess, completionMessage } = await finalizeReflectionMemoryWorktreeLaunch({
                           worktree: worktree2,
@@ -550395,6 +551107,9 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                           agentId,
                           conversationId: conversationIdRef.current,
                           subagentAgentId: reflectionAgentId2 ?? undefined,
+                          model: reflectionModel,
+                          ...getReflectionMergeLaunchOptions(agentId),
+                          telemetryContext: { triggerSource: "manual" },
                           recompileByConversation: systemPromptRecompileByConversationRef.current,
                           recompileQueuedByConversation: queuedSystemPromptRecompileByConversationRef.current,
                           logRecompileFailure: (message2) => debugWarn("memory", message2)
@@ -550470,13 +551185,15 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
             onComplete: async ({
               success: success2,
               error: error54,
-              agentId: reflectionAgentId2
+              agentId: reflectionAgentId2,
+              model: reflectionModel
             }) => {
               try {
                 telemetry.trackReflectionEnd("manual", success2, {
                   subagentId: reflectionAgentId2 ?? undefined,
                   conversationId: reflectionConversationId,
-                  error: error54
+                  error: error54,
+                  model: reflectionModel
                 });
                 const { completionSuccess, completionMessage } = await finalizeReflectionMemoryWorktreeLaunch({
                   worktree,
@@ -550485,6 +551202,9 @@ Resumed reflection arena choice prompt for run ${run2.runId}.`, true);
                   agentId,
                   conversationId: conversationIdRef.current,
                   subagentAgentId: reflectionAgentId2 ?? undefined,
+                  model: reflectionModel,
+                  ...getReflectionMergeLaunchOptions(agentId),
+                  telemetryContext: { triggerSource: "manual" },
                   recompileByConversation: systemPromptRecompileByConversationRef.current,
                   recompileQueuedByConversation: queuedSystemPromptRecompileByConversationRef.current,
                   logRecompileFailure: (message2) => debugWarn("memory", message2)
@@ -550975,7 +551695,7 @@ var init_use_submit_handler = __esm(async () => {
 });
 
 // src/cli/app/AppCoordinator.tsx
-import { join as join91 } from "node:path";
+import { join as join92 } from "node:path";
 function buildStartupCommandHints(options3) {
   const {
     isResumingConversation,
@@ -552282,7 +553002,7 @@ function App2({
       agentId: a2.agentId ?? null
     }))
   });
-  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join91(modContext.memfs.memoryDir, "mods") : null;
+  const agentModsDirectory = modContext.memfs.enabled && modContext.memfs.memoryDir ? join92(modContext.memfs.memoryDir, "mods") : null;
   const modAdapter = useLocalModAdapter(modContext, {
     agentModsDirectory,
     disabled: modsDisabled
@@ -553060,9 +553780,9 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     (async () => {
       try {
         const { watch: watch3 } = await import("node:fs");
-        const { existsSync: existsSync70 } = await import("node:fs");
+        const { existsSync: existsSync71 } = await import("node:fs");
         const memRoot = getScopedMemoryFilesystemRoot(agentId);
-        if (!existsSync70(memRoot))
+        if (!existsSync71(memRoot))
           return;
         watcher2 = watch3(memRoot, { recursive: true }, () => {});
         memfsWatcherRef.current = watcher2;
@@ -553097,10 +553817,6 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
         reflectionSettings: reflectionSettings2,
         reminderState: sharedReminderStateRef.current,
         contextTracker: contextTrackerRef.current,
-        onCompaction: () => queuePendingReflectionWorktreeReminders({
-          agentId: reflectionAgentId,
-          conversationId: conversationIdRef.current ?? "default"
-        }),
         launch: async (triggerSource) => {
           if (experimentManager.isEnabled("reflection_arena")) {
             const arenaResult = await launchReflectionArena({
@@ -553114,8 +553830,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
               feedbackContext: {
                 parentAgentName: agentName,
                 parentAgentDescription: agentDescription,
-                surface: "letta_code_tui",
-                model: currentModelId
+                surface: "letta_code_tui"
               },
               onReady: (message, readyRun) => {
                 appendTaskNotificationEvents([message]);
@@ -553132,7 +553847,6 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
             conversationId: conversationIdRef.current ?? "default",
             memfsEnabled: isActiveMemfsEnabled(reflectionAgentId),
             triggerSource,
-            skipPendingWorktreeReminderScan: triggerSource === "compaction-event",
             reflectionSettings: reflectionSettings2,
             description: AUTO_REFLECTION_DESCRIPTION,
             completionConversationId: () => conversationIdRef.current,
@@ -553144,8 +553858,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
             feedbackContext: {
               parentAgentName: agentName,
               parentAgentDescription: agentDescription,
-              surface: "letta_code_tui",
-              model: currentModelId
+              surface: "letta_code_tui"
             }
           });
           return result.launched;
@@ -553154,12 +553867,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     } catch (error54) {
       debugWarn("memory", `Failed to evaluate post-turn reflection: ${error54 instanceof Error ? error54.message : String(error54)}`);
     }
-  }, [
-    agentName,
-    agentDescription,
-    currentModelId,
-    appendTaskNotificationEvents
-  ]);
+  }, [agentName, agentDescription, appendTaskNotificationEvents]);
   const processConversation = useConversationLoop({
     abortControllerRef,
     agentIdRef,
@@ -554640,12 +555348,12 @@ EXAMPLES
   console.log(usage);
 }
 async function printInfo() {
-  const { join: join92 } = await import("node:path");
+  const { join: join93 } = await import("node:path");
   const { getVersion: getVersion2 } = await Promise.resolve().then(() => (init_version(), exports_version));
   const { SKILLS_DIR: SKILLS_DIR2 } = await Promise.resolve().then(() => (init_skills3(), exports_skills2));
   const { exists: exists2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
   const cwd2 = process.cwd();
-  const skillsDir = join92(cwd2, SKILLS_DIR2);
+  const skillsDir = join93(cwd2, SKILLS_DIR2);
   const skillsExist = exists2(skillsDir);
   await settingsManager.loadLocalProjectSettings(cwd2);
   const pinned = settingsManager.getPinnedAgents();
@@ -555099,40 +555807,18 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     }
   }
   try {
-    validateFlagConflicts({
-      guard: specifiedConversationId && specifiedConversationId !== "default",
-      checks: [
-        {
-          when: specifiedAgentId,
-          message: "--conversation cannot be used with --agent"
-        },
-        {
-          when: specifiedAgentName,
-          message: "--conversation cannot be used with --name"
-        },
-        {
-          when: forceNew,
-          message: "--conversation cannot be used with --new-agent"
-        },
-        {
-          when: fromAfFile,
-          message: "--conversation cannot be used with --import"
-        },
-        {
-          when: shouldResume,
-          message: "--conversation cannot be used with --resume"
-        }
-      ]
-    });
-    validateFlagConflicts({
-      guard: forceNewConversation,
-      checks: [
-        {
-          when: specifiedConversationId,
-          message: "--new cannot be used with --conversation"
-        },
-        { when: shouldResume, message: "--new cannot be used with --resume" }
-      ]
+    validatePrimaryStartupFlagConflicts({
+      specifiedConversationId,
+      specifiedAgentId,
+      specifiedAgentName,
+      forceNewAgent: forceNew,
+      forceNewConversation,
+      importFile: fromAfFile,
+      shouldResume,
+      stateless: values2.stateless,
+      isHeadless,
+      memfs: memfsFlag,
+      memfsStartup: values2["memfs-startup"]
     });
   } catch (error54) {
     console.error(error54 instanceof Error ? `Error: ${error54.message}` : String(error54));
@@ -555176,9 +555862,9 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     } else {
       const { resolve: resolve40 } = await import("node:path");
-      const { existsSync: existsSync70 } = await import("node:fs");
+      const { existsSync: existsSync71 } = await import("node:fs");
       const resolvedPath = resolve40(fromAfFile);
-      if (!existsSync70(resolvedPath)) {
+      if (!existsSync71(resolvedPath)) {
         console.error(`Error: AgentFile not found: ${resolvedPath}`);
         process.exit(1);
       }
@@ -558301,4 +558987,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=4E0E0DC994DF7B4864756E2164756E21
+//# debugId=AF6DD74653AB022F64756E2164756E21