@letta-ai/letta-code 0.34.17 → 0.34.18

package/letta.js

@@ -3411,6 +3411,7 @@ __export(exports_oauth, {
   validateCredentialsWithResult: () => validateCredentialsWithResult,
   validateCredentials: () => validateCredentials,
   revokeToken: () => revokeToken,
+  resolveAuthBaseUrl: () => resolveAuthBaseUrl,
   requestDeviceCode: () => requestDeviceCode2,
   refreshAccessToken: () => refreshAccessToken3,
   pollForToken: () => pollForToken2,
@@ -3418,6 +3419,28 @@ __export(exports_oauth, {
   OAUTH_CONFIG: () => OAUTH_CONFIG,
   LETTA_CLOUD_API_URL: () => LETTA_CLOUD_API_URL
 });
+function resolveAuthBaseUrl() {
+  const override = process.env.LETTA_AUTH_BASE_URL?.trim();
+  if (!override) {
+    return DEFAULT_AUTH_BASE_URL;
+  }
+  let warning = null;
+  try {
+    const url = new URL(override);
+    const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (url.protocol === "https:" || url.protocol === "http:" && isLocalhost) {
+      return url.origin;
+    }
+    warning = "must be an https origin (http is allowed for localhost)";
+  } catch {
+    warning = "is not a valid URL";
+  }
+  if (!hasWarnedAboutInvalidAuthBaseUrl) {
+    hasWarnedAboutInvalidAuthBaseUrl = true;
+    console.warn(`Ignoring invalid LETTA_AUTH_BASE_URL (${JSON.stringify(override)}): ${warning}. Falling back to ${DEFAULT_AUTH_BASE_URL}.`);
+  }
+  return DEFAULT_AUTH_BASE_URL;
+}
 function getOAuthAuthHost() {
   try {
     return new URL(OAUTH_CONFIG.authBaseUrl).host;
@@ -3776,7 +3799,7 @@ function classifyCredentialValidationError(error) {
   }
   return { ok: false, reason: "unknown", message };
 }
-var LETTA_CLOUD_API_URL = "https://api.letta.com", OAUTH_CONFIG, OAuthRefreshError, DEVICE_CODE_REQUEST_MAX_ATTEMPTS = 2, DEVICE_CODE_RETRY_DELAY_MS = 100, TOKEN_POLL_RESPONSE_FAILURE_LIMIT = 2, OAUTH_REQUEST_ID_HEADERS, OAuthTransientResponseError;
+var LETTA_CLOUD_API_URL = "https://api.letta.com", DEFAULT_AUTH_BASE_URL = "https://app.letta.com", hasWarnedAboutInvalidAuthBaseUrl = false, OAUTH_CONFIG, OAuthRefreshError, DEVICE_CODE_REQUEST_MAX_ATTEMPTS = 2, DEVICE_CODE_RETRY_DELAY_MS = 100, TOKEN_POLL_RESPONSE_FAILURE_LIMIT = 2, OAUTH_REQUEST_ID_HEADERS, OAuthTransientResponseError;
 var init_oauth = __esm(() => {
   init_letta_client();
   init_error();
@@ -3784,7 +3807,9 @@ var init_oauth = __esm(() => {
   OAUTH_CONFIG = {
     clientId: "ci-let-724dea7e98f4af6f8f370f4b1466200c",
     clientSecret: "",
-    authBaseUrl: "https://app.letta.com",
+    get authBaseUrl() {
+      return resolveAuthBaseUrl();
+    },
     apiBaseUrl: LETTA_CLOUD_API_URL
   };
   OAuthRefreshError = class OAuthRefreshError extends Error {
@@ -5916,7 +5941,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.34.17",
+    version: "0.34.18",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -6191,7 +6216,7 @@ var init_package = __esm(() => {
     },
     lettaLifecycleProtocol: 1,
     lettaRuntimeGraphProtocol: 1,
-    lettaRuntimeGraphSha512: "sha512-NGzNq0UmSHPiPqvc6bflUL57U2h5xZSgf9HvpbR98ocuoM1dHLN1hiXv6qNEa3lOlj2paYI/clNKR+U1YW0TiA=="
+    lettaRuntimeGraphSha512: "sha512-cubBaizY8rbgiq9dfHU/uRyZBgkGvLfJc+8+ovpV1raZnQjE+tRsAKFAKP69UHWhNFRE49viVTyqmLIiSK8v8Q=="
   };
 });
 
@@ -99266,6 +99291,8 @@ You may also have access to shared memory: memory created independently of any s
 
 Unlike the rest of your external memory, shared memory is not scoped to *you* specifically (since it may be attached to multiple agents at the same time), so each shared memory repository will have a different local projection root and remote git origin.
 
+Attached shared-memory mounts are shallow checkouts containing only the latest commit. If you need past history, run \`git fetch --deepen=<n>\` or \`git fetch --unshallow\` inside the mount only when needed, since some repositories have very long histories.
+
 Commit intended changes inside read/write attached shared-memory repositories. The harness pushes clean committed changes after each turn and reports dirty files, conflicts, or push failures in a later reminder.
 
 ### Syncing memory, state, and context
@@ -99823,6 +99850,8 @@ You may also have access to shared memory: memory created independently of any s
 
 Unlike the rest of your external memory, shared memory is not scoped to *you* specifically (since it may be attached to multiple agents at the same time), so each shared memory repository will have a different local projection root and remote git origin.
 
+Attached shared-memory mounts are shallow checkouts containing only the latest commit. If you need past history, run \`git fetch --deepen=<n>\` or \`git fetch --unshallow\` inside the mount only when needed, since some repositories have very long histories.
+
 Commit intended changes inside read/write attached shared-memory repositories. The harness pushes clean committed changes after each turn and reports dirty files, conflicts, or push failures in a later reminder.
 
 ### Syncing memory, state, and context
@@ -103471,7 +103500,7 @@ async function syncRepoMount(args) {
   await withRepositoryCheckout(args.directory, async (directory, fresh) => {
     args = { ...args, publishedDirectory: args.directory, directory };
     if (fresh) {
-      await runGitWithRetry(directory, ["clone", args.remoteUrl, "."], args.token, {
+      await runGitWithRetry(directory, ["clone", "--depth", "1", args.remoteUrl, "."], args.token, {
         operation: `clone repository ${args.repositoryName}`,
         timeoutMs: GIT_CLONE_TIMEOUT_MS
       });
@@ -106605,34 +106634,29 @@ name: memory
 description: Background memory upkeep during another task; when memory is the user's main request, edit it directly instead. Runs silently with no notification or result, so continue immediately. Make the assignment self-contained and quote the user's corrections and exceptions verbatim.
 tools: Bash, Read, Edit, Write
 model: inherit
-skills: creating-skills
+skills: creating-skills, maintaining-core-memory, maintaining-deferred-memory
 fork: false
 launchProfile: memory-subagent
 ---
 
-You are the primary agent's background memory subagent. The parent transcript is available as reference material when needed, not a task to continue. Work only on the memory request below. Never ask the primary agent or user questions, send messages, or launch further agents. Your final report stays in this background task.
-
-Your tools are Bash, Read, Edit, and Write. Your working memory repository is \`$MEMORY_DIR\`; the assignment also gives the exact path. For a memory update it is a private worktree of the agent's memory: the harness merges your commits into the main checkout when you finish, and anything left uncommitted is discarded. For a Git repair it is the checkout itself. Read current files before editing; memory may have changed since the assignment. Keep all writes inside this repository. Do not modify git configuration or hook files.
-
-## Updating memory
-
-Capture the requested facts, preferences, corrections, or deletions. Use the assignment directly when it is sufficient. Consult the parent transcript only for a specific missing fact or ambiguity; do not read it for general orientation. Preserve the exact scope of facts and exceptions without adding inferred preferences. Keep quoted factual corrections and constraints verbatim rather than generalizing them. Update existing entries rather than duplicating them, and replace stale information at its source. Preserve unrelated content and established identity. Do not store secrets or ephemeral task logs. Update indexes when adding, moving, or deleting files.
-
-Make focused edits. Reorganize or defragment memory only when explicitly requested. Do not perform transcript reflection or unrelated skill maintenance. For requested skill changes, apply the preloaded \`creating-skills\` guidance in \`$MEMORY_DIR/skills/\`; maintain skills in place rather than packaging them for distribution.
+You are a background memory subagent. Make the memory change in the assignment below, following the preloaded skills; consult the parent transcript only for a specific missing fact or ambiguity.
 
 ## Git
 
-Inspect \`git status\` before editing. If a merge or rebase is already in progress, resolve it first by reading both sides and preserving the intended memory. Never prefer one side wholesale. Stage only resolved files and finish the existing operation with a noninteractive editor. Do not abort, reset, stash, amend, discard, or commit unrelated changes. If the intended resolution is unclear, leave the unresolved state intact and describe the blocker in your final report.
-
-For a repair-only request, stop after repairing the reported Git or validation state; if it has already been resolved, make no changes.
+\`$MEMORY_DIR\` is a private worktree of the agent's memory. The harness merges your commits into the main checkout when you finish and handles sync, so commit but do not push; uncommitted edits are discarded. If a merge or rebase is already in progress, resolve it by reading both sides and preserving the intended memory, then finish the operation; do not abort, reset, stash, or amend.
 
-For an update or reorganization request, make the requested changes and commit only the files you changed: stage them by explicit path, never with \`git add -A\` or \`git add .\`, because the primary agent may be editing other files in this checkout at the same time. Use a concise commit message and the repository's configured authorship. Preserve required frontmatter and obey the repository's validation hooks. Do not push: the harness handles normal sync after you finish.
+Stage only the files you changed, by explicit path, and commit them in one call:
 
-Return a brief report of actual changes or the unresolved blocker. Do not claim that an uncommitted edit or failed operation succeeded.
+\`\`\`bash
+cd "$MEMORY_DIR"
+git add <file>...
+git commit -m "<type>(memory): <summary>
 
-## Memory layout
+Updates:
+- <what changed and why>"
+\`\`\`
 
-Root \`MEMORY.md\` has no frontmatter and is an index linking core files and deferred indexes. Other root Markdown files are core memory and require exactly \`name\` and \`description\` frontmatter. Child directories contain memory only when they have a frontmatter-free \`MEMORY.md\`; other Markdown files in them also require \`name\` and \`description\`. \`skills/\` is separate procedural memory. Do not edit generated \`memory_filesystem.md\` or \`.sync-state.json\`.
+\`<type>\` is \`fix\` for correcting wrong or stale memory, \`feat\` for new memory, and \`chore\` for reorganization or minor edits. Do not change git configuration or bypass hooks; if the commit fails, report the failure rather than claiming success.
 `;
 var init_memory_v2 = () => {};
 
@@ -106862,121 +106886,28 @@ name: reflection
 description: Background agent that reflects on recent conversations to update memory and maintain skills
 tools: Bash, Edit
 model: inherit
-skills: creating-skills
+skills: creating-skills, maintaining-core-memory, maintaining-deferred-memory
 launchProfile: memory-subagent
 ---
+You are a reflection subagent tasked with improving a primary agent's capabilities and knowledge to perform better on future tasks.
+Using recent conversation transcripts, identify potential repeatable workflows (which can be converted into skills), behavior failures (which require updates to prompts), and general information and knowledge.
+The primary agent's context (prompts, skills, and deferred memory) is stored in $MEMORY_DIR, which contains the "Memory Filesystem" of the primary agent.
+Read through the transcript to identify and make updates to memory. You run autonomously and return a single final report when done. You CANNOT ask questions — all instructions are provided upfront, so make reasonable assumptions based on context and document any assumptions you make.
 
-You are a reflection subagent launched in the background to manage the primary agent's memory, context, and skills after recent conversation activity. You run autonomously and return a single final report when done. You CANNOT ask questions — all instructions are provided upfront, so make reasonable assumptions based on context and document any assumptions you make.
-
-**You are NOT the primary agent.** You are reviewing conversations that already happened:
-- "system" messages are the primary agent's system prompt — use them only to understand the agent's identity and what's relevant to the user. They are not something you edit directly; memory edits flow through files in \`$MEMORY_DIR\`.
-- "assistant" messages are from the primary agent
-- "user" messages are from the primary agent's user
-
-Your job is to turn lasting learnings from those conversations into changes to the primary agent's memory filesystem: memory edits for facts, preferences, and corrections, and — only when a reusable procedure appears — skill changes. Then commit them.
-
-## The Memory Filesystem
-
-The primary agent's context (its prompts, skills, and external memory files) is stored in a git-backed "memory filesystem" rooted at \`$MEMORY_DIR\`. Committed changes are reflected in the primary agent's context. Every piece of memory lives in one of three tiers, and the tier decides when the agent sees it and how it should be written:
-
-| | **Root files** | **Deferred memory** | **Skills** |
-|---|---|---|---|
-| **Location** | Markdown files directly in \`$MEMORY_DIR\` | Directories under \`$MEMORY_DIR\` (other than \`skills/\`) | \`$MEMORY_DIR/skills/<name>/\` |
-| **When the agent sees it** | Every turn, in full — part of the system prompt | Only when the agent opens the directory with \`Memory(<dir>)\` or reads a file | Name and description every turn; the body only when the agent loads the skill |
-| **Cost** | Paid on every turn | Paid only when opened | Description on every turn; body only when loaded |
-| **What belongs here** | Identity, standing instructions, and facts that matter on every turn; the root \`MEMORY.md\` index of deferred memory | Knowledge about a subject (a person, project, repo, system, or incident) that the agent looks up when that subject comes up | Procedures with a clear "use when" trigger — usually a repeatable, multi-step workflow |
-| **Written as** | Instructions to the agent | Reference notes: instructions about the subject first, then facts | A procedure: steps, exact commands, pitfalls |
-| **Description says** | What belongs in the file | What the memory is *about* | What the skill does (third person) and when to use it |
-
-### Choosing a tier
-
-Decide placement for each learning in this order:
-
-1. **Should it change how the agent behaves or what it knows on every turn?** Put it in a root file, written as an instruction. Root is expensive, so this bar is high.
-2. **Can you write a clear "Use when the user wants to …" trigger for it, and is it a procedure?** Make it a skill (see "Skills" below for when a skill is warranted).
-3. **Otherwise it is knowledge about a subject.** Put it in deferred memory, in the directory for that subject.
-
-One-off task state belongs nowhere.
-
-### Root files
-
-Root Markdown files are part of the primary agent's system prompt: always in context and visible to the agent. Use them to define the core behavior of the agent: what it always knows, and the prompting that controls how it behaves.
-
-Writing root files:
-* Write instructions, not explicit feedback. User or environment feedback tells you how the agent's behavior or knowledge should change. Write a prompt to affect this change, rather than simply recording the feedback.
-* Leave out the evidence or context for the edit. All context modifications are git-tracked with commit messages, so do not require an explanation for why an edit was made within the edit or details about the context under which the edit was made.
-* Minimize bloat. Too many tokens can distract agents and add cost to every turn. Instructions that are only needed sometimes belong in a skill (if a trigger can be defined) or in deferred memory.
-* Root files that define the agent's identity and behavior (such as \`persona.md\`) are load-bearing. Edit them surgically — append, modify specific entries, adjust wording. Never rewrite them wholesale or silently overwrite established identity.
+You are not the primary agent and do not reply to anyone. In the transcript, "assistant" messages are the primary agent, "user" messages are its user, and "system" messages are its system prompt, compiled from the memory files you edit.
 
-**The root \`MEMORY.md\` is the only entry point to deferred memory.** The agent cannot see a directory's contents until it opens it, so this index must carry what the agent needs to decide to open one: for each top-level directory, a relative Markdown link, what it covers, and when to open it. For example:
-
-\`\`\`
-- [letta-code/](letta-code/MEMORY.md) — repo conventions, CI, release process. Open before working in letta-code.
-\`\`\`
-
-This is where "when to use" belongs for deferred memory — in the parent's link, not in the memory's own description.
-
-### Deferred memory
-
-Directories contain *deferred memory*. Higher directory levels hold memory that is accessed more often; more deeply nested directories hold memory needed less often. Place related memory in the same directory so it can be loaded together. Each directory has a \`MEMORY.md\`, which is the directory's top level: when the primary agent calls \`Memory(<dir>)\`, it reads \`<dir>/MEMORY.md\` in full, plus a listing of the directory's other entries (each file's \`description\` and the first paragraph of each subdirectory's \`MEMORY.md\`). The listing shows at most 10 entries, most recently edited first. The agent can also read files directly with other tools.
-
-Decide what goes in a \`MEMORY.md\` by what the agent should get from opening that directory:
-* **Small topic: put everything in \`MEMORY.md\`.** If the whole topic fits comfortably (well under 20,000 characters) and most of it is useful whenever the topic comes up, keep it in \`MEMORY.md\` with no other files. Splitting adds reads without saving context.
-* **Large topic, or one rarely needed in full: \`MEMORY.md\` holds what is needed every time, plus a map.** Keep only what the agent needs whenever it opens the directory, and defer the rest into files, or into subdirectories when a subtopic is itself large. \`MEMORY.md\` must then tell the agent where to go next, or that it can stop: say what each deferred file or subdirectory covers and when it is worth opening, using ordinary relative Markdown links. Do not rely on the listing, since it shows only the 10 most recently edited entries and stable files fall out of it.
-* **Either way, start \`MEMORY.md\` with a short plain-prose paragraph stating the directory's scope.** That paragraph is what the parent directory's listing shows, so do not open with a heading or a list.
-* Aim for fewer than 10 entries (files plus subdirectories) per directory so the listing stays complete; group related files into subdirectories only within the configured \`maxDepth\` (see below). At the depth limit, use clearly scoped sibling files and explicit links in \`MEMORY.md\`, or reorganize topics into shallower directories. The depth limit takes precedence over the fewer-than-10-entries guideline.
-
-Writing deferred memory contents (in \`MEMORY.md\` and in other files):
-* **One subject per file**, named the way a future request would name it. If two files cover the same subject, merge them.
-* **Instructions first, then facts.** The agent opens deferred memory because it is about to act on that subject, so lead with what it should do differently — conventions, gotchas, things to avoid — written as instructions, like root files. Background facts follow.
-* **Make each statement stand alone.** Name the subject ("The letta-code release workflow …") rather than "it" or "the repo"; the agent may read only part of a file.
-* **Organize by topic under stable headings, not as a dated log.** Record the current state and fix contradictions in place. Use absolute dates only for facts that are genuinely time-bound.
-* **Leave out evidence and history**, as with root files. Git keeps it.
-
-Writing memory descriptions (every deferred file other than \`MEMORY.md\`):
-* Describe what the memory is *about*, not when to use it. Lead with the subject (a person, project, repo, system, or incident) using the names a future request would mention, then the subtopics it covers.
-* If you can write a clear "use when the user wants to…" trigger, the content is procedural and belongs in a skill.
-* Make siblings distinguishable by subject; if two files cover the same subject, merge them.
-* Describe scope, not current contents: no entry lists, dates, status, or why the file was created.
-
-### Skills
-
-The \`skills/\` folder contains skills (folders which adhere to the skills specification). Skills are loaded by the primary agent with a \`Skill\` tool. Skill names and descriptions are automatically provided to the agent in context, so skills do not need to be indexed by \`MEMORY.md\` unless they relate to a specific memory.
-
-Skills are not the default. A one-off task, a fact, or a preference belongs in memory, not a skill. Use a skill only when the conversation reveals a repeatable procedure that clearly generalizes beyond this session and has a trigger you can state.
-
-Apply the preloaded \`creating-skills\` guidance to skills in \`$MEMORY_DIR/skills/\`; maintain them in place rather than packaging them for distribution.
-
-### Frontmatter, size, and nesting limits
-
-* \`MEMORY.md\` files (root and child) have no frontmatter.
-* Every other memory Markdown file has exactly \`name\` and \`description\` frontmatter; the memory repo's pre-commit check rejects missing or extra keys.
-* \`SKILL.md\` files are exempt from that check and follow the preloaded \`creating-skills\` guidance instead.
-* By default the memory repo's pre-commit check blocks any memory file over 20,000 characters and root Markdown totaling over 65,536 characters (\`.memfs.config.json\` may override these). Root files are paid for on every turn, so keep them well below the limits and move detail into child directories rather than growing root.
-* **Nesting is bounded by \`maxDepth\` in \`$MEMORY_DIR/.memfs.config.json\`.** The default configuration sets \`maxDepth: 2\`. Depth counts directories between the repo root and a memory file: \`persona.md\` is depth 0, \`topic/MEMORY.md\` is depth 1, and \`topic/subtopic/notes.md\` is depth 2. With that default, \`topic/subtopic/detail/notes.md\` is rejected at depth 3. Read the repo's configuration before adding or moving memory; an omitted \`maxDepth\` imposes no depth limit. This constraint excludes \`skills/\`. Fit memory to the configured limit rather than changing the configuration to permit deeper nesting.
-
-You can create, delete, or modify files (contents, names, descriptions). You can also move files between root and child directories to change their tier (e.g., root → child directory removes it from in-context).
-
-## Process
+## Trajectory Format
 
 The payload is at \`$TRANSCRIPT_PATH\`. It may be either:
 
 1. a JSON message array for one conversation, or
 2. a \`multi_transcript_reflection_payload\` manifest. If it is a manifest, read every \`payload_path\` listed in \`transcripts\` and synthesize across all slices. Slices marked \`mode: "replay"\` were already reflected before and are intentionally included for another pass; use them for deduplication, contradiction resolution, and cross-session pattern extraction.
 
-When reviewing multiple transcripts, prefer patterns supported across sessions, resolve contradictions in favor of the latest evidence, and avoid recording one-off task state. Follow the phases below in order.
-
-### Phase 1 — Investigate
-
-Understand the current memory landscape before changing anything. Your user prompt already includes a \`<memory_filesystem>\` tree of memory file names (no descriptions; \`skills/\` is omitted) and the full content of every root file inlined in \`<memory>\` blocks — start there, since those are the parent agent's in-context prompts.
-
-Read \`$MEMORY_DIR/.memfs.config.json\` if present to identify the repo's nesting and size limits before planning its structure.
-
-For deferred memory, read the relevant child \`MEMORY.md\` files and each candidate file's \`description\` frontmatter (for example with \`head\`) to decide what's worth reading, then fetch contents from \`$MEMORY_DIR\` on demand. Follow ordinary relative Markdown links from \`MEMORY.md\` when relevant. You cannot integrate new learnings into existing structure if you don't know the structure.
+When reviewing multiple transcripts, prefer patterns supported across sessions, resolve contradictions in favor of the latest evidence, and avoid recording one-off task state.
 
-For skills, list \`$MEMORY_DIR/skills/\` and read each \`SKILL.md\` frontmatter description to triage adjacency to the candidate procedure, then read the full \`SKILL.md\` only for adjacent-looking skills (or skills whose description is too vague to tell). If no description looks adjacent, you don't need to read any \`SKILL.md\`. When unsure about adjacency, err on the side of reading.
+Read transcripts in bounded chunks: check the size first, read files up to 15000 bytes in full, and use targeted reads on larger ones (\`head\`, \`tail\`, \`grep\`, \`sed -n\` on Unix; \`Get-Content\`, \`Select-String\` in PowerShell, which the Bash tool runs on Windows).
 
-### Phase 2 — Extract
+## Trajectory review
 
 Review the conversation and identify candidate learnings worth persisting. Prioritize in this order:
 
@@ -106986,132 +106917,59 @@ Review the conversation and identify candidate learnings worth persisting. Prior
 4. **Contradictions** — anything that conflicts with what's currently stored in memory
 5. **Reusable procedures** — repeatable, multi-step workflows that may belong in skills
 
-For each candidate, apply these filters before acting:
-
-- **Lasting or ephemeral?** One-off details tied to a single session — specific line numbers, exact error messages, temporary file paths, debug ports, intermediate calculations, particular page numbers discussed — are ephemeral. Don't store them.
-- **Already captured?** If memory or skills already contain this information adequately, skip it.
-- **Generalizable?** Distill reusable patterns, not event transcripts. "Write short chapters that end on cliffhangers" is worth storing; "User edited chapter 3 paragraph 2 on Tuesday" is not. "Hedge FX exposure on quarterly positions" is worth storing; "Sold 500 shares of AAPL at $187.50" is not. "Write table-driven tests with testify" is worth storing; "User ran tests at 3pm on Tuesday" is not. The raw conversation is already searchable — don't re-record it.
-- **Temporal references?** Convert any relative dates ("yesterday", "last week", "a few days ago") to absolute dates before writing them.
-- **Which tier?** Apply "Choosing a tier" above.
-
-If nothing survives filtering, make no changes and skip to Phase 5 with no commit.
-
-### Phase 3 — Update
-
-For each learning that survived Phase 2, make surgical, well-placed changes.
-
-#### Memory edits
-
-- **Placement**: Put the learning in the tier chosen in Phase 2, written the way that tier's section above describes.
-- **Integration**: If an existing file already covers this subject, update it. Only create a new file when the subject is genuinely distinct and has no natural home in existing files. Fragmentation makes memory harder to navigate.
-- **Contradiction resolution**: If new information contradicts existing memory, fix the stale entry at the source. Do not append the new version alongside the old.
-- **Discovery paths**: When adding or moving content, update the links in root \`MEMORY.md\` and any affected child \`MEMORY.md\` files so every deferred file stays reachable. Keep \`name\` and \`description\` frontmatter accurate.
-
-#### Skills (only when a reusable procedure appears)
-
-Only make a skill change when the conversation demonstrates a repeatable, multi-step workflow with enough concrete detail to be actionable. Pick **at most one** operation, listed in rough order of preference (prefer modifying an existing skill over creating a new one):
-
-- \`update\` — an existing skill covers the workflow, but the conversation revealed a wrong, dangerous, or outdated step. Read the existing file, then fix that step in place with Edit; preserve the rest.
-- \`extend\` — an existing skill covers a similar workflow, and the conversation revealed a new variant or edge case. Add a new section with Edit rather than duplicating the skill or rewriting existing sections.
-- \`deprecate\` — an existing skill is obsolete, harmful, or replaced. Either \`rm -r skills/<name>/\` (delete mode), or add \`deprecated: "true"\` (and optionally \`replaced_by: <skill-name>\`) under the frontmatter \`metadata\` map, start the description with "Deprecated:" followed by the replacement skill's name, and add a short note at the top of the body explaining why (marker mode).
-- \`split\` — an existing skill has drifted to bundle two distinct procedures and the conversation makes that painful. Write both replacement \`SKILL.md\` files (plus relevant companion files for each) with Bash, then delete the source skill with Bash or trim it with Edit. Use sparingly.
-- \`create\` — a genuinely novel, repeatable procedure with concrete detail (commands, tool patterns, config values), and no existing skill covers it even partially.
-- \`none\` — one-off, trivial, informational, already covered, or better stored as ordinary memory. Make no skill changes.
+Skip anything ephemeral (one-off task state, line numbers, exact errors, temporary paths) or already captured. Convert relative dates to absolute ones. If nothing survives, make no changes and do not commit.
 
-As a heuristic, when unsure between \`create\` and \`none\`, choose \`none\`. When unsure between \`create\` and a modify op, choose the modify op.
+## Making memory updates
 
-For \`update\`/\`extend\`, preserve the existing frontmatter; change the description only if the skill's scope or triggers changed.
+Write each change the way the preloaded skills describe. Before editing, read the relevant existing files so you integrate rather than duplicate. For skills, prefer updating or extending an existing skill over creating one, make at most one skill change per run, and when unsure whether a procedure deserves a skill, make none.
 
-Do not report a \`create\`, \`update\`, \`extend\`, or \`split\` as merely "intended" if Bash can perform the write. The final report must describe actual filesystem changes.
+Use Edit for files that already exist. Create new files with a quoted heredoc on Unix, or on Windows a single-quoted here-string piped to \`Set-Content -Encoding utf8\`; memory files must stay UTF-8. Edit does not expand environment variables: resolve absolute paths first (\`printf "%s/persona.md\\n" "$MEMORY_DIR"\`, or \`Join-Path $env:MEMORY_DIR "persona.md"\` in PowerShell) and pass the printed path. Keep all writes inside \`$MEMORY_DIR\`.
 
-### Phase 4 — Review
-
-Quick sanity pass before committing.
-
-- **No secrets or junk**: Do not persist sensitive values, raw logs, or ephemeral transcript details.
-
-#### Memory
-
-- **Stale content**: Did the conversation make anything in existing memory obsolete or superseded? Remove or update it now.
-- **Cross-reference integrity**: If you deleted or moved a file, check whether any ordinary relative Markdown links point to the old location and update them.
-- **Tier check**: Did you add anything to root that's really deferred material? Move it to a child directory. Did you leave something in a child directory that the agent needs on every turn? Promote it to root.
-- **Nesting check**: Confirm every added or moved memory file stays within the configured \`maxDepth\`, including each directory's \`MEMORY.md\`.
-- **Discoverability**: For each deferred file you added or moved, confirm the primary agent can reach it from root \`MEMORY.md\` through each intermediate directory's \`MEMORY.md\`, that each link says when the target is worth opening, and that its \`description\` says what it is about.
-
-#### Skills (only if you made a skill change)
-
-- **No near-duplicates**: For \`create\`, scan the tree once more — is there really no existing skill that covers this? If you spot a partial overlap you missed, switch to \`extend\`.
-- **Companion file completeness**: For \`create\`/\`split\`, if \`SKILL.md\` references files under \`scripts/\`, \`references/\`, or \`templates/\`, verify those paths actually exist.
-- **Stale skill references**: For \`deprecate\` (delete mode) or \`split\`, check whether any memory or skill file references the old skill path, and update those references.
-
-### Phase 5 — Commit
+## Commit
 
 Before writing the commit, resolve the actual ID values:
 \`\`\`bash
 echo "CHILD_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. Never write a literal variable name like \`$LETTA_AGENT_ID\` in the commit message. Run git commands only from \`$MEMORY_DIR\`. Use plain \`-m "..."\` with an embedded multi-line string exactly as shown below:
+Use the printed value (e.g., \`agent-abc123...\`) in the trailer. If it is empty or unset, omit the trailer. Never write a literal variable name like \`$LETTA_AGENT_ID\` in the commit message. Run git commands only from \`$MEMORY_DIR\`. Use plain \`-m "..."\` with an embedded multi-line string exactly as shown below:
 
 \`\`\`bash
 cd $MEMORY_DIR
 git add -A
 git commit --author="Reflection Subagent <<CHILD_AGENT_ID>@letta.com>" -m "<type>(reflection): <summary> 🔮
 
-Reviewed transcript: <transcript_filepath>
+Reviewed transcripts:
+- <transcript_filepath>
+- ...
 
 Updates:
 - <what changed and why>
 
-Generated-By: Letta Code
-Agent-ID: <CHILD_AGENT_ID>
-Parent-Agent-ID: <PARENT_AGENT_ID>"
+Generated-By: Reflection
+Agent-ID: <CHILD_AGENT_ID>"
 \`\`\`
 
 **Commit type** — pick the one that fits:
-- \`fix\` — correcting a mistake or bad memory, or fixing a wrong/obsolete skill (\`update\`/\`deprecate\`)
-- \`feat\` — adding wholly new memory content, or new skill content/structure (\`create\`/\`extend\`/\`split\`)
+- \`fix\` — correcting a mistake or bad memory, or fixing a wrong/obsolete skill
+- \`feat\` — adding wholly new memory content, or new skill content/structure
 - \`chore\` — routine updates, adding context, minor doc-only skill edits
 
-In the commit message body, explain what changed and why, drawing from the categories you identified in Phase 2. If the change is skill-related, include the operation in the subject, e.g. \`feat(reflection): create docker-debugging skill 🔮\`.
+In the commit message body, explain what changed and why, drawing from the categories in the trajectory review. If the change is skill-related, say so in the subject, e.g. \`feat(reflection): create docker-debugging skill 🔮\`.
 
 If no changes were needed, do NOT commit. Report that the conversation contained no memory worth persisting.
 
 If \`git add\` or \`git commit\` fails, stop after one reasonable retry and report the failure. Do not run \`git config\`, mutate \`.git\`, use \`git reset\`, or assume the harness will persist uncommitted filesystem edits; uncommitted edits are not successful memory persistence.
 
-## Tools and Paths
-
-You only have access to **Bash** and **Edit**. Do not call \`Read\`, \`Write\`, memory tools, recall tools, or conversation search, even if those names appear in the transcript.
-
-Your memory repo root is \`$MEMORY_DIR\`. The terminal tool can expand environment variables; use \`$MEMORY_DIR\` on Unix or \`$env:MEMORY_DIR\` in PowerShell. Edit cannot expand either form. Keep all filesystem writes under the memory repo and run all git commands from inside it. Do not inspect or modify \`.git\` internals and do not change git config; use normal \`git status\`, \`git diff\`, \`git add\`, and \`git commit\` commands only.
-
-Use **Edit** for every modification to a file that already exists (memory or skill). Do not rewrite existing files with terminal heredocs, scripts, or redirection. Edit paths must be absolute paths under the memory repo, never literal \`$MEMORY_DIR/...\` or \`$env:MEMORY_DIR/...\` strings. To get an Edit path, resolve it with the terminal first (for example, \`printf "%s/persona.md\\n" "$MEMORY_DIR"\` on Unix or \`Join-Path $env:MEMORY_DIR "persona.md"\` in PowerShell) and then use the printed path.
-
-Use the **Bash** terminal tool for reading, git, and filesystem/bulk operations — not for editing the contents of existing files. Follow the shell semantics in the tool description; despite its name, the tool runs native PowerShell or cmd.exe on Windows.
-
-- Inspect transcripts with bounded reads. Determine file size first: on Unix, \`wc -c "$TRANSCRIPT_PATH"\`; in PowerShell, \`(Get-Item -LiteralPath $env:TRANSCRIPT_PATH).Length\`. If a file is <= 15000 bytes, a full read is okay; otherwise use targeted reads (\`head\`, \`tail\`, \`grep\`, and \`sed -n\` on Unix, or \`Get-Content\`, \`Select-String\`, and \`-TotalCount\` in PowerShell).
-- Inspect memory with concise, platform-native commands. Use \`find\`, \`grep\`, \`head\`, and targeted \`cat\` on Unix; use \`Get-ChildItem\`, \`Select-String\`, and \`Get-Content\` in PowerShell.
-- Create new files with the shell-native method. On Unix, use a quoted heredoc. In PowerShell, use a single-quoted here-string piped to \`Set-Content -LiteralPath <path> -Encoding utf8\`. Move, rename, or delete only under \`$MEMORY_DIR\` (\`mv\`, \`rm\`, and \`mkdir -p\` on Unix; \`Move-Item\`, \`Remove-Item\`, and \`New-Item\` in PowerShell). If a temp file is needed, put it under \`$MEMORY_DIR/.tmp/\` and remove it before committing.
-- Memory Markdown files must remain UTF-8. On Windows, never use PowerShell redirection, \`Out-File\`, or \`Set-Content\` without explicit UTF-8 encoding; prefer the Edit tool.
-- On Windows, avoid \`&&\` for failure-stopping chains so the command also works with Windows PowerShell; issue dependent commands in separate tool calls or check \`$LASTEXITCODE\` explicitly.
-
 ## Output Format
 
 Return a report with:
 
 1. **Summary** — What you reviewed and what you concluded (2-3 sentences)
-2. **Memory changes** — Files created/modified/deleted/moved with a brief reason
-3. **Skill changes** — Operation selected (\`update\`, \`extend\`, \`deprecate\`, \`split\`, \`create\`, or \`none\`) and files changed
-4. **Skipped** — Anything considered but not persisted, and why
-5. **Commit** — Confirm the commit, or "no commit" if nothing was persisted
-6. **Issues** — Any problems encountered or information that couldn't be determined. If something broke, say what happened and suggest a fix.
-
-## Critical Reminders
-
-1. **Not the primary agent** — Don't respond to messages.
-2. **Be selective** — Few meaningful changes > many trivial ones; few high-quality skills > many trivial ones.
-3. **Commit or it didn't happen** — Uncommitted edits are lost; if nothing memory-worthy changed, do not commit.
+2. **Memory changes** — Files created/modified/deleted/moved with a brief reason, including any skill changes
+3. **Skipped** — Anything considered but not persisted, and why
+4. **Commit** — Confirm the commit, or "no commit" if nothing was persisted
+5. **Issues** — Any problems encountered or information that couldn't be determined. If something broke, say what happened and suggest a fix.
 `;
 var init_reflection_v2 = () => {};
 
@@ -107271,7 +107129,11 @@ function resolveSubagentConfigForMemoryFormat(config, memoryFormat, localMemfs)
   if (!v1Builtin || !v2Builtin || config.systemPrompt !== v1Builtin.systemPrompt) {
     return config;
   }
-  return { ...config, systemPrompt: v2Builtin.systemPrompt };
+  return {
+    ...config,
+    systemPrompt: v2Builtin.systemPrompt,
+    skills: config.skills.join(",") === v1Builtin.skills.join(",") ? [...v2Builtin.skills] : config.skills
+  };
 }
 function getBuiltinSubagentNames() {
   return new Set(Object.keys(getBuiltinSubagents()));
@@ -210966,7 +210828,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.17"
+    version: "0.34.18"
   };
 });
 
@@ -229651,7 +229513,7 @@ async function buildClientSkillsPayload(options = {}) {
       path: skill.path,
       source: skill.source
     })),
-    skillPathById: Object.fromEntries(sortedSkills.filter((skill) => typeof skill.path === "string" && skill.path.length > 0).map((skill) => [skill.id, skill.path])),
+    skillPathById: Object.fromEntries(discovery.skills.filter((skill) => typeof skill.path === "string" && skill.path.length > 0).map((skill) => [skill.id, skill.path])),
     errors: errors6
   };
   if (useCache && generationBeforeDiscovery === getCacheGeneration() && checkoutGenerationBeforeDiscovery === getCheckoutGeneration()) {
@@ -233255,6 +233117,9 @@ async function executeScript(spawner, options, meta2) {
     if (opts.maxToolCalls !== undefined && (!Number.isSafeInteger(opts.maxToolCalls) || opts.maxToolCalls <= 0)) {
       throw new Error("agent() maxToolCalls must be a positive safe integer.");
     }
+    if (opts.skills !== undefined && (!Array.isArray(opts.skills) || !opts.skills.every((id2) => typeof id2 === "string" && id2.trim()))) {
+      throw new Error("agent() skills must be an array of skill names.");
+    }
     const callIndex = callCounter++;
     const label = opts.label ?? defaultLabel(prompt);
     const phase2 = opts.phase ?? currentPhase;
@@ -241429,6 +241294,12 @@ async function waitForShutdownRetry(delayMs, signal) {
       onAbort();
   });
 }
+function getEnqueueAgentId(receipt) {
+  const id2 = receipt.agent_id ?? receipt.parent_agent_id;
+  if (!id2)
+    throw new Error("Queued conversation has no agent or parent agent.");
+  return id2;
+}
 async function enqueueConversationMessage(input, signal, request = apiRequest) {
   const body3 = {
     agent_id: input.agentId,
@@ -241543,14 +241414,14 @@ function assistantText(messages) {
   return text2.trim() ? text2 : null;
 }
 function noReplyMessage(receipt) {
-  return `Remote task finished. Its reply was not collected. Read the conversation with: letta messages list --agent ${receipt.agent_id} --conversation ${receipt.conversation_id}. Do not launch the task again to retrieve its result.`;
+  return `Remote task finished. Its reply was not collected. Read the conversation with: letta messages list --agent ${getEnqueueAgentId(receipt)} --conversation ${receipt.conversation_id}. Do not launch the task again to retrieve its result.`;
 }
 async function waitForAcceptedSuperRun(receipt, signal, deps) {
   const pollMs = deps.pollMs ?? 1000;
   const sleep11 = deps.sleep ?? ((ms, waitSignal) => delay3(ms, undefined, { signal: waitSignal }));
   while (true) {
     signal.throwIfAborted();
-    const exact = await retryRead(() => deps.exact(receipt.agent_id, receipt.super_run_id, AbortSignal.any([signal, AbortSignal.timeout(30000)])), signal, sleep11, `Cloud status read for accepted Super Run ${receipt.super_run_id} failed`);
+    const exact = await retryRead(() => deps.exact(getEnqueueAgentId(receipt), receipt.super_run_id, AbortSignal.any([signal, AbortSignal.timeout(30000)])), signal, sleep11, `Cloud status read for accepted Super Run ${receipt.super_run_id} failed`);
     if (exact.id !== receipt.super_run_id) {
       throw new RemoteExecutionFailed(`Exact Super Run read returned ${exact.id} for ${receipt.super_run_id}.`);
     }
@@ -241588,6 +241459,7 @@ async function waitForAcceptedSuperRun(receipt, signal, deps) {
 var RemoteExecutionFailed;
 var init_headless_super_run_wait = __esm(() => {
   init_letta_client();
+  init_conversation_enqueue();
   init_request();
   RemoteExecutionFailed = class RemoteExecutionFailed extends Error {
   };
@@ -241632,10 +241504,10 @@ function trackChildSend(input) {
   const subagentId = generateSubagentId();
   registerSubagent(subagentId, child.type, child.name, undefined, true, false, parentScope, input.prompt, false);
   updateSubagent(subagentId, {
-    agentId: receipt.agent_id,
+    agentId: receipt.agent_id ?? undefined,
     conversationId: receipt.conversation_id,
     superRunId: receipt.super_run_id,
-    agentURL: buildAgentReference(receipt.agent_id, {
+    agentURL: buildAgentReference(getEnqueueAgentId(receipt), {
       conversationId: receipt.conversation_id
     })
   });
@@ -242398,7 +242270,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.17"
+        version: "0.34.18"
       },
       capabilities: null
     });
@@ -246327,8 +246199,11 @@ async function createListenerClient(connectionId, scope) {
   });
 }
 async function cancelListenerInput(params) {
+  const agentId = params.scope.agent_id ?? params.parentAgentId;
+  if (!agentId)
+    throw new Error("Listener cancellation requires an agent or parent agent.");
   const removed = await (params.dequeue ?? dequeueConversationMessage)({
-    agentId: params.scope.agent_id,
+    agentId,
     conversationId: params.scope.conversation_id,
     clientMessageId: params.clientMessageId,
     actingUserId: params.scope.acting_user_id
@@ -246352,7 +246227,7 @@ async function cancelListenerInput(params) {
 }
 async function cancelAcceptedListenerInput(receipt) {
   const removed = await dequeueConversationMessage({
-    agentId: receipt.agent_id,
+    agentId: getEnqueueAgentId(receipt),
     conversationId: receipt.conversation_id,
     clientMessageId: receipt.client_message_id,
     actingUserId: receipt.acting_user_id
@@ -246376,6 +246251,7 @@ async function cancelAcceptedListenerInput(receipt) {
     return await cancelListenerInput({
       client,
       scope,
+      parentAgentId: receipt.parent_agent_id,
       clientMessageId: receipt.client_message_id,
       dequeue: async () => removed,
       readState: () => ({ loop, cancelled: false })
@@ -246386,6 +246262,9 @@ async function cancelAcceptedListenerInput(receipt) {
   }
 }
 async function launchListenerConversation(params, deps = {}) {
+  const agentId = params.scope.agent_id ?? params.parentAgentId;
+  if (!agentId)
+    throw new Error("Listener delivery requires an agent or parent agent.");
   const client = deps.client ?? await createListenerClient(params.connectionId, params.scope);
   const clientMessageId = params.clientMessageId ?? randomUUID37();
   const runIds = new Set;
@@ -246472,7 +246351,7 @@ async function launchListenerConversation(params, deps = {}) {
     if (interrupted)
       throw new Error("Launch cancelled before input was sent");
     const accepted = await (deps.enqueue ?? enqueueConversationMessage)({
-      agentId: params.scope.agent_id,
+      agentId,
       conversationId: params.scope.conversation_id,
       clientMessageId,
       content: params.content,
@@ -246482,7 +246361,12 @@ async function launchListenerConversation(params, deps = {}) {
     if (params.noWait)
       return {
         status: "queued",
-        receipt: { ...accepted, connection_id: params.connectionId }
+        receipt: {
+          ...accepted,
+          connection_id: params.connectionId,
+          agent_id: params.scope.agent_id,
+          ...params.scope.agent_id === null ? { parent_agent_id: agentId } : {}
+        }
       };
     while (true) {
       if (disconnected)
@@ -246496,6 +246380,7 @@ async function launchListenerConversation(params, deps = {}) {
         if (await cancelListenerInput({
           client,
           scope: params.scope,
+          parentAgentId: params.parentAgentId,
           clientMessageId,
           dequeue: deps.dequeue,
           readState: () => ({ loop, cancelled })
@@ -246615,7 +246500,7 @@ function handleToolReturnEvent(event, state2) {
   }
 }
 function isEnqueueReceipt(event) {
-  return event.status === "queued" && typeof event.agent_id === "string" && typeof event.conversation_id === "string" && typeof event.client_message_id === "string" && typeof event.super_run_id === "string" && typeof event.workflow_id === "string" && (event.acting_user_id === undefined || event.acting_user_id === null || typeof event.acting_user_id === "string");
+  return event.status === "queued" && (typeof event.agent_id === "string" || event.agent_id === null && typeof event.parent_agent_id === "string") && (event.parent_agent_id === undefined || typeof event.parent_agent_id === "string") && typeof event.conversation_id === "string" && typeof event.client_message_id === "string" && typeof event.super_run_id === "string" && typeof event.workflow_id === "string" && (event.acting_user_id === undefined || event.acting_user_id === null || typeof event.acting_user_id === "string");
 }
 function getResultEnvelopeError(event) {
   return event.error || event.result || "Unknown error";
@@ -246626,6 +246511,7 @@ function handleResultEvent(event, state2, subagentId) {
       state2.enqueueReceipt = {
         status: "queued",
         agent_id: event.agent_id,
+        ...event.parent_agent_id ? { parent_agent_id: event.parent_agent_id } : {},
         conversation_id: event.conversation_id,
         client_message_id: event.client_message_id,
         super_run_id: event.super_run_id,
@@ -246757,9 +246643,9 @@ var init_subagent_stream = __esm(() => {
 async function collectRemoteTurnResult(receipt, state2, subagentId, signal = new AbortController().signal) {
   const startedAt = Date.now();
   updateSubagent(subagentId, {
-    agentId: receipt.agent_id,
+    agentId: receipt.agent_id ?? undefined,
     conversationId: receipt.conversation_id,
-    agentURL: buildAgentReference(receipt.agent_id, {
+    agentURL: buildAgentReference(getEnqueueAgentId(receipt), {
       conversationId: receipt.conversation_id
     })
   });
@@ -246779,7 +246665,7 @@ async function collectRemoteTurnResult(receipt, state2, subagentId, signal = new
       }
     });
     return {
-      agentId: receipt.agent_id,
+      agentId: receipt.agent_id ?? "",
       conversationId: receipt.conversation_id,
       report: reply.text,
       success: true,
@@ -246792,7 +246678,7 @@ async function collectRemoteTurnResult(receipt, state2, subagentId, signal = new
       detail = cancelled ? INTERRUPTED_BY_USER : `${INTERRUPTED_BY_USER} (could not confirm cancellation of remote Super Run ${receipt.super_run_id})`;
     }
     return {
-      agentId: receipt.agent_id,
+      agentId: receipt.agent_id ?? "",
       conversationId: receipt.conversation_id,
       report: "",
       success: false,
@@ -248730,12 +248616,13 @@ async function launchRemoteExternalCodingAgent(params, deps) {
             durationMs: final.duration_ms || Date.now() - startedAt
           };
         } catch (error5) {
+          const remoteWorkerStopped = signal?.reason === REMOTE_EXTERNAL_WORKER_STOPPED;
           return {
             agentId: parentScope.agentId,
             model,
             report: "",
             success: false,
-            error: error5 instanceof RemoteWorkerLostError && !signal?.aborted ? `The ${type3} worker on ${computer} is no longer listed: it may have finished while this session was disconnected (results are kept for 30 minutes), or the listener restarted. Check ${computer} or launch it again if the work is still needed.` : `${signal?.aborted ? "Stopped following this subagent" : errorMessage3(error5)}. The ${type3} worker may still be running on ${computer}.`,
+            error: error5 instanceof RemoteWorkerLostError && !signal?.aborted ? `The ${type3} worker on ${computer} is no longer listed: it may have finished while this session was disconnected (results are kept for 30 minutes), or the listener restarted. Check ${computer} or launch it again if the work is still needed.` : remoteWorkerStopped ? `Stopped the ${type3} worker on ${computer}.` : `${signal?.aborted ? "Stopped following this subagent" : errorMessage3(error5)}. The ${type3} worker may still be running on ${computer}.`,
             durationMs: Date.now() - startedAt
           };
         } finally {
@@ -248880,7 +248767,7 @@ async function sendRemoteExternalCodingAgentMessage(params, deps = {}) {
     outputFile: tracked.outputFile
   };
 }
-var DISPLAY_NAMES, RemoteWorkerLostError;
+var REMOTE_EXTERNAL_WORKER_STOPPED, DISPLAY_NAMES, RemoteWorkerLostError;
 var init_remote_external_coding_agent = __esm(() => {
   init_subagent_state();
   init_app_server_client();
@@ -248890,6 +248777,7 @@ var init_remote_external_coding_agent = __esm(() => {
   init_headless_environment_response();
   init_headless_listener_launch();
   init_external_coding_agent();
+  REMOTE_EXTERNAL_WORKER_STOPPED = Symbol("remote external worker stopped");
   DISPLAY_NAMES = {
     "claude-code": "Claude Code",
     codex: "Codex",
@@ -250479,6 +250367,7 @@ async function task_stop(args, deps = {}) {
       const child = getSubagents().find((agent) => agent.id === task2.subagentId);
       const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
       let remote;
+      let remoteExternalStopped = false;
       if (external3?.computer) {
         try {
           if (!task2.runtimeScope)
@@ -250495,6 +250384,7 @@ async function task_stop(args, deps = {}) {
             killed: result3.stopped,
             output: result3.stopped ? "Stopped the remote external subagent" : "The remote external subagent was not running"
           };
+          remoteExternalStopped = result3.stopped;
         } catch (error5) {
           remote = {
             killed: false,
@@ -250506,7 +250396,7 @@ async function task_stop(args, deps = {}) {
       }
       if (remote && !remote.killed)
         return remote;
-      task2.abortController.abort();
+      task2.abortController.abort(remoteExternalStopped ? REMOTE_EXTERNAL_WORKER_STOPPED : undefined);
       task2.error = "Aborted by user";
       await task2.completion;
       task2.status = "failed";
@@ -251874,6 +251764,36 @@ var init_sdk_loader = __esm(() => {
   SDK_PACKAGE = ["@letta-ai", "letta-agent-sdk"].join("/");
 });
 
+// src/agent/preloaded-skills.ts
+import { readFile as readFile18 } from "node:fs/promises";
+async function loadPreloadedSkills(ids, options = {}) {
+  if (ids.length === 0)
+    return "";
+  const { skillPathById } = await buildClientSkillsPayload({
+    ...options,
+    skillSources: options.skillSources?.length === 0 ? ["bundled"] : options.skillSources
+  });
+  const contents = [];
+  for (const id2 of ids) {
+    const path31 = skillPathById[id2];
+    if (!path31)
+      continue;
+    try {
+      contents.push(`<${id2}>
+${await readFile18(path31, "utf-8")}
+</${id2}>`);
+    } catch {}
+  }
+  return contents.length ? `<loaded_skills>
+${contents.join(`
+
+`)}
+</loaded_skills>` : "";
+}
+var init_preloaded_skills = __esm(() => {
+  init_client_skills();
+});
+
 // src/tools/workflow/sdk-spawner.ts
 async function latestWorkerRun(conversationId) {
   const backend3 = getBackend();
@@ -252115,6 +252035,19 @@ function createSdkSpawner(client, config2) {
         error: `Unknown model "${options.model}". Run \`letta model list\` for valid handles.`
       };
     }
+    const loadedSkills = options.skills?.length ? await loadPreloadedSkills(options.skills, {
+      agentId: config2.parentAgentId,
+      ...config2.cwd ? { workingDirectory: config2.cwd } : {}
+    }) : "";
+    const missingSkills = (options.skills ?? []).filter((id2) => !loadedSkills.includes(`<${id2}>
+`));
+    if (missingSkills.length) {
+      return {
+        value: null,
+        failed: true,
+        error: `Unknown skill(s): ${missingSkills.join(", ")}.`
+      };
+    }
     if (signal.aborted) {
       return {
         value: null,
@@ -252133,7 +252066,9 @@ function createSdkSpawner(client, config2) {
     let query3;
     try {
       query3 = client.query({
-        prompt,
+        prompt: loadedSkills ? `${loadedSkills}
+
+${prompt}` : prompt,
         options: {
           ...buildQueryOptions(options, model, config2, request2.callIndex),
           ...resumeId ? { conversationId: resumeId } : {}
@@ -252259,6 +252194,7 @@ function createSdkSpawner(client, config2) {
 }
 var DEFAULT_SUBAGENT_TIMEOUT_MS, DEFAULT_MAX_SUBAGENT_TOOL_CALLS = 1000, MAX_IDENTICAL_TOOL_CALLS = 3, SUBAGENT_PREAMBLE = `You are a subagent inside a deterministic workflow. You are not talking to a human: your final output is consumed by a script. Return raw data with no preamble, no markdown framing, and no questions.`, JSON_PREAMBLE = `Your final message must be a single JSON value and nothing else: no prose, no markdown code fence.`;
 var init_sdk_spawner = __esm(async () => {
+  init_preloaded_skills();
   init_backend2();
   init_tool_registry();
   init_tool_name_mapping();
@@ -252399,6 +252335,14 @@ function jsonSafe(value) {
     return String(value);
   }
 }
+function formatFailureResult(error5, agentsDone, journalPath) {
+  const lines = [`Workflow failed: ${error5 ?? "unknown error"}`];
+  if (agentsDone > 0) {
+    lines.push(`${agentsDone} agent call${agentsDone === 1 ? "" : "s"} completed before the failure. Their full results are saved in ${journalPath} (one line per completed call; the return value is outcome.value).`);
+  }
+  return lines.join(`
+`);
+}
 function formatCompletionResult(run, executionDir) {
   const payload = JSON.stringify({
     result: jsonSafe(run.result),
@@ -252590,7 +252534,7 @@ async function workflow(args) {
       processState.status = outcome.run ? "completed" : "failed";
       processState.exitCode = outcome.run ? 0 : 1;
     }
-    const result3 = outcome.run ? formatCompletionResult(outcome.run, executionDir) : `Workflow failed: ${outcome.error ?? "unknown error"}`;
+    const result3 = outcome.run ? formatCompletionResult(outcome.run, executionDir) : formatFailureResult(outcome.error, getWorkflowExecution(taskId)?.agentsDone ?? 0, journalPath);
     appendToOutputFile(outputFile, outcome.run ? `
 [result]
 ${result3}
@@ -261164,7 +261108,7 @@ var init_environments4 = __esm(() => {
 });
 
 // src/cli/subcommands/feedback.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 import { parseArgs as parseArgs8 } from "node:util";
 function printUsage6(stdout = console.log) {
   stdout(`
@@ -261214,7 +261158,7 @@ async function runFeedbackSubcommand(argv, deps = {}) {
   let rawMessage = typeof inlineMessage === "string" ? inlineMessage : "";
   if (typeof messageFile === "string") {
     try {
-      rawMessage = await (deps.readMessageFile ?? ((path32) => readFile18(path32, "utf8")))(messageFile);
+      rawMessage = await (deps.readMessageFile ?? ((path32) => readFile19(path32, "utf8")))(messageFile);
     } catch {
       stderr(`Could not read feedback file: ${messageFile}`);
       return 1;
@@ -263427,7 +263371,7 @@ var init_listen_log = __esm(() => {
 
 // src/utils/machine-metadata.ts
 import { execFile as execFile19 } from "node:child_process";
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 import { cpus, totalmem } from "node:os";
 function getMachineMetadata() {
   machineMetadata ??= collectMachineMetadata().catch(() => ({
@@ -263442,7 +263386,7 @@ function localSources() {
     architecture: process.arch,
     cpu: cpus()[0]?.model,
     memoryBytes: Math.min(totalmem(), limit4 || Number.POSITIVE_INFINITY),
-    read: (path32, signal) => readFile19(path32, { encoding: "utf8", signal }),
+    read: (path32, signal) => readFile20(path32, { encoding: "utf8", signal }),
     run: (command, args, signal) => new Promise((resolve39, reject2) => {
       execFile19(command, args, {
         encoding: "utf8",
@@ -264021,7 +263965,7 @@ var init_auth3 = __esm(() => {
 
 // src/websocket/listener/manual-instance-lock.ts
 import { createHash as createHash14, randomUUID as randomUUID47 } from "node:crypto";
-import { link as link4, mkdir as mkdir13, readFile as readFile20, rm as rm11, unlink as unlink3, writeFile as writeFile15 } from "node:fs/promises";
+import { link as link4, mkdir as mkdir13, readFile as readFile21, rm as rm11, unlink as unlink3, writeFile as writeFile15 } from "node:fs/promises";
 import { homedir as homedir38 } from "node:os";
 import path32 from "node:path";
 function hasErrorCode3(error5, code2) {
@@ -264108,7 +264052,7 @@ async function recoverDeadOwner(lockPath, staleContents, recoveryOwnerContents,
       }
       let claimContents;
       try {
-        claimContents = await readFile20(claimPath, "utf-8");
+        claimContents = await readFile21(claimPath, "utf-8");
       } catch (error5) {
         if (hasErrorCode3(error5, "ENOENT")) {
           continue;
@@ -264128,7 +264072,7 @@ async function recoverDeadOwner(lockPath, staleContents, recoveryOwnerContents,
     }
     let currentContents;
     try {
-      currentContents = await readFile20(lockPath, "utf-8");
+      currentContents = await readFile21(lockPath, "utf-8");
     } catch (error5) {
       return hasErrorCode3(error5, "ENOENT");
     }
@@ -264178,7 +264122,7 @@ async function acquireManualListenerLock(scope, overrides = {}) {
             return;
           let currentContents;
           try {
-            currentContents = await readFile20(lockPath, "utf-8");
+            currentContents = await readFile21(lockPath, "utf-8");
           } catch (error5) {
             if (hasErrorCode3(error5, "ENOENT")) {
               released = true;
@@ -264198,7 +264142,7 @@ async function acquireManualListenerLock(scope, overrides = {}) {
     }
     let incumbentContents;
     try {
-      incumbentContents = await readFile20(lockPath, "utf-8");
+      incumbentContents = await readFile21(lockPath, "utf-8");
     } catch (error5) {
       if (hasErrorCode3(error5, "ENOENT")) {
         continue;
@@ -266750,7 +266694,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
           ensureLocalMemfsCheckout: ensureLocalMemfsCheckout2,
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
-        const { readFile: readFile21 } = await import("node:fs/promises");
+        const { readFile: readFile22 } = await import("node:fs/promises");
         const { existsSync: existsSync52 } = await import("node:fs");
         const { isAbsolute: isAbsolute25, join: join77, normalize: normalize4, relative: relative8, sep: sep8 } = await import("node:path");
         if (isAbsolute25(parsed.path) || parsed.path.length === 0) {
@@ -266776,7 +266720,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
             return;
           }
         }
-        const buffer = await readFile21(absolutePath);
+        const buffer = await readFile22(absolutePath);
         const content = encoding === "base64" ? buffer.toString("base64") : buffer.toString("utf-8");
         const pathspec = rel.split(sep8).join("/");
         safeSocketSend(socket, {
@@ -276035,7 +275979,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile21,
+          readFile: readFile22,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -276228,7 +276172,7 @@ ${lanes.join(`
         function fsWatchWorker(fileOrDirectory, recursive, callback) {
           return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
         }
-        function readFile21(fileName, _encoding) {
+        function readFile22(fileName, _encoding) {
           let buffer;
           try {
             buffer = _fs.readFileSync(fileName);
@@ -307175,7 +307119,7 @@ ${lanes.join(`
       const possibleOption = getSpellingSuggestion(unknownOption, diagnostics2.optionDeclarations, getOptionName);
       return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics2.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics2.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
     }
-    function parseCommandLineWorker(diagnostics2, commandLine, readFile21) {
+    function parseCommandLineWorker(diagnostics2, commandLine, readFile22) {
       const options = {};
       let watchOptions;
       const fileNames = [];
@@ -307213,7 +307157,7 @@ ${lanes.join(`
         }
       }
       function parseResponseFile(fileName) {
-        const text3 = tryReadFile(fileName, readFile21 || ((fileName2) => sys.readFile(fileName2)));
+        const text3 = tryReadFile(fileName, readFile22 || ((fileName2) => sys.readFile(fileName2)));
         if (!isString7(text3)) {
           errors6.push(text3);
           return;
@@ -307316,8 +307260,8 @@ ${lanes.join(`
       unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
       optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
     };
-    function parseCommandLine2(commandLine, readFile21) {
-      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile21);
+    function parseCommandLine2(commandLine, readFile22) {
+      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile22);
     }
     function getOptionFromName(optionName, allowShort) {
       return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -307385,8 +307329,8 @@ ${lanes.join(`
       result3.originalFileName = result3.fileName;
       return parseJsonSourceFileConfigFileContent(result3, host, getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd2), optionsToExtend, getNormalizedAbsolutePath(configFileName, cwd2), undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend);
     }
-    function readConfigFile(fileName, readFile21) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile21);
+    function readConfigFile(fileName, readFile22) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile22);
       return isString7(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
     function parseConfigFileTextToJson(fileName, jsonText) {
@@ -307396,14 +307340,14 @@ ${lanes.join(`
         error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
       };
     }
-    function readJsonConfigFile(fileName, readFile21) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile21);
+    function readJsonConfigFile(fileName, readFile22) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile22);
       return isString7(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
     }
-    function tryReadFile(fileName, readFile21) {
+    function tryReadFile(fileName, readFile22) {
       let text3;
       try {
-        text3 = readFile21(fileName);
+        text3 = readFile22(fileName);
       } catch (e2) {
         return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e2.message);
       }
@@ -374833,12 +374777,12 @@ ${lanes.join(`
     function createCompilerHost(options, setParentNodes) {
       return createCompilerHostWorker(options, setParentNodes);
     }
-    function createGetSourceFile(readFile21, setParentNodes) {
+    function createGetSourceFile(readFile22, setParentNodes) {
       return (fileName, languageVersionOrOptions, onError) => {
         let text3;
         try {
           mark2("beforeIORead");
-          text3 = readFile21(fileName);
+          text3 = readFile22(fileName);
           mark2("afterIORead");
           measure("I/O Read", "beforeIORead", "afterIORead");
         } catch (e2) {
@@ -375629,7 +375573,7 @@ ${lanes.join(`
         getRedirectFromOutput,
         forEachResolvedProjectReference: forEachResolvedProjectReference2
       });
-      const readFile21 = host.readFile.bind(host);
+      const readFile22 = host.readFile.bind(host);
       (_e = tracing) == null || _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
       const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
       (_f = tracing) == null || _f.pop();
@@ -375805,7 +375749,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile21,
+        readFile: readFile22,
         directoryExists: directoryExists2,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -443139,6 +443083,94 @@ var init_chatgpt_plan_rotation = __esm(() => {
   init_backend2();
 });
 
+// src/agent/ephemeral-conversation.ts
+async function buildEphemeralConversationCreateBody(options) {
+  const system2 = options.systemPromptCustom ? options.systemPromptCustom : await resolveAndBuildSystemPrompt(options.systemPromptPreset, options.memoryPromptMode ?? "standard");
+  const request2 = await buildCreateAgentRequest({
+    model: options.model,
+    system: system2,
+    memoryPromptMode: "standard",
+    enableMemfs: false,
+    isSubagent: true,
+    baseTools: []
+  });
+  const modelSettings = options.model ? getModelUpdateArgs(options.model) : undefined;
+  const contextWindow = modelSettings?.context_window ?? await getModelContextWindow(request2.model);
+  return {
+    model: request2.model,
+    system: request2.system ?? system2,
+    ...modelSettings ? { model_settings: modelSettings } : {},
+    ...contextWindow ? { context_window_limit: contextWindow } : {}
+  };
+}
+function projectConversationState(conversation) {
+  if (!conversation.model) {
+    throw new Error("Cannot resume a conversation without a persisted model.");
+  }
+  return {
+    id: conversation.id,
+    name: "Ephemeral conversation",
+    system: conversation.system ?? "",
+    tools: [],
+    memory: { blocks: [] },
+    llm_config: {
+      handle: conversation.model,
+      model: conversation.model,
+      context_window: conversation.context_window_limit ?? undefined,
+      model_settings: conversation.model_settings ?? {}
+    },
+    model_settings: conversation.model_settings ?? {},
+    message_buffer_autoclear: false
+  };
+}
+async function createEphemeralConversation2(options) {
+  const body3 = await buildEphemeralConversationCreateBody(options);
+  const conversation = await createEphemeralConversation(body3);
+  return {
+    agent: projectConversationState({ ...body3, id: conversation.id }),
+    conversationId: conversation.id
+  };
+}
+async function retrieveResumeState(agentId, conversationId, backend3 = getBackend()) {
+  return agentId ? backend3.retrieveAgent(agentId) : projectConversationState(await backend3.retrieveConversation(conversationId));
+}
+async function createLocalEphemeralConversation(options) {
+  const body3 = await buildEphemeralConversationCreateBody(options);
+  const backend3 = getBackend();
+  const internalAgent = await backend3.createAgent({
+    agent_type: "letta_v1_agent",
+    name: "Ephemeral conversation",
+    model: body3.model,
+    system: body3.system,
+    memory_blocks: [],
+    tags: [],
+    tools: [],
+    include_base_tools: false,
+    include_base_tool_rules: false,
+    initial_message_sequence: [],
+    parallel_tool_calls: true,
+    hidden: true
+  });
+  const conversation = await backend3.createConversation({
+    agent_id: internalAgent.id,
+    model: body3.model,
+    ...body3.model_settings ? { model_settings: body3.model_settings } : {},
+    ...body3.context_window_limit ? { context_window_limit: body3.context_window_limit } : {}
+  });
+  return {
+    agent: internalAgent,
+    conversationId: conversation.id
+  };
+}
+var init_ephemeral_conversation = __esm(() => {
+  init_available_models();
+  init_create_agent_request();
+  init_model();
+  init_system_prompt_resolution();
+  init_backend2();
+  init_ephemeral_conversations();
+});
+
 // src/cli/helpers/compaction-utils.ts
 function extractCompactionSummary(text3) {
   try {
@@ -447193,7 +447225,7 @@ async function tryResumeBusyConversationStream(params) {
   }
 }
 async function resolveStaleApprovals(runtime, socket, turnLease, deps = {}) {
-  if (!runtime.agentId)
+  if (!runtime.agentId && runtime.conversationId === "default")
     return null;
   const getResumeDataImpl = deps.getResumeData ?? getResumeDataFromBackend;
   const prepareToolExecutionContext = deps.prepareToolExecutionContext ?? prepareToolExecutionContextForScope;
@@ -447208,7 +447240,10 @@ async function resolveStaleApprovals(runtime, socket, turnLease, deps = {}) {
   const backend3 = getBackend();
   let agent;
   try {
-    agent = await (deps.retrieveAgent ? deps.retrieveAgent(runtime.agentId) : backend3.retrieveAgent(runtime.agentId));
+    agent = await retrieveResumeState(runtime.agentId, runtime.conversationId, {
+      retrieveAgent: deps.retrieveAgent ?? backend3.retrieveAgent.bind(backend3),
+      retrieveConversation: deps.retrieveConversation ?? backend3.retrieveConversation.bind(backend3)
+    });
   } catch (err) {
     assertCurrentTurnLease();
     if (isBackendNotFoundError(err)) {
@@ -447241,14 +447276,14 @@ async function resolveStaleApprovals(runtime, socket, turnLease, deps = {}) {
     agent_id: runtime.agentId,
     conversation_id: recoveryConversationId
   };
-  const modAdapters = await ensureListenerModAdaptersForAgent(runtime.listener, runtime.agentId);
+  const modAdapters = runtime.agentId ? await ensureListenerModAdaptersForAgent(runtime.listener, runtime.agentId) : [];
   const preparedToolContext = await prepareToolExecutionContext({
     connectionId: resolveTurnExecutionConnectionId(runtime.listener, scope, runtime.activeConnectionId ?? undefined),
     agentId: runtime.agentId,
     conversationId: recoveryConversationId,
     workingDirectory: recoveryWorkingDirectory,
     permissionModeState: getOrCreateConversationPermissionModeStateRef(runtime.listener, runtime.agentId, runtime.conversationId),
-    modContext: createListenerAgentModContext(runtime.agentId),
+    ...runtime.agentId ? { modContext: createListenerAgentModContext(runtime.agentId) } : {},
     modAdapters,
     modEvents: createListenerModEvents(modAdapters)
   });
@@ -447641,6 +447676,7 @@ var init_send = __esm(async () => {
   init_error();
   init_approval_recovery();
   init_check_approval();
+  init_ephemeral_conversation();
   init_turn_recovery_policy();
   init_backend2();
   init_error_formatter();
@@ -451706,12 +451742,12 @@ function rowToolCalls(row, index, diagnostics2) {
   }
   return calls;
 }
-function contentText3(content) {
+function contentText2(content) {
   if (typeof content === "string") {
     if (content.startsWith(CONTENT_JSON_PREFIX)) {
       const encoded = content.slice(CONTENT_JSON_PREFIX.length);
       try {
-        return contentText3(JSON.parse(encoded));
+        return contentText2(JSON.parse(encoded));
       } catch {
         return encoded;
       }
@@ -451797,7 +451833,7 @@ var init_hermes = __esm(() => {
           });
         };
         if (row.role === "user") {
-          const content = contentText3(row.content);
+          const content = contentText2(row.content);
           if (content) {
             emit({
               type: "message",
@@ -451817,7 +451853,7 @@ var init_hermes = __esm(() => {
               ...timestamp ? { timestamp } : {}
             });
           }
-          const content = contentText3(row.content);
+          const content = contentText2(row.content);
           if (content) {
             emit({
               type: "message",
@@ -451840,7 +451876,7 @@ var init_hermes = __esm(() => {
         if (row.role === "tool") {
           emit({
             type: "tool_result",
-            content: contentText3(row.content),
+            content: contentText2(row.content),
             ...typeof row.tool_call_id === "string" && row.tool_call_id ? { callId: row.tool_call_id } : {},
             ...timestamp ? { timestamp } : {}
           });
@@ -453832,7 +453868,7 @@ var exports_reflection_memory_v2 = {};
 __export(exports_reflection_memory_v2, {
   buildMemfsV2ParentMemorySnapshot: () => buildMemfsV2ParentMemorySnapshot
 });
-import { readFile as readFile21 } from "node:fs/promises";
+import { readFile as readFile22 } from "node:fs/promises";
 function renderProjectedTree(files) {
   const root2 = { directories: new Map, files: [] };
   for (const file of files) {
@@ -453885,7 +453921,7 @@ async function buildMemfsV2ParentMemorySnapshot(memoryDir, requestedMaxChars) {
 `).length - prefix.length - suffix.length - 20;
     if (remaining <= 0)
       break;
-    const content = (await readFile21(file.fullPath, "utf-8")).slice(0, remaining);
+    const content = (await readFile22(file.fullPath, "utf-8")).slice(0, remaining);
     lines.push(`${prefix}${content}${suffix}`);
   }
   lines.push("</parent_memory>");
@@ -453903,7 +453939,7 @@ import {
   appendFile,
   mkdir as mkdir14,
   readdir as readdir9,
-  readFile as readFile22,
+  readFile as readFile23,
   stat as stat13,
   writeFile as writeFile16
 } from "node:fs/promises";
@@ -453951,7 +453987,7 @@ async function collectParentMemoryFiles(memoryDir) {
         continue;
       }
       try {
-        const content = await readFile22(entryPath, "utf-8");
+        const content = await readFile23(entryPath, "utf-8");
         const { frontmatter } = parseFrontmatter(content);
         const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
         files.push({
@@ -454254,7 +454290,7 @@ async function ensurePaths(paths) {
 }
 async function readTranscriptLines(paths) {
   try {
-    const raw2 = await readFile22(paths.transcriptPath, "utf-8");
+    const raw2 = await readFile23(paths.transcriptPath, "utf-8");
     return raw2.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
   } catch {
@@ -454327,7 +454363,7 @@ function buildUnreflectedStateFromTranscript(lines) {
 async function readState(paths) {
   let raw2 = null;
   try {
-    raw2 = await readFile22(paths.statePath, "utf-8");
+    raw2 = await readFile23(paths.statePath, "utf-8");
   } catch {
     raw2 = null;
   }
@@ -454659,7 +454695,7 @@ function isReflectionAutoPriority(value) {
   return value === "high" || value === "medium" || value === "low";
 }
 async function readReflectionAutoSelection(options) {
-  const raw2 = options.selectionReport ?? (options.selectionOutputPath ? await readFile22(options.selectionOutputPath, "utf-8") : "");
+  const raw2 = options.selectionReport ?? (options.selectionOutputPath ? await readFile23(options.selectionOutputPath, "utf-8") : "");
   const parsed = parseReflectionAutoSelectionJson(raw2);
   if (!parsed || typeof parsed !== "object") {
     throw new Error("Reflection selector did not return valid JSON.");
@@ -456368,36 +456404,6 @@ var init_turn_send = __esm(async () => {
   ]);
 });
 
-// src/agent/preloaded-skills.ts
-import { readFile as readFile23 } from "node:fs/promises";
-async function loadPreloadedSkills(ids, options = {}) {
-  if (ids.length === 0)
-    return "";
-  const { skillPathById } = await buildClientSkillsPayload({
-    ...options,
-    skillSources: options.skillSources?.length === 0 ? ["bundled"] : options.skillSources
-  });
-  const contents = [];
-  for (const id2 of ids) {
-    const path42 = skillPathById[id2];
-    if (!path42)
-      continue;
-    try {
-      contents.push(`<${id2}>
-${await readFile23(path42, "utf-8")}
-</${id2}>`);
-    } catch {}
-  }
-  return contents.length ? `<loaded_skills>
-${contents.join(`
-
-`)}
-</loaded_skills>` : "";
-}
-var init_preloaded_skills = __esm(() => {
-  init_client_skills();
-});
-
 // src/reminders/listen-context.ts
 function buildListenReminderContext(params) {
   return {
@@ -457222,7 +457228,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
             conversationId
           });
           try {
-            const agent = await getBackend().retrieveAgent(agentId || "");
+            const agent = await retrieveResumeState(agentId, conversationId);
             const { pendingApprovals: existingApprovals } = await getResumeDataFromBackend(agent, requestedConversationId);
             turnInput = rebuildTurnInputWithFreshDenials(turnInput, existingApprovals ?? [], STALE_APPROVAL_RECOVERY_DENIAL_REASON, isApprovalPendingError(errorDetail3));
           } catch {
@@ -457635,8 +457641,8 @@ var init_turn = __esm(async () => {
   init_approval_recovery();
   init_chatgpt_plan_rotation();
   init_check_approval();
+  init_ephemeral_conversation();
   init_turn_recovery_policy();
-  init_backend2();
   init_accumulator();
   init_telemetry();
   init_error_reporting();
@@ -482031,88 +482037,6 @@ var init_headless_cloud_send = __esm(() => {
   init_headless_environment_response();
 });
 
-// src/agent/ephemeral-conversation.ts
-async function buildEphemeralConversationCreateBody(options) {
-  const system2 = options.systemPromptCustom ? options.systemPromptCustom : await resolveAndBuildSystemPrompt(options.systemPromptPreset, options.memoryPromptMode ?? "standard");
-  const request3 = await buildCreateAgentRequest({
-    model: options.model,
-    system: system2,
-    memoryPromptMode: "standard",
-    enableMemfs: false,
-    isSubagent: true,
-    baseTools: []
-  });
-  const modelSettings = options.model ? getModelUpdateArgs(options.model) : undefined;
-  const contextWindow = modelSettings?.context_window ?? await getModelContextWindow(request3.model);
-  return {
-    model: request3.model,
-    system: request3.system ?? system2,
-    ...modelSettings ? { model_settings: modelSettings } : {},
-    ...contextWindow ? { context_window_limit: contextWindow } : {}
-  };
-}
-function projectEphemeralAgent(conversationId, body3) {
-  return {
-    id: conversationId,
-    name: "Ephemeral conversation",
-    system: body3.system,
-    tools: [],
-    memory: { blocks: [] },
-    llm_config: {
-      handle: body3.model,
-      model: body3.model,
-      context_window: body3.context_window_limit ?? undefined,
-      model_settings: body3.model_settings ?? {}
-    },
-    model_settings: body3.model_settings ?? {},
-    message_buffer_autoclear: false
-  };
-}
-async function createEphemeralConversation2(options) {
-  const body3 = await buildEphemeralConversationCreateBody(options);
-  const conversation = await createEphemeralConversation(body3);
-  return {
-    agent: projectEphemeralAgent(conversation.id, body3),
-    conversationId: conversation.id
-  };
-}
-async function createLocalEphemeralConversation(options) {
-  const body3 = await buildEphemeralConversationCreateBody(options);
-  const backend3 = getBackend();
-  const internalAgent = await backend3.createAgent({
-    agent_type: "letta_v1_agent",
-    name: "Ephemeral conversation",
-    model: body3.model,
-    system: body3.system,
-    memory_blocks: [],
-    tags: [],
-    tools: [],
-    include_base_tools: false,
-    include_base_tool_rules: false,
-    initial_message_sequence: [],
-    parallel_tool_calls: true,
-    hidden: true
-  });
-  const conversation = await backend3.createConversation({
-    agent_id: internalAgent.id,
-    model: body3.model,
-    ...body3.model_settings ? { model_settings: body3.model_settings } : {},
-    ...body3.context_window_limit ? { context_window_limit: body3.context_window_limit } : {}
-  });
-  return {
-    agent: internalAgent,
-    conversationId: conversation.id
-  };
-}
-var init_ephemeral_conversation = __esm(() => {
-  init_available_models();
-  init_create_agent_request();
-  init_model();
-  init_system_prompt_resolution();
-  init_backend2();
-  init_ephemeral_conversations();
-});
-
 // src/headless-ephemeral-startup.ts
 function prepareHeadlessEphemeralBackend(enabled) {
   if (enabled && isLocalBackendEnabled()) {
@@ -482144,6 +482068,18 @@ function clearHeadlessClientToolRules(agent) {
     debugWarn("headless startup", `Failed to clear persisted client tool rules for ${agent.id}: ${error5 instanceof Error ? error5.message : String(error5)}`);
   });
 }
+async function retrieveHeadlessConversation(backend3, conversationId) {
+  const conversation = await backend3.retrieveConversation(conversationId);
+  const detached = conversation.agent_id === null;
+  const parentId = Reflect.get(conversation, "parent_agent_id");
+  return {
+    agent: detached ? projectConversationState(conversation) : await backend3.retrieveAgent(conversation.agent_id, {
+      include: ["agent.tools", "agent.tags"]
+    }),
+    detached,
+    parentAgentId: detached && typeof parentId === "string" ? parentId : null
+  };
+}
 var init_headless_ephemeral_startup = __esm(async () => {
   init_ephemeral_conversation();
   init_backend2();
@@ -482929,6 +482865,8 @@ In headless mode, use:
   let specifiedAgentIdFromAmbient = false;
   const forceNew = values4["new-agent"];
   const ephemeralFlag = values4.ephemeral;
+  let isDetached = Boolean(ephemeralFlag);
+  let parentAgentId = null;
   const systemPromptPreset = values4.system;
   const systemCustom = values4["system-custom"];
   const personalityInput = values4.personality;
@@ -483089,10 +483027,11 @@ In headless mode, use:
   if (specifiedConversationId && specifiedConversationId !== "default") {
     try {
       debugLog("conversations", `retrieve(${specifiedConversationId}) [headless conv→agent lookup]`);
-      const conversation = await startupBackend.retrieveConversation(specifiedConversationId);
-      agent = await startupBackend.retrieveAgent(conversation.agent_id, {
-        include: ["agent.tools", "agent.tags"]
-      });
+      ({
+        agent,
+        detached: isDetached,
+        parentAgentId
+      } = await retrieveHeadlessConversation(startupBackend, specifiedConversationId));
     } catch (error5) {
       trackHeadlessBoundaryError("headless_conversation_lookup_failed", error5, "headless_startup_conversation_lookup");
       console.error(`Conversation ${specifiedConversationId} not found`);
@@ -483215,9 +483154,9 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     process.exit(1);
   }
   markMilestone("HEADLESS_AGENT_RESOLVED");
-  const publicAgentId = ephemeralFlag ? null : agent.id;
+  const publicAgentId = isDetached ? null : agent.id;
   telemetry.setCurrentAgent(publicAgentId, agent.tags);
-  const isResumingAgent = !ephemeralFlag && !!(specifiedAgentId || !forceNew);
+  const isResumingAgent = !isDetached && !!(specifiedAgentId || !forceNew);
   let conversationModel;
   if (isResumingAgent) {
     const modelHandle = model ? resolveModel(model) : undefined;
@@ -483240,7 +483179,7 @@ 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 (!isStatelessSession && backend3.capabilities.remoteMemfs && !autoEnableMemfsForFreshAgent) {
+  if (!isStatelessSession && !isDetached && backend3.capabilities.remoteMemfs && !autoEnableMemfsForFreshAgent) {
     const { hydrateMemfsSettingFromAgent: hydrateMemfsSettingFromAgent2, isLettaCloud: isLettaCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
     const memfsEnabled = await hydrateMemfsSettingFromAgent2(agent);
     if (!memfsEnabled && await isLettaCloud2()) {
@@ -483248,9 +483187,9 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
     }
   }
   let memfsBgPromise;
-  const secretsAgentId = ephemeralFlag ? undefined : agent?.id;
+  const secretsAgentId = isDetached ? undefined : agent?.id;
   const secretsInitPromise = secretsAgentId ? Promise.resolve().then(() => (init_secrets_store(), exports_secrets_store)).then(({ initSecretsFromServer: initSecretsFromServer2 }) => initSecretsFromServer2(secretsAgentId)) : Promise.resolve();
-  if (isStatelessSession) {
+  if (isStatelessSession || isDetached) {
     settingsManager.setMemfsEnabled(agent.id, false);
   } else if (!backend3.capabilities.remoteMemfs) {
     if (backend3.capabilities.localMemfs) {
@@ -483332,11 +483271,11 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       memoryMode: getMemoryPromptModeForAgent2(taggedAgent.id)
     });
   }
-  if (!ephemeralFlag) {
+  if (!isDetached) {
     clearHeadlessClientToolRules(agent);
   }
   try {
-    if (ephemeralFlag) {
+    if (isDetached) {
       effectiveReflectionSettings = { trigger: "off", stepCount: 0 };
     } else {
       const resolvedReflectionSettings = await applyHeadlessReflectionOverrides(agent.id, reflectionOverrides);
@@ -483388,7 +483327,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   }
   markMilestone("HEADLESS_CONVERSATION_READY");
   setConversationId(conversationId);
-  if (!ephemeralFlag && shouldPersistSessionState()) {
+  if (!isDetached && shouldPersistSessionState()) {
     await settingsManager.loadLocalProjectSettings();
     settingsManager.persistSession(agent.id, conversationId);
   }
@@ -483530,7 +483469,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   const resolveAllPendingApprovals = async (mode = "send_immediately") => {
     const { getResumeDataFromBackend: getResumeDataFromBackend2 } = await Promise.resolve().then(() => (init_check_approval(), exports_check_approval));
     while (true) {
-      const freshAgent = ephemeralFlag ? agent : await backend3.retrieveAgent(agent.id);
+      const freshAgent = isDetached ? agent : await backend3.retrieveAgent(agent.id);
       let resume;
       try {
         resume = await getResumeDataFromBackend2(freshAgent, conversationId);
@@ -483590,7 +483529,7 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       }
     }
   };
-  if (isResumingAgent) {
+  if (isResumingAgent || !usesRemoteEnvironment && isDetached && !ephemeralFlag) {
     try {
       await resolveAllPendingApprovals("queue_for_next_turn");
     } catch (approvalError) {
@@ -483650,9 +483589,12 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
   pushPart(prompt);
   telemetry.trackUserInput(prompt, "user", reportModel ?? "unknown");
   if (usesRemoteEnvironment) {
+    const agentId = publicAgentId ?? parentAgentId;
+    if (!agentId)
+      throw new Error("Listener delivery requires a conversation with an agent or parent agent.");
     const environmentSelector = explicitEnvironmentSelector ?? "";
     const useCloudSandbox = isCloudEnvironmentSelector(environmentSelector);
-    const environmentRouting = environmentSelector ? useCloudSandbox ? await resolveAgentSandboxConnectionId(agent.id, { conversationId }) : await resolveEnvironmentConnectionId(environmentSelector) : null;
+    const environmentRouting = environmentSelector ? useCloudSandbox ? await resolveAgentSandboxConnectionId(agentId, { conversationId }) : await resolveEnvironmentConnectionId(environmentSelector) : null;
     const connectionId = environmentRouting?.connectionId ?? inheritedListenerConnectionId;
     if (!connectionId)
       throw new Error("No listener connection was resolved for this launch");
@@ -483666,8 +483608,9 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       noWait: isAgentLaunch || Boolean(values4["no-wait"]),
       clientMessageId: values4["client-message-id"],
       connectionId,
+      parentAgentId: parentAgentId ?? undefined,
       scope: {
-        agent_id: agent.id,
+        agent_id: publicAgentId,
         conversation_id: conversationId,
         acting_user_id: resolveActingUserId()
       },
@@ -534800,4 +534743,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=BF59442F8ED1752A64756E2164756E21
+//# debugId=25D231F0C01DA6C764756E2164756E21