@letta-ai/letta-code 0.21.5 → 0.21.6

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.21.5",
+    version: "0.21.6",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -6851,75 +6851,71 @@ You are a history analysis subagent. You create a git worktree from the agent's
 
 You run autonomously. You **cannot ask questions** mid-execution.
 
-## Goal
+## Guiding Principles
+
+Your memory files form the parent agent's identity and knowledge. Follow these principles:
 
-Learn everything you can from the conversation history and capture it in well-organized memory files. Your edits should make the agent dramatically better at working with this user on their projects.
+- **Generalize, don't memorize**: Distill patterns from repeated observations. "Always use uv, never pip (corrected 10+ times)" is valuable; a single offhand mention is not. Look for signal through repetition.
+- **System/ is the core program**: Only durable, generalizable knowledge belongs in \`system/\`. Distilled preferences, behavioral rules, project gotchas, conventions enforced through corrections. Evidence trails, raw session summaries, and verbose context go outside \`system/\`.
+- **Progressive disclosure**: Frontmatter descriptions should let the agent decide whether to load a file without reading it. Summaries and principles in \`system/\`; detail and evidence outside it, linked with \`[[path]]\`.
+- **Identity continuity**: Treat this history as the agent's own past — not someone else's sessions. Findings should read as learned knowledge, not "analysis of external data."
+- **Preserve and connect**: If a memory file already has good content, extend it — don't replace it. Use \`[[path]]\` links to connect new findings to existing memory.
 
-The memory you create serves the same purpose as memory built during \`/init\`:
+## Goal
 
-**About the user:**
-- Identity, role, what they actually do day-to-day
-- How they work — debugging style, testing preferences, workflow patterns, tools they reach for
-- What they explicitly prefer or reject — tools, frameworks, patterns, conventions
-- What frustrates them — corrections they make repeatedly, "no", "undo", "stop doing X"
-- How they communicate — terse vs detailed, directive vs collaborative, typical prompt length
+Distill actionable knowledge from conversation history into well-organized memory. Focus on:
 
-**About the projects:**
-- Architecture and how it evolved over time — major refactors, design decisions, why things are the way they are
-- Gotchas and footguns discovered through errors and debugging sessions
-- Conventions enforced through corrections (not just documented — actually enforced)
-- Dependencies, tooling choices, and the reasoning behind them
-- Recurring issues and how they were resolved
-- Cross-repo relationships and how projects connect
+- **Preferences enforced through corrections**: What the user repeatedly corrects their AI assistant about — these are gold. They reveal what the user actually cares about vs. what's merely documented.
+- **Project gotchas**: Footguns, fragile areas, and non-obvious constraints discovered through debugging sessions and errors.
+- **Working patterns**: How the user works — debugging style, testing habits, tools they reach for, communication style.
+- **Conventions actually used**: Not just what's in a README, but what's enforced through practice.
 
-## How to work
+**What NOT to store**: Raw quotes, one-off events, session-by-session summaries, anything that can be retrieved from conversation history on demand.
 
-### 1. Create a worktree
+## Workflow
 
-Create a git worktree from the memory repo so you can edit files without affecting the main branch. Use a timestamped branch name:
+### 1. Set up worktree
 
 \`\`\`bash
 MEMORY_DIR=~/.letta/agents/$LETTA_PARENT_AGENT_ID/memory
 WORKTREE_DIR=~/.letta/agents/$LETTA_PARENT_AGENT_ID/memory-worktrees
-TS=$(date +%s)
-BRANCH_NAME="migration-$TS"
-
+BRANCH_NAME="migration-$(date +%s)"
 mkdir -p "$WORKTREE_DIR"
 cd "$MEMORY_DIR"
 git worktree add "$WORKTREE_DIR/$BRANCH_NAME" -b "$BRANCH_NAME"
 \`\`\`
 
-If \`git worktree add\` fails because main is locked or busy,
-retry up to 3 times with backoff (sleep 2, 5, 10 seconds).
-Never delete \`.git/index.lock\` manually.
-
-All your edits go in \`$WORKTREE_DIR/$BRANCH_NAME/\`.
+If worktree creation fails (locked index), retry up to 3 times with backoff (sleep 2, 5, 10). Never delete \`.git/index.lock\` manually. All edits go in \`$WORKTREE_DIR/$BRANCH_NAME/\`.
 
 ### 2. Read existing memory
 
-Read all files in your worktree's \`system/\` directory first. Understand what's already there so you can add to it, not duplicate it.
+Read all files in your worktree's \`system/\` directory. Understand what's already there so you can extend it, not duplicate it.
 
-### 3. Read the history data
+### 3. Read and analyze history
 
-Use the data access patterns from the \`migrating-from-codex-and-claude-code\` skill to read and search the history assigned to you. Filter to your assigned date range.
+Use the \`migrating-from-codex-and-claude-code\` skill for data access patterns. Filter to your assigned chunk.
 
-### 4. Analyze for patterns
+Look for **repeated patterns**, not isolated events:
+- Count correction frequency — 10 corrections on the same topic >> 1 mention
+- Explicit preference statements ("I always want...", "never do...")
+- Implicit preferences revealed by what commands they run, what patterns they follow
+- Frustration signals — "no", "undo", rapid corrections, /clear, model switches
 
-Don't just skim — look for **repeated patterns** across many interactions:
-- Count how many times the user corrects the same thing (e.g. "use uv not pip" appearing 10+ times is much more significant than appearing once)
-- Look for explicit statements of preference ("I always want...", "never do...")
-- Look for implicit preferences (what commands do they run? what patterns do they follow?)
-- Pay attention to frustration signals — "no", rapid corrections, /clear, model switches
-### 5. Update memory files
+### 4. Update memory files
 
-**Create and edit files directly in your worktree.** Organize however makes sense for the content you find. Be granular — it's better to have many focused files than a few large ones.
+**Content placement:**
+- \`system/\`: Generalized rules, distilled preferences, project gotchas, identity. Keep files lean — bullets, short lines, scannable.
+- Outside \`system/\`: Evidence, detailed history, verbose context. Link from system/ with \`[[path]]\`.
 
-Write memory files the way the agent would want to read them — clean, actionable, no clutter. Don't paste raw quotes or evidence into the memory files. If you want to note where something came from, a short file reference is enough (e.g. \`(from: ~/.claude/history.jsonl)\`).
+**File structure:**
+- Use the project's **real name** as directory prefix (e.g. \`my-app/conventions.md\`), not generic \`project/\`
+- One concept per file, nested with \`/\` paths
+- Every file needs a meaningful \`description\` in frontmatter
+- Write for the agent's future self — clean, actionable, no clutter
 
-### 6. Commit
+You can also cite the files if you want to note where something came from (e.g. \`(from: ~/.claude/history.jsonl)\`).
 
-Use Conventional Commits format with the \`(history-analyzer)\`
-scope and ⏳ signature:
+### 5. Commit
 
 \`\`\`bash
 cd $WORKTREE_DIR/$BRANCH_NAME
@@ -6929,40 +6925,22 @@ git commit -m "<type>(history-analyzer): [summary] ⏳
 Source: [file path] ([N] prompts, [DATE RANGE])
 Key updates:
 - [file]: [what was added/changed]
-...
 
 Generated-By: Letta Code
 Agent-ID: <ACTUAL_AGENT_ID>
 Parent-Agent-ID: <ACTUAL_PARENT_AGENT_ID>"
 \`\`\`
 
-**Commit type** — pick the one that fits:
-- \`chore\` — routine history ingestion (most common)
-- \`feat\` — adding wholly new memory blocks/topics
-- \`refactor\` — reorganizing memory by domain/project
-
-**Example subjects:**
-- \`chore(history-analyzer): ingest Claude Code history 2025-09 ⏳\`
-- \`refactor(history-analyzer): reorganize memory by project domain ⏳\`
+Resolve \`ACTUAL_AGENT_ID\` and \`ACTUAL_PARENT_AGENT_ID\` by running \`echo $LETTA_AGENT_ID\` and \`echo $LETTA_PARENT_AGENT_ID\` first. Never write literal variable names in the commit message. Omit trailers if the variable is empty.
 
-**Trailers:** Before writing the commit, resolve the actual
-ID values by running:
-\`\`\`bash
-echo "AGENT_ID=$LETTA_AGENT_ID"
-echo "PARENT_AGENT_ID=$LETTA_PARENT_AGENT_ID"
-\`\`\`
-Use the printed values (e.g. \`agent-abc123...\`) in the
-trailers. If a variable is empty or unset, omit that
-trailer entirely. Never write a literal variable name like
-\`$LETTA_AGENT_ID\` in the commit message.
+**Commit types**: \`chore\` (routine ingestion), \`feat\` (new memory topics), \`refactor\` (reorganizing by domain).
 
-## Important
+## Rules
 
-- Create your own worktree and work there — do NOT edit the memory dir directly
+- Work in your worktree — do NOT edit the memory dir directly
 - Do NOT merge into main — the parent agent handles merging
-- **Be detailed** — capture granular specifics, not vague summaries. "Always use uv, never pip (corrected 10+ times)" is much better than "Has Python tool preferences"
-- **Learn from feedback** — corrections the user made to their AI assistant are gold. They tell you exactly what NOT to do and what TO do instead
-- **Preserve existing content** — if a memory file already has good content, add to it or refine it, don't replace it
+- Preserve existing content — extend or refine, don't replace
+- Quality over quantity — fewer distilled insights beat many raw observations
 `;
 var init_history_analyzer = () => {};
 
@@ -6980,10 +6958,18 @@ You are a fast memory initialization subagent. Your job is to quickly scan a pro
 
 You run autonomously in the background. You CANNOT ask questions. Be fast — minimize tool calls.
 
+## Guiding Principles
+
+Your memory files are not just data — they form the parent agent's identity and knowledge. Follow these principles:
+
+- **System/ is the core program**: Only durable knowledge needed every turn belongs in \`system/\`. Identity, preferences, behavioral rules, project index, gotchas.
+- **Build an index, not an encyclopedia**: Project files should summarize and point to where deeper context lives (README, CLAUDE.md, key source files) rather than duplicating everything.
+- **Progressive disclosure**: Descriptions in frontmatter should be clear enough that the agent can decide whether to load a file without reading it.
+- **Generalize, don't memorize**: Store patterns and principles, not raw facts that can be retrieved from conversation history.
+
 ## Context
 
 Your prompt includes pre-gathered context:
-- **Git context**: branch, status, recent commits, contributors
 - **Existing memory files**: file paths and contents of the current memory filesystem (may be empty for new agents)
 - **Directory listing**: top-level project files
 
@@ -6994,7 +6980,7 @@ Your prompt includes pre-gathered context:
 Read these files **in parallel** in a single turn (skip any that don't exist):
 - \`CLAUDE.md\` or \`AGENTS.md\`
 - \`package.json\`, \`pyproject.toml\`, \`Cargo.toml\`, or \`go.mod\` (whichever exists)
-- \`README.md\`
+- \`README.md\` (recursively)
 
 ### 2. Plan the hierarchy
 
@@ -7017,32 +7003,34 @@ cd "$MEMORY_DIR" && git add -A && git commit -m "..." && git push
 
 ## Memory hierarchy
 
-Memory files live under \`$MEMORY_DIR/system/\` and are rendered in the parent agent's context every turn. Each file should have YAML frontmatter with a \`description\` field.
-
-The shallow init creates a **skeleton** — a well-structured hierarchy with just enough content to be useful from the first interaction. The parent agent will flesh out these files and add new ones over time as it learns more about the project and user.
+Memory files live under \`$MEMORY_DIR/system/\` and are rendered in the parent agent's context every turn. Each file should have YAML frontmatter with a \`description\` field that clearly explains the file's purpose and when to use it.
 
 ### Default blocks
 
-New agents come with default boilerplate files at \`$MEMORY_DIR/system/human.md\` and \`$MEMORY_DIR/system/persona.md\`. These contain placeholder content. Update \`system/human.md\` in place with real user info. **Leave \`system/persona.md\` as-is** — the parent agent will shape it over time through interaction.
+New agents come with default boilerplate files at \`$MEMORY_DIR/system/human.md\` and \`$MEMORY_DIR/system/persona.md\`. Update \`system/human.md\` with what you can learn about the user from git context — name, email, role, contribution patterns. human.md is about the user as a person, not about project conventions. For \`system/persona.md\`, write a persona that expresses the agent's identity, personality and values — how you communicate, what you care about, how you handle uncertainty. Don't just list project rules. Both files should be **project-agnostic** — the same agent may work across multiple projects, so don't tie identity to a specific codebase. The parent agent will develop both further through interaction.
+
+### Required files
 
-### Topics to cover
+- **\`system/human.md\`** (update the default): the user as a person — identity from git, contribution patterns. Not project conventions.
+- **\`system/persona.md\`** (update the default): identity, personality, values, communication style — not just project rules
 
-Ensure each topic is covered by exactly one file. If an existing file already covers a topic, update it rather than creating a new file at a different path.
+### Project files
 
-- **\`system/human.md\`** (update the default): name, email, role — inferred from git context
-- **Project overview**: what it is, tech stack, repo structure
-- **Project commands**: build, test, lint, dev workflows
-- **Project conventions**: coding style, runtime preferences, patterns from CLAUDE.md/AGENTS.md
+Derive the file structure from what the project actually needs — don't follow a fixed template. A CLI tool needs different files than a web app or a library. Common topics include overview, conventions, gotchas, commands, tooling — but only create files that have real content to put in them.
 
-The project topic should always be broken into multiple files under \`$MEMORY_DIR/system/\`. Use the project's name as the parent directory (e.g., \`letta-code/overview.md\`, \`my-app/commands.md\`) instead of a generic \`project/\` prefix. **One file per topic, no duplicates.**
+Rules:
+- Use the project's **real name** as the parent directory (e.g., \`letta-code/overview.md\`), not generic \`project/\`
+- **Overview should be a compact summary / index** (~10-15 lines): what it is, stack, key links. Don't list every module — that's what architecture docs are for.
+- One file per topic, no duplicates. If an existing file covers a topic, update it.
+- All system/ files should be ~15-30 lines. If you have more detail, put it outside system/ and link with \`[[path]]\`.
 
 ### Structure principles
 
-- All files go under \`$MEMORY_DIR/system/\` — never create files outside of it
-- Use nested paths with \`/\` for new project files (e.g., \`letta-code/overview.md\`, \`letta-code/commands.md\`)
-- Keep each file focused on one topic, ~15-30 lines
-- 3-6 files is the right range — just the skeleton
+- All files go under \`$MEMORY_DIR/system/\` — only create files outside system/ if you have detailed content that's too long for system/ (e.g., architecture docs)
+- Keep each file focused on one topic
+- 5-8 files is the right range — just the skeleton
 - Only include information that's actually useful; skip boilerplate
+- Add \`[[path]]\` links where they improve discoverability across related context
 - Leave room for growth: the parent agent will add detail over time
 
 **Commit format:**
@@ -8972,72 +8960,6 @@ var init_models2 = __esm(() => {
           parallel_tool_calls: true
         }
       },
-      {
-        id: "gpt-5.4-none",
-        handle: "openai/gpt-5.4",
-        label: "GPT-5.4",
-        description: "OpenAI's most capable model (no reasoning)",
-        updateArgs: {
-          reasoning_effort: "none",
-          verbosity: "medium",
-          context_window: 272000,
-          max_output_tokens: 128000,
-          parallel_tool_calls: true
-        }
-      },
-      {
-        id: "gpt-5.4-low",
-        handle: "openai/gpt-5.4",
-        label: "GPT-5.4",
-        description: "OpenAI's most capable model (low reasoning)",
-        updateArgs: {
-          reasoning_effort: "low",
-          verbosity: "medium",
-          context_window: 272000,
-          max_output_tokens: 128000,
-          parallel_tool_calls: true
-        }
-      },
-      {
-        id: "gpt-5.4-medium",
-        handle: "openai/gpt-5.4",
-        label: "GPT-5.4",
-        description: "OpenAI's most capable model (med reasoning)",
-        updateArgs: {
-          reasoning_effort: "medium",
-          verbosity: "medium",
-          context_window: 272000,
-          max_output_tokens: 128000,
-          parallel_tool_calls: true
-        }
-      },
-      {
-        id: "gpt-5.4-high",
-        handle: "openai/gpt-5.4",
-        label: "GPT-5.4",
-        description: "OpenAI's most capable model (high reasoning)",
-        isFeatured: true,
-        updateArgs: {
-          reasoning_effort: "high",
-          verbosity: "medium",
-          context_window: 272000,
-          max_output_tokens: 128000,
-          parallel_tool_calls: true
-        }
-      },
-      {
-        id: "gpt-5.4-xhigh",
-        handle: "openai/gpt-5.4",
-        label: "GPT-5.4",
-        description: "OpenAI's most capable model (max reasoning)",
-        updateArgs: {
-          reasoning_effort: "xhigh",
-          verbosity: "medium",
-          context_window: 272000,
-          max_output_tokens: 128000,
-          parallel_tool_calls: true
-        }
-      },
       {
         id: "gpt-5.4-pro-medium",
         handle: "openai/gpt-5.4-pro",
@@ -38057,6 +37979,11 @@ var init_modify = __esm(async () => {
 });
 
 // src/agent/create.ts
+var exports_create = {};
+__export(exports_create, {
+  createAgentWithBaseToolsRecovery: () => createAgentWithBaseToolsRecovery,
+  createAgent: () => createAgent
+});
 function isToolsNotFoundError(err) {
   const message = err instanceof Error ? err.message : String(err);
   const status = err?.status;
@@ -38656,6 +38583,24 @@ var init_memoryGit = __esm(async () => {
 });
 
 // src/agent/personality.ts
+var exports_personality = {};
+__export(exports_personality, {
+  resolvePersonalityId: () => resolvePersonalityId,
+  replaceBodyPreservingFrontmatter: () => replaceBodyPreservingFrontmatter,
+  getPersonalityOption: () => getPersonalityOption,
+  getPersonalityHumanContent: () => getPersonalityHumanContent,
+  getPersonalityContent: () => getPersonalityContent,
+  getPersonalityBlockValues: () => getPersonalityBlockValues,
+  getPersonalityBlockDefinitions: () => getPersonalityBlockDefinitions,
+  getDefaultHumanContent: () => getDefaultHumanContent,
+  enableMemfsForCreatedAgent: () => enableMemfsForCreatedAgent,
+  detectPersonalityFromPersonaFile: () => detectPersonalityFromPersonaFile,
+  createAgentForPersonality: () => createAgentForPersonality,
+  buildCreateAgentOptionsForPersonality: () => buildCreateAgentOptionsForPersonality,
+  applyPersonalityToMemory: () => applyPersonalityToMemory,
+  PERSONALITY_OPTIONS: () => PERSONALITY_OPTIONS,
+  DEFAULT_CREATE_AGENT_PERSONALITIES: () => DEFAULT_CREATE_AGENT_PERSONALITIES
+});
 import { execFile as execFileCb2 } from "node:child_process";
 import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname3, join as join8 } from "node:path";
@@ -38818,6 +38763,63 @@ function getPersonalityBlockDefinitions(personalityId) {
     }
   };
 }
+async function buildCreateAgentOptionsForPersonality(params) {
+  const { personalityId, name, description, model, tags } = params;
+  const personality = getPersonalityOption(personalityId);
+  const blockDefinitions = getPersonalityBlockDefinitions(personalityId);
+  const defaultMemoryBlocks = await getDefaultMemoryBlocks();
+  return {
+    name: name ?? personality.label,
+    description: description ?? personality.description,
+    model,
+    tags,
+    memoryPromptMode: "memfs",
+    memoryBlocks: defaultMemoryBlocks.map((block) => {
+      if (block.label === "persona") {
+        return {
+          label: block.label,
+          value: blockDefinitions.persona.value,
+          description: blockDefinitions.persona.description ?? block.description ?? undefined
+        };
+      }
+      if (block.label === "human") {
+        return {
+          label: block.label,
+          value: blockDefinitions.human.value,
+          description: blockDefinitions.human.description ?? block.description ?? undefined
+        };
+      }
+      return {
+        label: block.label,
+        value: block.value,
+        description: block.description ?? undefined
+      };
+    })
+  };
+}
+async function enableMemfsForCreatedAgent(params) {
+  const { agentId, agentTags } = params;
+  try {
+    const { getClient: getClient3 } = await init_client2().then(() => exports_client);
+    const client = await getClient3();
+    const tags = agentTags || [];
+    if (!tags.includes(GIT_MEMORY_ENABLED_TAG)) {
+      await client.agents.update(agentId, {
+        tags: [...tags, GIT_MEMORY_ENABLED_TAG]
+      });
+    }
+    settingsManager.setMemfsEnabled(agentId, true);
+  } catch {}
+}
+async function createAgentForPersonality(params) {
+  const { createAgent: createAgent2 } = await init_create().then(() => exports_create);
+  const result = await createAgent2(await buildCreateAgentOptionsForPersonality(params));
+  await enableMemfsForCreatedAgent({
+    agentId: result.agent.id,
+    agentTags: result.agent.tags
+  });
+  return result;
+}
 function replaceBodyPreservingFrontmatter(existingPersonaFile, newBody, options) {
   const frontmatterMatch = existingPersonaFile.match(FRONTMATTER_REGEX);
   if (!frontmatterMatch || frontmatterMatch.index !== 0) {
@@ -38855,7 +38857,7 @@ function isExitCode(error, expectedCode) {
 async function runGit2(cwd2, args) {
   const result = await execFile2("git", args, {
     cwd: cwd2,
-    maxBuffer: 10 * 1024 * 1024,
+    maxBuffer: 10485760,
     timeout: 60000
   });
   return result.stdout?.toString() ?? "";
@@ -38954,39 +38956,47 @@ async function applyPersonalityToMemory(params) {
     commitMessage
   };
 }
-var execFile2, PRIMARY_PERSONA_RELATIVE_PATH = "system/persona.md", LEGACY_PERSONA_RELATIVE_PATH = "memory/system/persona.md", PRIMARY_HUMAN_RELATIVE_PATH = "system/human.md", LEGACY_HUMAN_RELATIVE_PATH = "memory/system/human.md", PERSONALITY_OPTIONS, PERSONALITY_ALIASES, FRONTMATTER_REGEX, EDITABLE_FRONTMATTER_KEYS;
+var execFile2, PRIMARY_PERSONA_RELATIVE_PATH = "system/persona.md", LEGACY_PERSONA_RELATIVE_PATH = "memory/system/persona.md", PRIMARY_HUMAN_RELATIVE_PATH = "system/human.md", LEGACY_HUMAN_RELATIVE_PATH = "memory/system/human.md", PERSONALITY_OPTIONS, DEFAULT_CREATE_AGENT_PERSONALITIES, PERSONALITY_ALIASES, FRONTMATTER_REGEX, EDITABLE_FRONTMATTER_KEYS;
 var init_personality = __esm(async () => {
   init_memory();
   init_promptAssets();
-  await init_memoryGit();
+  await __promiseAll([
+    init_settings_manager(),
+    init_memoryGit()
+  ]);
   execFile2 = promisify2(execFileCb2);
   PERSONALITY_OPTIONS = [
     {
       id: "memo",
       label: "Letta Code",
-      description: "The default Letta Code personality that learns"
+      description: "The memory-first agent"
     },
     {
       id: "linus",
       label: "Linus",
-      description: "Blunt and unfiltered, inspired by Linus Torvalds"
+      description: "Code with a stern hand"
     },
     {
       id: "kawaii",
-      label: "Kawaii",
-      description: "A cute anime-inspired personality"
+      label: "Letta-Chan",
+      description: "sugoi~ (◕‿◕)✨"
     },
     {
       id: "claude",
-      label: "Claude",
-      description: "A concise engineering personality from Claude Code"
+      label: "Letta Code",
+      description: "Vanilla Claude flavors"
     },
     {
       id: "codex",
-      label: "Codex",
-      description: "A pragmatic coding personality from Codex"
+      label: "Letta Code",
+      description: "Vanilla Codex flavors"
     }
   ];
+  DEFAULT_CREATE_AGENT_PERSONALITIES = [
+    "memo",
+    "linus",
+    "kawaii"
+  ];
   PERSONALITY_ALIASES = {
     "letta-code": "memo",
     lettacode: "memo",
@@ -72110,9 +72120,6 @@ function buildShallowInitPrompt(args) {
 - parent_agent_id: ${args.agentId}
 ${identityLine}
 
-## Git
-${args.gitContext}
-
 ## Project Structure
 
 \`\`\`
@@ -72141,7 +72148,6 @@ async function fireAutoInit(agentId, onComplete) {
     agentId,
     workingDirectory: process.cwd(),
     memoryDir: getMemoryFilesystemRoot(agentId),
-    gitContext: gitDetails.context,
     gitIdentity: gitDetails.identity,
     existingMemoryPaths: existing.paths,
     existingMemory: existing.contents,
@@ -82053,6 +82059,12 @@ function isSkillDisableCommand(value) {
   const c = value;
   return c.type === "skill_disable" && typeof c.request_id === "string" && typeof c.name === "string";
 }
+function isCreateAgentCommand(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const c = value;
+  return c.type === "create_agent" && typeof c.request_id === "string" && (c.personality === "memo" || c.personality === "linus" || c.personality === "kawaii") && (c.model === undefined || typeof c.model === "string") && (c.pin_global === undefined || typeof c.pin_global === "boolean");
+}
 function isGetReflectionSettingsCommand(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -82091,7 +82103,7 @@ function parseServerMessage(data) {
   try {
     const raw = typeof data === "string" ? data : data.toString();
     const parsed = JSON.parse(raw);
-    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isEditFileCommand(parsed) || isListMemoryCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
+    if (isInputCommand(parsed) || isChangeDeviceStateCommand(parsed) || isAbortMessageCommand(parsed) || isSyncCommand(parsed) || isTerminalSpawnCommand(parsed) || isTerminalInputCommand(parsed) || isTerminalResizeCommand(parsed) || isTerminalKillCommand(parsed) || isSearchFilesCommand(parsed) || isListInDirectoryCommand(parsed) || isReadFileCommand(parsed) || isWriteFileCommand(parsed) || isEditFileCommand(parsed) || isListMemoryCommand(parsed) || isEnableMemfsCommand(parsed) || isListModelsCommand(parsed) || isUpdateModelCommand(parsed) || isCronListCommand(parsed) || isCronAddCommand(parsed) || isCronGetCommand(parsed) || isCronDeleteCommand(parsed) || isCronDeleteAllCommand(parsed) || isSkillEnableCommand(parsed) || isSkillDisableCommand(parsed) || isCreateAgentCommand(parsed) || isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed) || isExecuteCommandCommand(parsed) || isSearchBranchesCommand(parsed) || isCheckoutBranchCommand(parsed)) {
       return parsed;
     }
     const invalidInput = getInvalidInputReason(parsed);
@@ -82693,6 +82705,45 @@ async function handleSkillCommand(parsed, socket) {
   }
   return false;
 }
+async function handleCreateAgentCommand(parsed, socket) {
+  try {
+    if (parsed.model) {
+      const resolved = resolveModel2(parsed.model);
+      if (!resolved) {
+        socket.send(JSON.stringify({
+          type: "create_agent_response",
+          request_id: parsed.request_id,
+          success: false,
+          error: `Unknown model "${parsed.model}"`
+        }));
+        return;
+      }
+    }
+    const { createAgentForPersonality: createAgentForPersonality2 } = await init_personality().then(() => exports_personality);
+    const result = await createAgentForPersonality2({
+      personalityId: parsed.personality,
+      model: parsed.model
+    });
+    if (parsed.pin_global !== false) {
+      settingsManager.pinGlobal(result.agent.id);
+    }
+    socket.send(JSON.stringify({
+      type: "create_agent_response",
+      request_id: parsed.request_id,
+      success: true,
+      agent_id: result.agent.id,
+      name: result.agent.name,
+      model: result.agent.model ?? null
+    }));
+  } catch (err) {
+    socket.send(JSON.stringify({
+      type: "create_agent_response",
+      request_id: parsed.request_id,
+      success: false,
+      error: err instanceof Error ? err.message : "Failed to create agent"
+    }));
+  }
+}
 function toReflectionSettingsResponse(agentId, workingDirectory) {
   const settings = getReflectionSettings(agentId, workingDirectory);
   return {
@@ -83742,6 +83793,10 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       handleSkillCommand(parsed, socket);
       return;
     }
+    if (isCreateAgentCommand(parsed)) {
+      handleCreateAgentCommand(parsed, socket);
+      return;
+    }
     if (isGetReflectionSettingsCommand(parsed) || isSetReflectionSettingsCommand(parsed)) {
       handleReflectionSettingsCommand(parsed, socket, runtime);
       return;
@@ -84193,6 +84248,7 @@ var init_client4 = __esm(async () => {
     handleChangeDeviceStateInput,
     handleCronCommand,
     handleSkillCommand,
+    handleCreateAgentCommand,
     handleReflectionSettingsCommand,
     scheduleQueuePump,
     recoverApprovalStateForSync,
@@ -106524,37 +106580,105 @@ var init_useProgressIndicator = __esm(() => {
 });
 
 // src/cli/hooks/useTextInputCursor.ts
+function findPreviousWordStart(text, cursorPos) {
+  let pos = cursorPos;
+  while (pos > 0 && text[pos - 1] === " ") {
+    pos -= 1;
+  }
+  while (pos > 0 && text[pos - 1] !== " ") {
+    pos -= 1;
+  }
+  return pos;
+}
+function applyTextInputKey(state, input, key) {
+  const { text, cursorPos } = state;
+  if (key.leftArrow || key.ctrl && input === "b") {
+    return {
+      text,
+      cursorPos: Math.max(0, cursorPos - 1),
+      handled: true
+    };
+  }
+  if (key.rightArrow || key.ctrl && input === "f") {
+    return {
+      text,
+      cursorPos: Math.min(text.length, cursorPos + 1),
+      handled: true
+    };
+  }
+  if (key.home || key.ctrl && input === "a") {
+    return { text, cursorPos: 0, handled: true };
+  }
+  if (key.end || key.ctrl && input === "e") {
+    return { text, cursorPos: text.length, handled: true };
+  }
+  if (key.ctrl && input === "u") {
+    return {
+      text: text.slice(cursorPos),
+      cursorPos: 0,
+      handled: true
+    };
+  }
+  if (key.ctrl && input === "k") {
+    return {
+      text: text.slice(0, cursorPos),
+      cursorPos,
+      handled: true
+    };
+  }
+  if (key.ctrl && input === "w") {
+    if (cursorPos === 0) {
+      return { text, cursorPos, handled: true };
+    }
+    const start = findPreviousWordStart(text, cursorPos);
+    return {
+      text: text.slice(0, start) + text.slice(cursorPos),
+      cursorPos: start,
+      handled: true
+    };
+  }
+  if (key.backspace || key.delete) {
+    if (cursorPos > 0) {
+      return {
+        text: text.slice(0, cursorPos - 1) + text.slice(cursorPos),
+        cursorPos: cursorPos - 1,
+        handled: true
+      };
+    }
+    return { text, cursorPos, handled: true };
+  }
+  if (key.isPasted && input) {
+    const sanitized = input.replace(/[\r\n]+/g, " ");
+    return {
+      text: text.slice(0, cursorPos) + sanitized + text.slice(cursorPos),
+      cursorPos: cursorPos + sanitized.length,
+      handled: true
+    };
+  }
+  if (input && !key.ctrl && !key.meta && input.length === 1) {
+    return {
+      text: text.slice(0, cursorPos) + input + text.slice(cursorPos),
+      cursorPos: cursorPos + 1,
+      handled: true
+    };
+  }
+  return { text, cursorPos, handled: false };
+}
 function useTextInputCursor(initialText = "") {
   const [text, setText] = import_react40.useState(initialText);
-  const [cursorPos, setCursorPos] = import_react40.useState(0);
+  const [cursorPos, setCursorPos] = import_react40.useState(initialText.length);
   const handleKey = (input, key) => {
-    if (key.leftArrow) {
-      setCursorPos((prev) => Math.max(0, prev - 1));
-      return true;
-    }
-    if (key.rightArrow) {
-      setCursorPos((prev) => Math.min(text.length, prev + 1));
-      return true;
-    }
-    if (key.backspace || key.delete) {
-      if (cursorPos > 0) {
-        setText((prev) => prev.slice(0, cursorPos - 1) + prev.slice(cursorPos));
-        setCursorPos((prev) => prev - 1);
-      }
-      return true;
+    const result = applyTextInputKey({ text, cursorPos }, input, key);
+    if (!result.handled) {
+      return false;
     }
-    if (key.isPasted && input) {
-      const sanitized = input.replace(/[\r\n]+/g, " ");
-      setText((prev) => prev.slice(0, cursorPos) + sanitized + prev.slice(cursorPos));
-      setCursorPos((prev) => prev + sanitized.length);
-      return true;
+    if (result.text !== text) {
+      setText(result.text);
     }
-    if (input && !key.ctrl && !key.meta && input.length === 1) {
-      setText((prev) => prev.slice(0, cursorPos) + input + prev.slice(cursorPos));
-      setCursorPos((prev) => prev + 1);
-      return true;
+    if (result.cursorPos !== cursorPos) {
+      setCursorPos(result.cursorPos);
     }
-    return false;
+    return true;
   };
   const clear = () => {
     setText("");
@@ -108037,32 +108161,46 @@ var init_InlineQuestionApproval = __esm(async () => {
   ]);
   import_react46 = __toESM(require_react(), 1);
   jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
-  InlineQuestionApproval = import_react46.memo(({ questions, onSubmit, onCancel, isFocused = true }) => {
+  InlineQuestionApproval = import_react46.memo(({
+    questions,
+    onSubmit,
+    onCancel,
+    onConsumeDraft,
+    isFocused = true,
+    initialDraft
+  }) => {
     const [currentQuestionIndex, setCurrentQuestionIndex] = import_react46.useState(0);
     const [answers, setAnswers] = import_react46.useState({});
     const [selectedOption, setSelectedOption] = import_react46.useState(0);
-    const {
-      text: customText,
-      setText: setCustomText,
-      cursorPos,
-      setCursorPos,
-      handleKey,
-      clear: clearCustomText
-    } = useTextInputCursor();
     const [selectedMulti, setSelectedMulti] = import_react46.useState(new Set);
     const columns = useTerminalWidth();
     useProgressIndicator();
     const currentQuestion = questions[currentQuestionIndex];
     const showOther = currentQuestion?.allowOther !== false;
-    const baseOptions = currentQuestion ? [
-      ...currentQuestion.options,
-      ...showOther ? [{ label: "Type something.", description: "" }] : []
+    const hasDraft = initialDraft && initialDraft.trim().length > 0;
+    const draftInput = useTextInputCursor(hasDraft ? initialDraft : "");
+    const customInput = useTextInputCursor("");
+    const regularOptions = currentQuestion?.options ?? [];
+    const draftOption = hasDraft ? [
+      {
+        label: initialDraft,
+        description: ""
+      }
     ] : [];
+    const typeNewOption = showOther ? [{ label: "Type new message.", description: "" }] : [];
+    const baseOptions = [...regularOptions, ...draftOption, ...typeNewOption];
     const optionsWithOther = currentQuestion?.multiSelect ? [...baseOptions, { label: "Submit", description: "" }] : baseOptions;
+    const draftOptionIndex = hasDraft ? regularOptions.length : -1;
     const customOptionIndex = showOther ? baseOptions.length - 1 : -1;
     const submitOptionIndex = currentQuestion?.multiSelect ? optionsWithOther.length - 1 : -1;
+    const isOnDraftOption = hasDraft && selectedOption === draftOptionIndex;
     const isOnCustomOption = showOther && selectedOption === customOptionIndex;
     const isOnSubmitOption = selectedOption === submitOptionIndex;
+    import_react46.useEffect(() => {
+      if (hasDraft && draftOptionIndex >= 0) {
+        setSelectedOption(draftOptionIndex);
+      }
+    }, [hasDraft, draftOptionIndex]);
     const handleSubmitAnswer = (answer) => {
       if (!currentQuestion)
         return;
@@ -108074,7 +108212,8 @@ var init_InlineQuestionApproval = __esm(async () => {
       if (currentQuestionIndex < questions.length - 1) {
         setCurrentQuestionIndex(currentQuestionIndex + 1);
         setSelectedOption(0);
-        clearCustomText();
+        draftInput.clear();
+        customInput.clear();
         setSelectedMulti(new Set);
       } else {
         onSubmit(newAnswers);
@@ -108095,6 +108234,25 @@ var init_InlineQuestionApproval = __esm(async () => {
         setSelectedOption((prev) => Math.min(optionsWithOther.length - 1, prev + 1));
         return;
       }
+      if (isOnDraftOption) {
+        if (key.return) {
+          if (draftInput.text.trim()) {
+            onConsumeDraft?.();
+            handleSubmitAnswer(draftInput.text.trim());
+          }
+          return;
+        }
+        if (key.escape) {
+          if (draftInput.text) {
+            draftInput.clear();
+          } else {
+            onCancel?.();
+          }
+          return;
+        }
+        if (draftInput.handleKey(input, key))
+          return;
+      }
       if (isOnCustomOption) {
         if (key.return) {
           if (currentQuestion.multiSelect) {
@@ -108108,8 +108266,8 @@ var init_InlineQuestionApproval = __esm(async () => {
               return newSet;
             });
           } else {
-            if (customText.trim()) {
-              handleSubmitAnswer(customText.trim());
+            if (customInput.text.trim()) {
+              handleSubmitAnswer(customInput.text.trim());
             }
           }
           return;
@@ -108122,19 +108280,19 @@ var init_InlineQuestionApproval = __esm(async () => {
               return newSet;
             });
           }
-          setCustomText((prev) => `${prev.slice(0, cursorPos)} ${prev.slice(cursorPos)}`);
-          setCursorPos((prev) => prev + 1);
+          customInput.setText((prev) => `${prev.slice(0, customInput.cursorPos)} ${prev.slice(customInput.cursorPos)}`);
+          customInput.setCursorPos((prev) => prev + 1);
           return;
         }
         if (key.escape) {
-          if (customText) {
-            clearCustomText();
+          if (customInput.text) {
+            customInput.clear();
           } else {
             onCancel?.();
           }
           return;
         }
-        if (handleKey(input, key))
+        if (customInput.handleKey(input, key))
           return;
       }
       if (isOnSubmitOption) {
@@ -108142,8 +108300,8 @@ var init_InlineQuestionApproval = __esm(async () => {
           const selectedLabels = [];
           for (const i of selectedMulti) {
             if (i === customOptionIndex) {
-              if (customText.trim()) {
-                selectedLabels.push(customText.trim());
+              if (customInput.text.trim()) {
+                selectedLabels.push(customInput.text.trim());
               }
             } else {
               const label = baseOptions[i]?.label;
@@ -108213,7 +108371,18 @@ var init_InlineQuestionApproval = __esm(async () => {
               return newSet;
             });
           } else {
-            handleSubmitAnswer(optionsWithOther[optionIndex]?.label || "");
+            if (optionIndex === draftOptionIndex) {
+              if (draftInput.text.trim()) {
+                onConsumeDraft?.();
+                handleSubmitAnswer(draftInput.text.trim());
+              }
+            } else if (optionIndex === customOptionIndex) {
+              if (customInput.text.trim()) {
+                handleSubmitAnswer(customInput.text.trim());
+              }
+            } else {
+              handleSubmitAnswer(optionsWithOther[optionIndex]?.label || "");
+            }
           }
         }
       }
@@ -108272,6 +108441,7 @@ var init_InlineQuestionApproval = __esm(async () => {
               const isSelected = index === selectedOption;
               const isChecked = selectedMulti.has(index);
               const color = isSelected ? colors.approval.header : undefined;
+              const isDraftOption = index === draftOptionIndex;
               const isCustomOption = index === customOptionIndex;
               const isSubmitOption = index === submitOptionIndex;
               const selectorAndNumber = 5;
@@ -108311,7 +108481,7 @@ var init_InlineQuestionApproval = __esm(async () => {
                   ]
                 }, "submit", true, undefined, this);
               }
-              const hasDescription = option.description && !isCustomOption;
+              const hasDescription = option.description && !isCustomOption && !isDraftOption;
               return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(import_react46.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
@@ -108346,21 +108516,23 @@ var init_InlineQuestionApproval = __esm(async () => {
                       /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Box_default, {
                         flexGrow: 1,
                         width: Math.max(0, columns - prefixWidth),
-                        children: isCustomOption ? customText ? /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
-                          wrap: "wrap",
-                          children: [
-                            customText.slice(0, cursorPos),
-                            isSelected && "█",
-                            customText.slice(cursorPos)
-                          ]
-                        }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
-                          wrap: "wrap",
-                          dimColor: true,
-                          children: [
-                            option.label,
-                            isSelected && "█"
-                          ]
-                        }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
+                        children: isDraftOption || isCustomOption ? (() => {
+                          const textValue = isDraftOption ? draftInput.text : customInput.text;
+                          const textCursor = isDraftOption ? draftInput.cursorPos : customInput.cursorPos;
+                          if (textValue) {
+                            const display = isSelected ? `${textValue.slice(0, textCursor)}█${textValue.slice(textCursor)}` : textValue;
+                            return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
+                              wrap: "wrap",
+                              children: display
+                            }, undefined, false, undefined, this);
+                          }
+                          const emptyDisplay = isDraftOption ? `${initialDraft}${isSelected ? "█" : ""}` : isSelected ? "█" : "";
+                          return /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
+                            wrap: "wrap",
+                            dimColor: true,
+                            children: emptyDisplay
+                          }, undefined, false, undefined, this);
+                        })() : /* @__PURE__ */ jsx_dev_runtime23.jsxDEV(Text2, {
                           wrap: "wrap",
                           color,
                           bold: isSelected,
@@ -109076,20 +109248,24 @@ var init_StaticPlanApproval = __esm(async () => {
     onApproveAndAcceptEdits,
     onKeepPlanning,
     onCancel,
+    onConsumeDraft,
     showAcceptEditsOption = true,
     isFocused = true,
     planContent,
     planFilePath,
-    agentName
+    agentName,
+    initialDraft
   }) => {
-    const [selectedOption, setSelectedOption] = import_react48.useState(0);
+    const hasDraft = Boolean(initialDraft && initialDraft.trim().length > 0);
+    const fixedOptionCount = showAcceptEditsOption ? 2 : 1;
+    const draftOptionIndex = hasDraft ? fixedOptionCount : -1;
+    const customOptionIndex = hasDraft ? fixedOptionCount + 1 : fixedOptionCount;
+    const maxOptionIndex = customOptionIndex;
+    const defaultOptionIndex = hasDraft ? draftOptionIndex : 0;
+    const [selectedOption, setSelectedOption] = import_react48.useState(defaultOptionIndex);
     const [browserStatus, setBrowserStatus] = import_react48.useState("");
-    const {
-      text: customReason,
-      cursorPos,
-      handleKey,
-      clear
-    } = useTextInputCursor();
+    const draftInput = useTextInputCursor(hasDraft ? initialDraft : "");
+    const newInput = useTextInputCursor("");
     const columns = useTerminalWidth();
     useProgressIndicator();
     const openInBrowser = import_react48.useCallback(() => {
@@ -109104,11 +109280,11 @@ var init_StaticPlanApproval = __esm(async () => {
         setTimeout(() => setBrowserStatus(""), 5000);
       });
     }, [planContent, planFilePath, agentName]);
-    const customOptionIndex = showAcceptEditsOption ? 2 : 1;
-    const maxOptionIndex = customOptionIndex;
     const effectiveSelectedOption = Math.min(selectedOption, maxOptionIndex);
+    const isOnDraftOption = hasDraft && effectiveSelectedOption === draftOptionIndex;
     const isOnCustomOption = effectiveSelectedOption === customOptionIndex;
-    const customOptionPlaceholder = "Type here to tell Letta Code what to change";
+    const isOnTextOption = isOnDraftOption || isOnCustomOption;
+    const activeInput = isOnDraftOption ? draftInput : isOnCustomOption ? newInput : null;
     use_input_default((input, key) => {
       if (!isFocused)
         return;
@@ -109116,7 +109292,7 @@ var init_StaticPlanApproval = __esm(async () => {
         onCancel();
         return;
       }
-      if ((input === "o" || input === "O") && !isOnCustomOption && planContent) {
+      if ((input === "o" || input === "O") && !isOnTextOption && planContent) {
         openInBrowser();
         return;
       }
@@ -109128,22 +109304,25 @@ var init_StaticPlanApproval = __esm(async () => {
         setSelectedOption((prev) => Math.min(maxOptionIndex, prev + 1));
         return;
       }
-      if (isOnCustomOption) {
+      if (activeInput) {
         if (key.return) {
-          if (customReason.trim()) {
-            onKeepPlanning(customReason.trim());
+          if (activeInput.text.trim()) {
+            if (isOnDraftOption) {
+              onConsumeDraft?.();
+            }
+            onKeepPlanning(activeInput.text.trim());
           }
           return;
         }
         if (key.escape) {
-          if (customReason) {
-            clear();
+          if (activeInput.text) {
+            activeInput.clear();
           } else {
             onKeepPlanning("User cancelled");
           }
           return;
         }
-        if (handleKey(input, key))
+        if (activeInput.handleKey(input, key))
           return;
       }
       if (key.return) {
@@ -109170,9 +109349,18 @@ var init_StaticPlanApproval = __esm(async () => {
         onApprove();
         return;
       }
+      if (hasDraft && input === String(draftOptionIndex + 1)) {
+        setSelectedOption(draftOptionIndex);
+        return;
+      }
+      if (input === String(customOptionIndex + 1)) {
+        setSelectedOption(customOptionIndex);
+      }
     }, { isActive: isFocused });
     const browserHint = planContent ? " · O open in browser" : "";
-    const hintText = isOnCustomOption ? customReason ? "Enter to submit · Esc to clear" : "Type feedback · Esc to cancel" : `Enter to select${browserHint} · Esc to cancel`;
+    const activeText = activeInput?.text || "";
+    const hintText = isOnTextOption ? activeText ? "Enter to submit · Esc to clear" : "Type feedback · Esc to cancel" : `Enter to select${browserHint} · Esc to cancel`;
+    const textOptionColor = colors.approval.header;
     return /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
       flexDirection: "column",
       children: [
@@ -109235,18 +109423,18 @@ var init_StaticPlanApproval = __esm(async () => {
                 }, undefined, false, undefined, this)
               ]
             }, undefined, true, undefined, this),
-            /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+            hasDraft && /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
               flexDirection: "row",
               children: [
                 /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
                   width: 5,
                   flexShrink: 0,
                   children: /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
-                    color: isOnCustomOption ? colors.approval.header : undefined,
+                    color: isOnDraftOption ? textOptionColor : undefined,
                     children: [
-                      isOnCustomOption ? "❯" : " ",
+                      isOnDraftOption ? "❯" : " ",
                       " ",
-                      customOptionIndex + 1,
+                      draftOptionIndex + 1,
                       "."
                     ]
                   }, undefined, true, undefined, this)
@@ -109254,21 +109442,52 @@ var init_StaticPlanApproval = __esm(async () => {
                 /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
                   flexGrow: 1,
                   width: Math.max(0, columns - 5),
-                  children: customReason ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
+                  children: isOnDraftOption ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
                     wrap: "wrap",
                     children: [
-                      customReason.slice(0, cursorPos),
-                      isOnCustomOption && "█",
-                      customReason.slice(cursorPos)
+                      draftInput.text.slice(0, draftInput.cursorPos),
+                      "█",
+                      draftInput.text.slice(draftInput.cursorPos)
                     ]
                   }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
                     wrap: "wrap",
                     dimColor: true,
+                    children: draftInput.text
+                  }, undefined, false, undefined, this)
+                }, undefined, false, undefined, this)
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+              flexDirection: "row",
+              children: [
+                /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+                  width: 5,
+                  flexShrink: 0,
+                  children: /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
+                    color: isOnCustomOption ? textOptionColor : undefined,
                     children: [
-                      customOptionPlaceholder,
-                      isOnCustomOption && "█"
+                      isOnCustomOption ? "❯" : " ",
+                      " ",
+                      customOptionIndex + 1,
+                      "."
                     ]
                   }, undefined, true, undefined, this)
+                }, undefined, false, undefined, this),
+                /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Box_default, {
+                  flexGrow: 1,
+                  width: Math.max(0, columns - 5),
+                  children: isOnCustomOption ? /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
+                    wrap: "wrap",
+                    children: [
+                      newInput.text.slice(0, newInput.cursorPos),
+                      "█",
+                      newInput.text.slice(newInput.cursorPos)
+                    ]
+                  }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime25.jsxDEV(Text2, {
+                    wrap: "wrap",
+                    dimColor: true,
+                    children: newInput.text
+                  }, undefined, false, undefined, this)
                 }, undefined, false, undefined, this)
               ]
             }, undefined, true, undefined, this)
@@ -109481,6 +109700,7 @@ var init_ApprovalSwitch = __esm(async () => {
     onApproveAlways,
     onDeny,
     onCancel,
+    onConsumeDraft,
     isFocused = true,
     approveAlwaysText,
     allowPersistence = true,
@@ -109495,7 +109715,8 @@ var init_ApprovalSwitch = __esm(async () => {
     defaultScope = "project",
     planContent,
     planFilePath,
-    agentName
+    agentName,
+    initialDraft
   }) => {
     const toolName = approval.toolName;
     if (toolName === "ExitPlanMode" && onPlanApprove && onPlanKeepPlanning) {
@@ -109505,11 +109726,13 @@ var init_ApprovalSwitch = __esm(async () => {
         onApproveAndAcceptEdits: () => onPlanApprove(true),
         onKeepPlanning: onPlanKeepPlanning,
         onCancel: onCancel ?? (() => {}),
+        onConsumeDraft,
         showAcceptEditsOption,
         isFocused,
         planContent,
         planFilePath,
-        agentName
+        agentName,
+        initialDraft
       }, undefined, false, undefined, this);
     }
     if (isFileEditTool(toolName) || isFileWriteTool(toolName) || isPatchTool(toolName)) {
@@ -109562,7 +109785,9 @@ var init_ApprovalSwitch = __esm(async () => {
           questions,
           onSubmit: onQuestionSubmit,
           onCancel,
-          isFocused
+          onConsumeDraft,
+          isFocused,
+          initialDraft
         }, undefined, false, undefined, this);
       }
     }
@@ -116952,6 +117177,7 @@ function Input({
   statusLinePadding = 0,
   statusLinePrompt,
   onCycleReasoningEffort,
+  onDraftChange,
   footerNotification
 }) {
   const [value, setValue] = import_react74.useState("");
@@ -117045,10 +117271,17 @@ function Input({
   const [atEndBoundary, setAtEndBoundary] = import_react74.useState(false);
   const [preferredColumn, setPreferredColumn] = import_react74.useState(null);
   import_react74.useEffect(() => {
-    if (restoredInput && value === "") {
+    if (restoredInput === null || restoredInput === undefined)
+      return;
+    if (restoredInput === "") {
+      setValue("");
+      onRestoredInputConsumed?.();
+      return;
+    }
+    if (value === "") {
       setValue(restoredInput);
       onRestoredInputConsumed?.();
-    } else if (restoredInput && value !== "") {
+    } else {
       onRestoredInputConsumed?.();
     }
   }, [restoredInput, value, onRestoredInputConsumed]);
@@ -117308,7 +117541,8 @@ function Input({
       setAtEndBoundary(false);
     }
     previousValueRef.current = value;
-  }, [value]);
+    onDraftChange?.(value);
+  }, [value, onDraftChange]);
   import_react74.useEffect(() => {
     if (historyIndex !== -1 && value !== history[historyIndex]) {
       setHistoryIndex(-1);
@@ -132970,6 +133204,7 @@ function App2({
   const dequeueInFlightRef = import_react103.useRef(false);
   const lastDequeuedMessageRef = import_react103.useRef(null);
   const [restoredInput, setRestoredInput] = import_react103.useState(null);
+  const currentDraftRef = import_react103.useRef("");
   const isAgentBusy = import_react103.useCallback(() => {
     return streamingRef.current || isExecutingTool || commandRunningRef.current || abortControllerRef.current !== null;
   }, [isExecutingTool]);
@@ -139969,6 +140204,10 @@ ${guidance}`);
     refreshDerived,
     queueApprovalResults
   ]);
+  const handleConsumeDraft = import_react103.useCallback(() => {
+    currentDraftRef.current = "";
+    setRestoredInput("");
+  }, []);
   const handleQuestionSubmit = import_react103.useCallback(async (answers) => {
     const currentIndex = approvalResults.length;
     const approval = pendingApprovals[currentIndex];
@@ -140391,7 +140630,9 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                           showPreview: showApprovalPreview,
                           planContent: currentApproval.toolName === "ExitPlanMode" ? _readPlanFile(lastPlanFilePathRef.current) : undefined,
                           planFilePath: currentApproval.toolName === "ExitPlanMode" ? permissionMode.getPlanFilePath() ?? lastPlanFilePathRef.current ?? undefined : undefined,
-                          agentName: agentName ?? undefined
+                          agentName: agentName ?? undefined,
+                          initialDraft: currentDraftRef.current || undefined,
+                          onConsumeDraft: handleConsumeDraft
                         }, undefined, false, undefined, this) : ln.kind === "user" ? /* @__PURE__ */ jsx_dev_runtime80.jsxDEV(UserMessage, {
                           line: ln,
                           prompt: statusLine.prompt
@@ -140446,7 +140687,9 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                       showPreview: showApprovalPreview,
                       planContent: currentApproval.toolName === "ExitPlanMode" ? _readPlanFile(lastPlanFilePathRef.current) : undefined,
                       planFilePath: currentApproval.toolName === "ExitPlanMode" ? permissionMode.getPlanFilePath() ?? lastPlanFilePathRef.current ?? undefined : undefined,
-                      agentName: agentName ?? undefined
+                      agentName: agentName ?? undefined,
+                      initialDraft: currentDraftRef.current || undefined,
+                      onConsumeDraft: handleConsumeDraft
                     }, undefined, false, undefined, this)
                   }, undefined, false, undefined, this),
                   /* @__PURE__ */ jsx_dev_runtime80.jsxDEV(SubagentGroupDisplay, {}, undefined, false, undefined, this)
@@ -140578,6 +140821,9 @@ If using apply_patch, use this exact relative patch path: ${applyPatchRelativePa
                   onPasteError: handlePasteError,
                   restoredInput,
                   onRestoredInputConsumed: () => setRestoredInput(null),
+                  onDraftChange: (draft) => {
+                    currentDraftRef.current = draft;
+                  },
                   networkPhase,
                   terminalWidth: chromeColumns,
                   shouldAnimate,
@@ -141958,8 +142204,8 @@ var init_defaults2 = __esm(async () => {
 });
 
 // src/agent/create.ts
-var exports_create = {};
-__export(exports_create, {
+var exports_create2 = {};
+__export(exports_create2, {
   createAgentWithBaseToolsRecovery: () => createAgentWithBaseToolsRecovery2,
   createAgent: () => createAgent2
 });
@@ -145755,11 +146001,9 @@ function validateRegistryHandleOrThrow(handle) {
 }
 
 // src/cli/subcommands/agents.ts
-init_memory();
 await __promiseAll([
   init_client2(),
   init_create(),
-  init_memoryGit(),
   init_personality(),
   init_settings_manager()
 ]);
@@ -145858,37 +146102,11 @@ async function runCreateAction(values) {
     console.error(`Unknown personality: ${personalityInput}. Valid: letta-code, linus, kawaii, claude, codex`);
     return 1;
   }
-  let personalityBlockDefinitions;
-  if (personality) {
-    personalityBlockDefinitions = getPersonalityBlockDefinitions(personality);
-  }
-  const options = {
+  const options = personality ? await buildCreateAgentOptionsForPersonality({
+    personalityId: personality
+  }) : {
     memoryPromptMode: "memfs"
   };
-  if (personalityBlockDefinitions) {
-    const defaultMemoryBlocks = await getDefaultMemoryBlocks();
-    options.memoryBlocks = defaultMemoryBlocks.map((block) => {
-      if (block.label === "persona") {
-        return {
-          label: block.label,
-          value: personalityBlockDefinitions.persona.value,
-          description: personalityBlockDefinitions.persona.description ?? block.description ?? undefined
-        };
-      }
-      if (block.label === "human") {
-        return {
-          label: block.label,
-          value: personalityBlockDefinitions.human.value,
-          description: personalityBlockDefinitions.human.description ?? block.description ?? undefined
-        };
-      }
-      return {
-        label: block.label,
-        value: block.value,
-        description: block.description ?? undefined
-      };
-    });
-  }
   if (typeof values.name === "string") {
     options.name = values.name;
   }
@@ -145903,21 +146121,23 @@ async function runCreateAction(values) {
     options.tags = tags;
   }
   try {
-    const result = await createAgent(options);
+    const result = personality ? await createAgentForPersonality({
+      personalityId: personality,
+      name: options.name,
+      description: options.description,
+      model: options.model,
+      tags: options.tags
+    }) : await createAgent(options);
     const agentId = result.agent.id;
+    if (!personality) {
+      await enableMemfsForCreatedAgent({
+        agentId,
+        agentTags: result.agent.tags
+      });
+    }
     if (values.pinned) {
       settingsManager.pinGlobal(agentId);
     }
-    try {
-      const client2 = await getClient();
-      const agentTags = result.agent.tags || [];
-      if (!agentTags.includes(GIT_MEMORY_ENABLED_TAG)) {
-        await client2.agents.update(agentId, {
-          tags: [...agentTags, GIT_MEMORY_ENABLED_TAG]
-        });
-      }
-      settingsManager.setMemfsEnabled(agentId, true);
-    } catch {}
     const client = await getClient();
     const updatedAgent = await client.agents.retrieve(agentId);
     console.log(JSON.stringify(updatedAgent, null, 2));
@@ -150089,7 +150309,7 @@ Error: ${message}`);
   markMilestone2("REACT_IMPORT_START");
   const React14 = await Promise.resolve().then(() => __toESM(require_react2(), 1));
   const { render: render2 } = await init_build5().then(() => exports_build);
-  const { useState: useState56, useEffect: useEffect40 } = React14;
+  const { useState: useState56, useEffect: useEffect41 } = React14;
   const AppModule = await init_App2().then(() => exports_App);
   const App3 = AppModule.default;
   function LoadingApp({
@@ -150127,14 +150347,14 @@ Error: ${message}`);
     const [selfHostedBaseUrl, setSelfHostedBaseUrl] = useState56(null);
     const [releaseNotes2, setReleaseNotes] = useState56(null);
     const [updateNotification, setUpdateNotification] = useState56(null);
-    useEffect40(() => {
+    useEffect41(() => {
       autoUpdatePromise.then((result) => {
         if (result?.latestVersion) {
           setUpdateNotification(result.latestVersion);
         }
       }).catch(() => {});
     }, []);
-    useEffect40(() => {
+    useEffect41(() => {
       async function autoInstallKeybinding() {
         const {
           detectTerminalType: detectTerminalType3,
@@ -150191,7 +150411,7 @@ Error: ${message}`);
       autoInstallKeybinding();
       autoInstallWezTermFix();
     }, []);
-    useEffect40(() => {
+    useEffect41(() => {
       async function checkNotes() {
         const { checkReleaseNotes: checkReleaseNotes2 } = await init_release_notes().then(() => exports_release_notes);
         const notes = await checkReleaseNotes2();
@@ -150199,7 +150419,7 @@ Error: ${message}`);
       }
       checkNotes();
     }, []);
-    useEffect40(() => {
+    useEffect41(() => {
       async function checkAndStart() {
         await settingsManager2.loadLocalProjectSettings();
         const localSettings = settingsManager2.getLocalProjectSettings();
@@ -150372,7 +150592,7 @@ Error: ${message}`);
       shouldResume,
       specifiedConversationId
     ]);
-    useEffect40(() => {
+    useEffect41(() => {
       if (loadingState !== "assembling")
         return;
       async function init() {
@@ -150423,7 +150643,7 @@ Error: ${message}`);
         const modelForTools = getModelForToolLoading(model, toolset);
         await loadTools2(modelForTools);
         setLoadingState("initializing");
-        const { createAgent: createAgent3 } = await init_create3().then(() => exports_create);
+        const { createAgent: createAgent3 } = await init_create3().then(() => exports_create2);
         let agent = null;
         if (fromAfFile2) {
           setLoadingState("importing");
@@ -150826,4 +151046,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=B4D4FA14AA481C6C64756E2164756E21
+//# debugId=0CA763A3D8DFE56864756E2164756E21