@letta-ai/letta-code 0.34.17 → 0.34.19

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.19",
     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-RWgzMK/RLJluHmJEAXwWV7NZe1gpOgg3BYpp8+G8QfqsXUUmzZgQpQz5E9CHogeIwfcGzCaHAUIdboH6Ir7KyA=="
   };
 });
 
@@ -6463,6 +6488,7 @@ function telemetryChannel(value) {
     return;
   return [
     "slack",
+    "microsoftteams",
     "microsoftTeams",
     "telegram",
     "discord",
@@ -99266,6 +99292,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 +99851,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 +103501,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 +106635,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.
+\`$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 a repair-only request, stop after repairing the reported Git or validation state; if it has already been resolved, make no changes.
+Stage only the files you changed, by explicit path, and commit them in one call:
 
-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.
-
-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 +106887,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.
-
-**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.
+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.
 
-### 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.
+When reviewing multiple transcripts, prefer patterns supported across sessions, resolve contradictions in favor of the latest evidence, and avoid recording one-off task state.
 
-Read \`$MEMORY_DIR/.memfs.config.json\` if present to identify the repo's nesting and size limits before planning its structure.
+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).
 
-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.
-
-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.
-
-### Phase 2 — Extract
+## Trajectory review
 
 Review the conversation and identify candidate learnings worth persisting. Prioritize in this order:
 
@@ -106986,132 +106918,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.
-
-As a heuristic, when unsure between \`create\` and \`none\`, choose \`none\`. When unsure between \`create\` and a modify op, choose the modify op.
-
-For \`update\`/\`extend\`, preserve the existing frontmatter; change the description only if the skill's scope or triggers changed.
-
-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.
-
-### Phase 4 — Review
-
-Quick sanity pass before committing.
-
-- **No secrets or junk**: Do not persist sensitive values, raw logs, or ephemeral transcript details.
-
-#### Memory
+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.
 
-- **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.
+## Making memory updates
 
-#### Skills (only if you made a skill change)
+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.
 
-- **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.
+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 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 +107130,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()));
@@ -172772,6 +172635,16 @@ var init_message_queue_bridge = __esm(() => {
   pendingMessages = [];
 });
 
+// src/utils/subagent-scope.ts
+function subagentScopeMatches(parentAgentId, parentConversationId, scope) {
+  if (scope.agentId !== undefined && parentAgentId !== scope.agentId) {
+    return false;
+  }
+  if (scope.conversationId === undefined)
+    return true;
+  return parentConversationId === undefined || parentConversationId === scope.conversationId;
+}
+
 // src/utils/task-notifications.ts
 function escapeXml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -172880,6 +172753,47 @@ function appendTaskNotificationEventsToBuffer(summaries, buffer, generateId, flu
   flush?.();
   return true;
 }
+function selectStopFailedNotifications(rows, seenIds, scope) {
+  const failures = [];
+  const stops = [];
+  for (const row of rows) {
+    if (!subagentScopeMatches(row.parentAgentId, row.parentConversationId, scope)) {
+      continue;
+    }
+    if (row.stopFailed && (row.status === "pending" || row.status === "running")) {
+      const key2 = `${row.id}:${row.stopOutcome?.attempt ?? 0}`;
+      if (!seenIds.has(key2)) {
+        seenIds.add(key2);
+        failures.push(`Background task "${row.description}" could not be stopped — still running remotely. Press Esc to retry.`);
+      }
+      continue;
+    }
+    if (row.stopOutcome?.kind === "stopped" && row.status === "error") {
+      const key2 = `${row.id}:${row.stopOutcome.attempt}`;
+      if (!seenIds.has(key2)) {
+        let surfacedEarlierFailure = false;
+        for (let attempt2 = 0;attempt2 < row.stopOutcome.attempt; attempt2 += 1) {
+          if (seenIds.has(`${row.id}:${attempt2}`)) {
+            surfacedEarlierFailure = true;
+            break;
+          }
+        }
+        if (surfacedEarlierFailure) {
+          seenIds.add(key2);
+          stops.push(`Background task "${row.description}" stopped.`);
+        }
+      }
+    }
+  }
+  const present = new Set(rows.map((row) => row.id));
+  for (const key2 of seenIds) {
+    const rowId = key2.slice(0, key2.lastIndexOf(":"));
+    if (!present.has(rowId)) {
+      seenIds.delete(key2);
+    }
+  }
+  return { failures, stops };
+}
 var init_task_notifications = __esm(() => {
   init_context();
   init_constants2();
@@ -210966,7 +210880,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.17"
+    version: "0.34.19"
   };
 });
 
@@ -215101,7 +215015,7 @@ Do not use this tool for root memory files (already loaded) or skills/ (use Skil
 var init_Memory = () => {};
 
 // src/tools/descriptions/Monitor.md
-var Monitor_default = 'Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you\'re waiting for the user to answer a question.\n\nPick by how many notifications you need:\n- **One** ("tell me when the server is ready / the build finishes") → use **Bash with `run_in_background`** and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits.\n- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor with an unbounded command (`tail -f`, `inotifywait -m`, `while true`).\n- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor with a command that emits lines and then exits.\n\nYour script\'s stdout is the event stream. Each line becomes a notification. Exit ends the watch.\n  # Each matching log line is an event\n  tail -f /var/log/app.log | grep --line-buffered "ERROR"\n  # Each file change is an event\n  inotifywait -m --format \'%e %f\' /watched/dir\n  # Node script that emits events as they arrive (e.g. WebSocket listener)\n  node watch-for-events.js\n\nFor open github.com pull requests, use WatchPR instead. It covers the whole PR surface and keeps watching after CI finishes. Use Monitor only when WatchPR does not apply.\n\n**Don\'t use an unbounded command for a single notification.** `tail -f`, `inotifywait -m`, and `while true` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash `run_in_background` with an `until` loop instead (one notification, ends in seconds). Note that `tail -f log | grep -m 1 ...` does *not* fix this: if the log goes quiet after the match, `tail` never receives SIGPIPE and the pipeline hangs anyway.\n\n- Every pipe stage must flush per line or matches sit in its buffer unseen: `grep` needs `--line-buffered`, `awk` needs `fflush()`. `head` cannot flush at all — `| head -N` delivers nothing until N matches accumulate, then ends the stream.\n- In poll loops, handle transient failures (`curl ... || true`) — one failed request shouldn\'t kill the monitor.\n- Poll intervals: 30s+ for remote APIs (rate limits), 0.5–1s for local checks.\n- Write a specific `description` — it appears in every notification ("errors in deploy.log" not "watching logs").\n- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications — for a command you run directly (e.g. `python train.py 2>&1 | grep --line-buffered ...`), merge stderr with `2>&1` so its failures reach your filter. (No effect on `tail -f` of an existing log — that file only contains what its writer redirected.)\n\n**Coverage — silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit — and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.\n  # Wrong — silent on crash, hang, or any non-success exit\n  tail -f run.log | grep --line-buffered "elapsed_steps="\n  # Right — one alternation covering progress + the failure signatures you\'d act on\n  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"\n\nFor poll loops checking job state, emit on every terminal status (`succeeded|failed|cancelled|timeout`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it — some extra noise is better than missing a crashloop.\n\n**Output volume**: Every stdout line is a conversation message, so the filter should be selective — but selective means "the lines you\'d act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.\n\nStdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.\n\nThe script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout → killed. Set `persistent: true` for session-length watches (log tails, long-lived event streams) — the monitor runs until you call TaskStop or the session ends. Use TaskStop to cancel early.\n\nWhen someone is waiting on the result, set `backup_after_seconds` (e.g. 900). If the monitor goes that long without an event, a durable Wake brings you back to check the real state, so a queued, hung, or dead watch can\'t leave them waiting in silence.\n\n**ws source** — open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.\n    ws: {url: \'wss://events.example.com/stream\', protocols: [\'v1\']},\n    description: \'deploy events\',\n\nEach text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as `[binary frame, N bytes]` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash — a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.\n\nPrefer this over `command: \'websocat wss://…\'` — it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.\n';
+var Monitor_default = 'Start a background monitor that streams events from a long-running script. Each stdout line is an event — you keep working and notifications arrive in the chat. Events arrive on their own schedule and are not replies from the user, even if one lands while you\'re waiting for the user to answer a question.\n\nPick by how many notifications you need:\n- **One** ("tell me when the server is ready / the build finishes") → use **Bash with `run_in_background`** and a command that exits when the condition is true, e.g. `until grep -q "Ready in" dev.log; do sleep 0.5; done`. You get a single completion notification when it exits.\n- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor with an unbounded command (`tail -f`, `inotifywait -m`, `while true`).\n- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor with a command that emits lines and then exits.\n\nYour script\'s stdout is the event stream. Each line becomes a notification. Exit ends the watch.\n  # Each matching log line is an event\n  tail -f /var/log/app.log | grep --line-buffered "ERROR"\n  # Each file change is an event\n  inotifywait -m --format \'%e %f\' /watched/dir\n  # Node script that emits events as they arrive (e.g. WebSocket listener)\n  node watch-for-events.js\n\nFor open github.com pull requests, use WatchPR instead. It covers the whole PR surface and keeps watching after CI finishes. Use Monitor only when WatchPR does not apply.\n\n**Don\'t use an unbounded command for a single notification.** `tail -f`, `inotifywait -m`, and `while true` never exit on their own, so the monitor stays armed until timeout even after the event has fired. For "tell me when X is ready," use Bash `run_in_background` with an `until` loop instead (one notification, ends in seconds). Note that `tail -f log | grep -m 1 ...` does *not* fix this: if the log goes quiet after the match, `tail` never receives SIGPIPE and the pipeline hangs anyway.\n\n- Every pipe stage must flush per line or matches sit in its buffer unseen: `grep` needs `--line-buffered`, `awk` needs `fflush()`. `head` cannot flush at all — `| head -N` delivers nothing until N matches accumulate, then ends the stream.\n- In poll loops, handle transient failures (`curl ... || true`) — one failed request shouldn\'t kill the monitor.\n- Poll intervals: 30s+ for remote APIs (rate limits), 0.5–1s for local checks.\n- Write a specific `description` — it appears in every notification ("errors in deploy.log" not "watching logs").\n- Only stdout is the event stream. Stderr goes to the output file (readable via Read) but does not trigger notifications — for a command you run directly (e.g. `python train.py 2>&1 | grep --line-buffered ...`), merge stderr with `2>&1` so its failures reach your filter. (No effect on `tail -f` of an existing log — that file only contains what its writer redirected.)\n\n**Coverage — silence is not success.** When watching a job or process for an outcome, your filter must match every terminal state, not just the happy path. A monitor that greps only for the success marker stays silent through a crashloop, a hung process, or an unexpected exit — and silence looks identical to "still running." Before arming, ask: *if this process crashed right now, would my filter emit anything?* If not, widen it.\n  # Wrong — silent on crash, hang, or any non-success exit\n  tail -f run.log | grep --line-buffered "elapsed_steps="\n  # Right — one alternation covering progress + the failure signatures you\'d act on\n  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"\n\nFor poll loops checking job state, emit on every terminal status (`succeeded|failed|cancelled|timeout`), not just success. If you cannot confidently enumerate the failure signatures, broaden the grep alternation rather than narrow it — some extra noise is better than missing a crashloop.\n\n**Output volume**: Every stdout line is a conversation message, so the filter should be selective — but selective means "the lines you\'d act on," not "only good news." Never pipe raw logs; filter to exactly the success and failure signals you care about. Monitors that produce too many events are automatically stopped; restart with a tighter filter if this happens.\n\nStdout lines within 200ms are batched into a single notification, so multiline output from a single event groups naturally.\n\nThe script runs in the same shell environment as Bash. Exit ends the watch (exit code is reported). Timeout → killed. Set `persistent: true` for session-length watches (log tails, long-lived event streams). In managed Cloud sandboxes, every monitor stops after at most 1 hour, including persistent monitors; elsewhere persistent monitors run until TaskStop or session end. For longer Cloud waits, schedule a Wake or cron (which does not keep the sandbox running between turns) and combine it with shorter monitors. Use TaskStop to cancel early.\n\nWhen someone is waiting on the result, set `backup_after_seconds` (e.g. 900). If the monitor goes that long without an event, a durable Wake brings you back to check the real state, so a queued, hung, or dead watch can\'t leave them waiting in silence.\n\n**ws source** — open a WebSocket and stream each incoming text frame as an event. No shell, no polling: the server pushes, you get notified.\n    ws: {url: \'wss://events.example.com/stream\', protocols: [\'v1\']},\n    description: \'deploy events\',\n\nEach text frame becomes one notification (multiline frames stay as one event). Binary frames are reported as `[binary frame, N bytes]` rather than passed through. Socket close ends the watch with the close code surfaced; errors are surfaced before close. Same rate limiting as bash — a firehose will be suppressed and eventually stopped, so subscribe to a filtered feed where one exists.\n\nPrefer this over `command: \'websocat wss://…\'` — it avoids the extra process and line-buffering pitfalls. Use bash when you need to transform or filter frames with shell tools before they become events.\n';
 var init_Monitor = () => {};
 
 // src/tools/descriptions/Read.md
@@ -215624,6 +215538,8 @@ var init_Wake = () => {};
 // src/tools/descriptions/WatchPR.md
 var WatchPR_default = `Watch one open github.com pull request until it merges, closes, is stopped with TaskStop, or the session ends.
 
+In managed Cloud sandboxes, WatchPR also stops after a hard 1-hour limit and sends a timeout notification. For checks beyond that window, use Wake or cron (which does not keep the sandbox running between turns) and combine it with shorter watches. Local watches have no duration limit.
+
 Use WatchPR instead of writing a Monitor or shell polling loop when you need ongoing notifications about a PR. Start at most one watch per PR. It reports:
 
 - current-head check failures, recoveries, retries, and completion;
@@ -221280,12 +221196,55 @@ var init_disk_space = __esm(() => {
 var exports_approval_execution = {};
 __export(exports_approval_execution, {
   settleApprovalExecutionTasks: () => settleApprovalExecutionTasks,
+  overlayPartialResults: () => overlayPartialResults,
+  isUserAbortError: () => isUserAbortError,
   getResourceKey: () => getResourceKey,
   getDisplayableToolReturn: () => getDisplayableToolReturn,
   executeAutoAllowedTools: () => executeAutoAllowedTools,
-  executeApprovalBatch: () => executeApprovalBatch
+  executeApprovalBatch: () => executeApprovalBatch,
+  buildDeniedResults: () => buildDeniedResults,
+  buildCompanionResults: () => buildCompanionResults,
+  appendAbortPartials: () => appendAbortPartials,
+  ABORT_GRACE_MS: () => ABORT_GRACE_MS
 });
 import * as path16 from "node:path";
+function isUserAbortError(error5) {
+  return error5 instanceof APIUserAbortError || error5 instanceof Error && (error5.name === "AbortError" || error5.message === INTERRUPTED_BY_USER || error5.message === "The operation was aborted");
+}
+function overlayPartialResults(queued, partials) {
+  const realById = new Map((partials ?? []).map((r5) => [r5.tool_call_id, r5]));
+  const overlaid = (queued ?? []).map((r5) => realById.get(r5.tool_call_id) ?? r5);
+  const queuedIds = new Set((queued ?? []).map((r5) => r5.tool_call_id));
+  const extras = (partials ?? []).filter((r5) => !queuedIds.has(r5.tool_call_id));
+  return [...overlaid, ...extras];
+}
+function buildDeniedResults(autoDenied) {
+  return autoDenied.map((ad) => ({
+    type: "approval",
+    tool_call_id: ad.approval.toolCallId,
+    approve: false,
+    reason: ad.reason
+  }));
+}
+function buildCompanionResults(autoHandled, autoDenied) {
+  return [
+    ...autoHandled.map((ar) => ({
+      type: "tool",
+      tool_call_id: ar.toolCallId,
+      tool_return: ar.result.toolReturn,
+      status: ar.result.status,
+      stdout: ar.result.stdout,
+      stderr: ar.result.stderr
+    })),
+    ...buildDeniedResults(autoDenied)
+  ];
+}
+function appendAbortPartials(error5, extras) {
+  if (extras.length === 0 || !isUserAbortError(error5))
+    return;
+  const abortError = error5;
+  abortError.partialResults = [...abortError.partialResults ?? [], ...extras];
+}
 function getDisplayableToolReturn(content) {
   if (typeof content === "string") {
     return content;
@@ -221422,8 +221381,61 @@ async function executeSingleDecision(decision, onChunk, options) {
 async function executeApprovalBatch(decisions, onChunk, options) {
   return watchDiskSpaceDuring(options?.workingDirectory ?? getCurrentWorkingDirectory(), (text2) => deliverDiskSpaceReminder(text2, options?.parentScope), () => executeApprovalBatchUnwatched(decisions, onChunk, options));
 }
-async function settleApprovalExecutionTasks(tasks, partialResults = () => []) {
-  const settled = await Promise.allSettled(tasks);
+async function settleApprovalExecutionTasks(tasks, partialResults = () => [], options) {
+  const signal = options?.abortSignal;
+  if (!signal || signal.aborted) {
+    throwFirstSettledRejection(await Promise.allSettled(tasks), partialResults);
+    return;
+  }
+  const settled = new Array(tasks.length);
+  let remaining = tasks.length;
+  const tracked = tasks.map((task, index) => task.then(() => {
+    settled[index] = { status: "fulfilled", value: undefined };
+  }, (reason) => {
+    settled[index] = { status: "rejected", reason };
+  }).finally(() => {
+    remaining -= 1;
+  }));
+  let onAbort = () => {};
+  const aborted2 = new Promise((resolve20) => {
+    onAbort = resolve20;
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    await Promise.race([Promise.all(tracked).then(() => {
+      return;
+    }), aborted2]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (remaining === 0) {
+    throwFirstSettledRejection(settled, partialResults);
+    return;
+  }
+  let graceTimer;
+  const graceExpired = new Promise((resolve20) => {
+    graceTimer = setTimeout(resolve20, ABORT_GRACE_MS);
+  });
+  try {
+    await Promise.race([
+      Promise.all(tracked).then(() => {
+        return;
+      }),
+      graceExpired
+    ]);
+  } finally {
+    clearTimeout(graceTimer);
+  }
+  if (remaining === 0) {
+    throwFirstSettledRejection(settled, partialResults);
+    return;
+  }
+  throwFirstSettledRejection(settled.filter((result2) => result2 !== undefined), partialResults);
+  const error5 = signal.reason instanceof Error ? signal.reason : new Error(INTERRUPTED_BY_USER);
+  Object.assign(error5, { partialResults: partialResults() });
+  throw error5;
+}
+function throwFirstSettledRejection(settled, partialResults) {
   for (const result2 of settled) {
     if (result2.status !== "rejected")
       continue;
@@ -221437,6 +221449,19 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
     workingDirectory: options.workingDirectory
   })).contextId : undefined);
   const results = new Array(decisions.length).fill(null);
+  let batchDiscarded = false;
+  const guardedOnChunk = onChunk ? (chunk2) => {
+    if (!batchDiscarded)
+      onChunk(chunk2);
+  } : undefined;
+  const guardedOptions = options?.onStreamingOutput ? {
+    ...options,
+    onStreamingOutput: (toolCallId, chunk2, isStderr) => {
+      if (!batchDiscarded) {
+        options.onStreamingOutput?.(toolCallId, chunk2, isStderr);
+      }
+    }
+  } : options;
   const parallelIndices = [];
   const writeToolsByResource = new Map;
   const denyIndices = [];
@@ -221472,11 +221497,11 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
     const decision = decisions[i4];
     if (decision) {
       let crossedEffectBoundary = false;
-      const result2 = await executeSingleDecision(decision, onChunk, {
-        ...options,
+      const result2 = await executeSingleDecision(decision, guardedOnChunk, {
+        ...guardedOptions,
         toolContextId,
         beforeToolExecution: async (toolCallId) => {
-          await options?.beforeToolExecution?.(toolCallId);
+          await guardedOptions?.beforeToolExecution?.(toolCallId);
           crossedEffectBoundary = true;
         }
       });
@@ -221486,15 +221511,20 @@ async function executeApprovalBatchUnwatched(decisions, onChunk, options) {
       }
     }
   };
-  await settleApprovalExecutionTasks([
-    ...parallelIndices.map(execute),
-    ...denyIndices.map(execute),
-    ...Array.from(writeToolsByResource.values()).map(async (indices) => {
-      for (const i4 of indices) {
-        await execute(i4);
-      }
-    })
-  ], () => results.filter((result2) => result2 !== null));
+  try {
+    await settleApprovalExecutionTasks([
+      ...parallelIndices.map(execute),
+      ...denyIndices.map(execute),
+      ...Array.from(writeToolsByResource.values()).map(async (indices) => {
+        for (const i4 of indices) {
+          await execute(i4);
+        }
+      })
+    ], () => results.filter((result2) => result2 !== null), { abortSignal: options?.abortSignal });
+  } catch (error5) {
+    batchDiscarded = true;
+    throw error5;
+  }
   return results.filter((r5) => r5 !== null);
 }
 async function executeAutoAllowedTools(autoAllowed, onChunk, options) {
@@ -221513,8 +221543,9 @@ async function executeAutoAllowedTools(autoAllowed, onChunk, options) {
     }
   }));
 }
-var PARALLEL_SAFE_TOOLS, FILE_PATH_TOOLS, GLOBAL_LOCK_TOOLS;
+var ABORT_GRACE_MS = 500, PARALLEL_SAFE_TOOLS, FILE_PATH_TOOLS, GLOBAL_LOCK_TOOLS;
 var init_approval_execution = __esm(async () => {
+  init_error();
   init_constants2();
   init_disk_space();
   init_runtime_context();
@@ -222512,14 +222543,23 @@ function scheduleCompletedSubagentCleanup(id2) {
     return;
   }
   clearCompletedSubagentCleanup(id2);
+  armCompletedSubagentCleanup(id2);
+}
+function armCompletedSubagentCleanup(id2) {
+  const agent = store2.agents.get(id2);
+  if (!agent)
+    return;
   const timer = setTimeout(() => {
+    completedSubagentCleanupTimers.delete(id2);
     const current = store2.agents.get(id2);
     if (!current || current.status !== "completed" && current.status !== "error") {
-      completedSubagentCleanupTimers.delete(id2);
+      return;
+    }
+    if (current.cancelPending) {
+      armCompletedSubagentCleanup(id2);
       return;
     }
     store2.agents.delete(id2);
-    completedSubagentCleanupTimers.delete(id2);
     notifyListeners();
   }, agent.result !== undefined ? publishedResultRetentionMs : completedSubagentRetentionMs);
   unrefTimer2(timer);
@@ -222609,6 +222649,7 @@ function completeSubagent(id2, result2) {
     ...agent,
     status: result2.success ? "completed" : "error",
     error: result2.error,
+    stopFailed: undefined,
     ...result2.result !== undefined ? { result: result2.result } : {},
     durationMs: Date.now() - agent.startTime,
     totalTokens: result2.totalTokens ?? agent.totalTokens,
@@ -222665,6 +222706,8 @@ function clearCompletedSubagents() {
   for (const [id2, agent] of store2.agents.entries()) {
     if (agent.result !== undefined)
       continue;
+    if (agent.cancelPending)
+      continue;
     if (agent.status === "completed" || agent.status === "error") {
       clearCompletedSubagentCleanup(id2);
       store2.agents.delete(id2);
@@ -222678,6 +222721,11 @@ function clearCompletedSubagents() {
 function clearSubagentsByIds(ids) {
   let removedAny = false;
   for (const id2 of ids) {
+    const agent = store2.agents.get(id2);
+    if (agent?.cancelPending) {
+      updateSubagent(id2, { silent: true });
+      continue;
+    }
     clearCompletedSubagentCleanup(id2);
     removedAny = store2.agents.delete(id2) || removedAny;
   }
@@ -222693,15 +222741,28 @@ function hasActiveSubagents() {
   }
   return false;
 }
-function interruptActiveSubagents(errorMessage) {
+function registerSubagentAbortHook(id2, hook) {
+  subagentAbortHooks.set(id2, hook);
+}
+function clearSubagentAbortHook(id2) {
+  subagentAbortHooks.delete(id2);
+}
+function interruptActiveSubagents(errorMessage, scope) {
   let anyInterrupted = false;
   for (const [id2, agent] of store2.agents.entries()) {
     if (agent.status === "pending" || agent.status === "running") {
+      if (scope && !subagentMatchesScope(agent, scope))
+        continue;
+      const hook = subagentAbortHooks.get(id2);
+      hook?.();
+      subagentAbortHooks.delete(id2);
       const updatedAgent = {
         ...agent,
         status: "error",
         error: errorMessage,
-        durationMs: Date.now() - agent.startTime
+        durationMs: Date.now() - agent.startTime,
+        ...hook ? { cancelPending: true, stopAttempts: (agent.stopAttempts ?? 0) + 1 } : {},
+        stopFailed: undefined
       };
       store2.agents.set(id2, updatedAgent);
       scheduleCompletedSubagentCleanup(id2);
@@ -222712,6 +222773,50 @@ function interruptActiveSubagents(errorMessage) {
     notifyListeners();
   }
 }
+function interruptStopFailedSubagents(errorMessage, scope) {
+  const interrupted = [];
+  for (const [id2, agent] of store2.agents.entries()) {
+    if (!agent.stopFailed)
+      continue;
+    if (agent.status !== "pending" && agent.status !== "running")
+      continue;
+    if (scope && !subagentMatchesScope(agent, scope))
+      continue;
+    const hook = subagentAbortHooks.get(id2);
+    hook?.();
+    subagentAbortHooks.delete(id2);
+    const updatedAgent = {
+      ...agent,
+      status: "error",
+      error: errorMessage,
+      durationMs: Date.now() - agent.startTime,
+      ...hook ? { cancelPending: true, stopAttempts: (agent.stopAttempts ?? 0) + 1 } : {},
+      stopFailed: undefined
+    };
+    store2.agents.set(id2, updatedAgent);
+    scheduleCompletedSubagentCleanup(id2);
+    interrupted.push(id2);
+  }
+  if (interrupted.length > 0) {
+    notifyListeners();
+  }
+  return interrupted;
+}
+function subagentMatchesScope(agent, scope) {
+  return subagentScopeMatches(agent.parentAgentId, agent.parentConversationId, scope);
+}
+function hasStopFailedSubagents(scope) {
+  for (const agent of store2.agents.values()) {
+    if (!agent.stopFailed)
+      continue;
+    if (agent.status !== "pending" && agent.status !== "running")
+      continue;
+    if (scope && !subagentMatchesScope(agent, scope))
+      continue;
+    return true;
+  }
+  return false;
+}
 function subscribe2(listener) {
   store2.listeners.add(listener);
   return () => {
@@ -222732,7 +222837,7 @@ function emitStreamEvent(subagentId, event) {
     listener(subagentId, event);
   }
 }
-var store2, cachedSnapshot, cachedLifecycleItems, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, DEFAULT_PUBLISHED_RESULT_RETENTION_MS, publishedResultRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, streamEventListeners;
+var store2, cachedSnapshot, cachedLifecycleItems, DEFAULT_COMPLETED_SUBAGENT_RETENTION_MS = 30000, completedSubagentRetentionMs, DEFAULT_PUBLISHED_RESULT_RETENTION_MS, publishedResultRetentionMs, completedSubagentCleanupTimers, subagentCounter = 0, subagentAbortHooks, streamEventListeners;
 var init_subagent_state = __esm(() => {
   store2 = {
     agents: new Map,
@@ -222748,6 +222853,7 @@ var init_subagent_state = __esm(() => {
   DEFAULT_PUBLISHED_RESULT_RETENTION_MS = 30 * 60000;
   publishedResultRetentionMs = DEFAULT_PUBLISHED_RESULT_RETENTION_MS;
   completedSubagentCleanupTimers = new Map;
+  subagentAbortHooks = new Map;
   streamEventListeners = new Set;
 });
 
@@ -223266,10 +223372,37 @@ var init_tool_registry = __esm(() => {
 });
 
 // src/tools/external-tool-background.ts
+function interruptedExternalToolResult(toolName2) {
+  return {
+    status: "error",
+    toolReturn: `External tool call interrupted by user: ${toolName2}. The remote tool may still finish; its outcome is unknown. Check the destination before retrying a write.`
+  };
+}
+function raceExternalOperationAbort(operation, signal, toolName2) {
+  if (signal.aborted) {
+    return Promise.resolve(interruptedExternalToolResult(toolName2));
+  }
+  return new Promise((resolve21, reject2) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      cleanup();
+      resolve21(interruptedExternalToolResult(toolName2));
+    };
+    signal.addEventListener("abort", onAbort);
+    operation.then((result2) => {
+      cleanup();
+      resolve21(result2);
+    }, (error5) => {
+      cleanup();
+      reject2(error5);
+    });
+  });
+}
 function notificationText(toolReturn) {
   return scrubAmbientSecrets(String(toolReturn));
 }
 async function autoBackgroundExternalTool(toolName2, tool, operation, options) {
+  const signal = options?.signal;
   const runtime = options?.runtimeScope;
   const scope = options?.scope ?? (runtime?.agentId && runtime.conversationId ? {
     agentId: runtime.agentId,
@@ -223278,24 +223411,36 @@ async function autoBackgroundExternalTool(toolName2, tool, operation, options) {
   } : undefined);
   const canBackground = () => typeof options?.canBackground === "function" ? options.canBackground() : options?.canBackground !== false;
   if (tool?.autoBackground !== true || !canBackground() || !scope || !options?.enqueue && !isQueueBridgeConnected())
-    return operation;
+    return signal ? raceExternalOperationAbort(operation, signal, toolName2) : operation;
   const startedAt = Date.now();
   const settled = operation.then((result2) => ({ kind: "result", result: result2 }), (error5) => ({ kind: "error", error: error5 }));
   let timer;
+  let onAbort;
+  const abortSettled = signal ? new Promise((resolve21) => {
+    onAbort = () => resolve21({ kind: "aborted" });
+    signal?.addEventListener("abort", onAbort);
+  }) : undefined;
   const first = await Promise.race([
     settled,
     new Promise((resolve21) => {
       timer = setTimeout(() => resolve21({ kind: "yield" }), options?.yieldMs ?? DEFAULT_EXTERNAL_TOOL_YIELD_MS);
-    })
+    }),
+    ...abortSettled ? [abortSettled] : []
   ]);
   if (timer !== undefined)
     clearTimeout(timer);
+  if (onAbort !== undefined && signal) {
+    signal.removeEventListener("abort", onAbort);
+  }
+  if (first.kind === "aborted")
+    return interruptedExternalToolResult(toolName2);
   if (first.kind === "result")
     return first.result;
   if (first.kind === "error")
     throw first.error;
-  if (!canBackground())
-    return operation;
+  if (!canBackground()) {
+    return signal ? raceExternalOperationAbort(operation, signal, toolName2) : operation;
+  }
   const taskId = `external_${crypto.randomUUID()}`;
   const enqueue = options?.enqueue ?? addToMessageQueue;
   settled.then(async (outcome) => {
@@ -223345,14 +223490,15 @@ function hasActiveToolEndHandlers(events) {
     return false;
   return events.hasHandlers?.("tool_end") ?? true;
 }
-function listenerExternalToolBackgroundOptions(tool, events, runtimeScope) {
+function listenerExternalToolBackgroundOptions(tool, events, runtimeScope, signal) {
   const registration = tool ? listenerRegistrations.get(tool) : undefined;
   const notificationGuard = registration?.createNotificationGuard();
   return {
     canBackground: () => notificationGuard?.isCurrent() === true && !hasActiveToolEndHandlers(events),
     ...registration?.yieldMs !== undefined ? { yieldMs: registration.yieldMs } : {},
     ...notificationGuard ? { shouldEnqueue: notificationGuard.waitUntilCurrent } : {},
-    runtimeScope
+    runtimeScope,
+    ...signal ? { signal } : {}
   };
 }
 var listenerRegistrations;
@@ -229130,7 +229276,6 @@ var LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS, PROJECT_SKILLS_DIR, SKILLS_DIR = ".skil
 var init_skills5 = __esm(() => {
   init_skill_sources();
   LOCAL_AGENT_EXCLUDED_BUNDLED_SKILLS = new Set([
-    "curating-memory-palace",
     "image-generation",
     "managing-agent-webhooks",
     "managing-shared-memory",
@@ -229651,7 +229796,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()) {
@@ -230280,7 +230425,7 @@ function getExternalToolsAsClientTools() {
     parameters: tool.parameters
   }));
 }
-async function executeExternalTool(toolCallId, toolName2, input, executorOverride, toolDefinition) {
+async function executeExternalTool(toolCallId, toolName2, input, executorOverride, toolDefinition, signal) {
   const executor = executorOverride ?? getExternalToolExecutor();
   if (!executor) {
     return {
@@ -230292,7 +230437,7 @@ async function executeExternalTool(toolCallId, toolName2, input, executorOverrid
   let success = false;
   try {
     const tool = toolDefinition ?? getExternalToolDefinition(toolName2);
-    const result2 = await executor(toolCallId, toolName2, input, tool ? { tool } : undefined);
+    const result2 = await executor(toolCallId, toolName2, input, tool ? { tool, signal } : undefined);
     success = !result2.isError;
     return {
       toolReturn: clampToolReturnContent(normalizeExternalToolResultContent(result2.content), toolName2),
@@ -231059,7 +231204,7 @@ async function executeToolInner(name, args, options) {
     if (permissionDecision2?.decision !== undefined && permissionDecision2.decision !== "allow") {
       return createModPermissionToolResult(permissionDecision2);
     }
-    return runWithRuntimeContext(executionScope, () => autoBackgroundExternalTool(name, externalTool, executeExternalTool(options?.toolCallId ?? `ext-${Date.now()}`, name, eventArgs2, externalTool?.executor ?? activeExternalExecutor, externalTool), listenerExternalToolBackgroundOptions(externalTool, modEvents, executionScope)));
+    return runWithRuntimeContext(executionScope, () => autoBackgroundExternalTool(name, externalTool, executeExternalTool(options?.toolCallId ?? `ext-${Date.now()}`, name, eventArgs2, externalTool?.executor ?? activeExternalExecutor, externalTool, options?.signal), listenerExternalToolBackgroundOptions(externalTool, modEvents, executionScope, options?.signal)));
   }
   const internalName = resolveInternalToolName(name, activeRegistry);
   const tool = internalName ? activeRegistry.get(internalName) : undefined;
@@ -232521,12 +232666,12 @@ async function runCall(parsed, deps, agentId, stdout) {
   await printJson(stdout, result2);
   return result2.isError === true ? 2 : 0;
 }
-async function callCatalogTool(catalog, deps, agentId, toolName2, args) {
+async function callCatalogTool(catalog, deps, agentId, toolName2, args, options) {
   const tool = catalog.tools.find((candidate) => candidate.schema.name === toolName2);
   if (!tool) {
     throw new McpCliError("tool_not_found", `MCP tool '${toolName2}' is not available`);
   }
-  return tool.target.kind === "client" ? await tool.target.connection.callTool(tool.target.rawName, args) : mcpToolResultFromServer(await runUnifiedMcpTool({
+  return tool.target.kind === "client" ? await tool.target.connection.callTool(tool.target.rawName, args, options) : mcpToolResultFromServer(await runUnifiedMcpTool({
     client: await getServerClient(deps),
     agentId,
     mcpServerId: tool.target.serverId,
@@ -232555,7 +232700,7 @@ function createAgentMcpSession(agentId, deps = {}) {
     return catalog;
   };
   return {
-    callTool: async (toolName2, args) => callCatalogTool(await load(), deps, agentId, toolName2, args),
+    callTool: async (toolName2, args, options) => callCatalogTool(await load(), deps, agentId, toolName2, args, options),
     listTools: async () => (await load()).tools.map((tool) => tool.schema),
     close: async () => {
       closed = true;
@@ -232712,7 +232857,7 @@ async function createScriptToolScope(parentAgentId, signal) {
           isError: result2.status === "error"
         };
       }
-      return (await mcp()).callTool(toolName2, toolArgs);
+      return (await mcp()).callTool(toolName2, toolArgs, signal ? { signal } : {});
     },
     cleanup: async () => {
       await mcpSession?.then((session3) => session3.close()).catch(() => {
@@ -233255,6 +233400,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;
@@ -240001,6 +240149,9 @@ var init_monitor_event_stream = __esm(() => {
 // src/tools/impl/monitor.ts
 import { appendFileSync as appendFileSync7, readFileSync as readFileSync35, writeFileSync as writeFileSync27 } from "node:fs";
 import { WebSocket as WebSocket4 } from "ws";
+function getMonitorTimeoutEvent(timeoutMs) {
+  return isManagedCloudRuntime() && timeoutMs === MONITOR_MAX_TIMEOUT_MS ? "Monitor stopped at the 1-hour Cloud sandbox limit. Cloud monitors have a hard 1-hour limit to avoid keeping sandbox resources unnecessarily running. For later checks, schedule a Wake or cron, which does not keep the sandbox running between turns, and combine it with shorter monitors when needed." : "[Monitor timed out — re-arm if needed.]";
+}
 function buildMonitorResult(taskId, timeoutMs, persistent, outputFile) {
   const lifetime = persistent ? "persistent — runs until TaskStop or session end" : `timeout ${timeoutMs}ms`;
   return {
@@ -240110,8 +240261,8 @@ function normalizeMonitorArgs(args) {
   if (typeof normalized.description !== "string") {
     throw new Error("Monitor description is required");
   }
-  if (typeof normalized.timeout_ms !== "number" || !Number.isFinite(normalized.timeout_ms) || normalized.timeout_ms < MIN_TIMEOUT_MS || !normalized.persistent && normalized.timeout_ms > MAX_TIMEOUT_MS) {
-    throw new Error(`Monitor timeout_ms must be between ${MIN_TIMEOUT_MS} and ${MAX_TIMEOUT_MS}`);
+  if (typeof normalized.timeout_ms !== "number" || !Number.isFinite(normalized.timeout_ms) || normalized.timeout_ms < MIN_TIMEOUT_MS || !normalized.persistent && normalized.timeout_ms > MONITOR_MAX_TIMEOUT_MS) {
+    throw new Error(`Monitor timeout_ms must be between ${MIN_TIMEOUT_MS} and ${MONITOR_MAX_TIMEOUT_MS}`);
   }
   if (typeof normalized.persistent !== "boolean") {
     throw new Error("Monitor persistent must be a boolean");
@@ -240143,6 +240294,10 @@ function normalizeMonitorArgs(args) {
     }
     validateWebSocketSource(normalized.ws);
   }
+  if (isManagedCloudRuntime() && normalized.persistent) {
+    normalized.persistent = false;
+    normalized.timeout_ms = MONITOR_MAX_TIMEOUT_MS;
+  }
   return normalized;
 }
 function webSocketDisplayUrl(sourceUrl) {
@@ -240375,7 +240530,7 @@ function startCommandMonitor(args) {
 `);
       queueMonitorEvent({
         taskId,
-        event: "[Monitor timed out — re-arm if needed.]",
+        event: getMonitorTimeoutEvent(args.timeout_ms),
         scope,
         actingUserId,
         secrets: secrets2
@@ -240557,7 +240712,7 @@ function startWebSocketMonitor(args) {
         return;
       queueMonitorEvent({
         taskId,
-        event: "[Monitor timed out — re-arm if needed.]",
+        event: getMonitorTimeoutEvent(args.timeout_ms),
         scope,
         actingUserId,
         secrets: secrets2
@@ -240620,7 +240775,7 @@ function installMonitorProcessExitCleanup() {
   monitorProcessExitCleanupInstalled = true;
   process.once("exit", stopMonitorsForProcessExit);
 }
-var MIN_TIMEOUT_MS = 1000, MAX_TIMEOUT_MS = 3600000, DEFAULT_TIMEOUT_MS4 = 300000, MONITOR_OUTPUT_FILE_BYTES, WEBSOCKET_MAX_PAYLOAD_BYTES, WEBSOCKET_PROTOCOL_PATTERN, monitorProcessExitCleanupInstalled = false;
+var MIN_TIMEOUT_MS = 1000, MONITOR_MAX_TIMEOUT_MS = 3600000, DEFAULT_TIMEOUT_MS4 = 300000, MONITOR_OUTPUT_FILE_BYTES, WEBSOCKET_MAX_PAYLOAD_BYTES, WEBSOCKET_PROTOCOL_PATTERN, monitorProcessExitCleanupInstalled = false;
 var init_monitor = __esm(async () => {
   init_strip_ansi();
   init_runtime_context();
@@ -241429,6 +241584,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 +241704,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 +241749,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 +241794,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 +242560,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.17"
+        version: "0.34.19"
       },
       capabilities: null
     });
@@ -242817,6 +242979,22 @@ var init_codex_app_server = __esm(() => {
   DEFAULT_IDLE_TIMEOUT_MS = 5 * 60000;
 });
 
+// src/agent/parent-memory-note.ts
+import { statSync as statSync18 } from "node:fs";
+function buildParentMemoryNote(parentAgentId) {
+  const directory = getScopedMemoryFilesystemRoot(parentAgentId);
+  try {
+    if (!statSync18(directory).isDirectory())
+      return;
+  } catch {
+    return;
+  }
+  return `Your parent agent (${parentAgentId}) keeps its memory as Markdown files at \`${directory}\`; attached shared-memory repos sit next to it. If the task depends on context about the user, project, people or conventions, check there first: start with \`MEMORY.md\` and the directory indexes, then open only the files that look relevant. Don't edit or commit there unless asked.`;
+}
+var init_parent_memory_note = __esm(() => {
+  init_memory_filesystem2();
+});
+
 // src/cli/helpers/agent-info.ts
 function getRelativeTime(dateStr) {
   const date5 = new Date(dateStr);
@@ -242860,10 +243038,13 @@ function buildAgentInfo(options) {
     })();
     const memoryDirLine = showMemoryDir ? `
 - **Memory directory (also stored in \`MEMORY_DIR\` env var)**: \`${getScopedMemoryFilesystemRoot(agentInfo.id)}\`` : "";
+    const parentMemoryNote = options.parentAgentId && options.parentAgentId !== agentInfo.id ? buildParentMemoryNote(options.parentAgentId) : undefined;
+    const parentMemoryLine = parentMemoryNote ? `
+- ${parentMemoryNote}` : "";
     const convLine = conversationId ? `
 - **Conversation ID (also stored in \`CONVERSATION_ID\` env var)**: ${conversationId}` : "";
     return `${SYSTEM_REMINDER_OPEN} This is an automated message providing information about you.
-- **Agent ID (also stored in \`AGENT_ID\` env var)**: ${agentInfo.id}${convLine}${memoryDirLine}
+- **Agent ID (also stored in \`AGENT_ID\` env var)**: ${agentInfo.id}${convLine}${memoryDirLine}${parentMemoryLine}
 - **Agent name**: ${agentInfo.name || "(unnamed)"} (the user can change this with /rename)
 - **Agent description**: ${agentInfo.description || "(no description)"} (the user can change this with /description)
 - **Last message**: ${lastRunInfo}
@@ -242874,6 +243055,7 @@ ${SYSTEM_REMINDER_CLOSE}`;
 }
 var init_agent_info = __esm(() => {
   init_memory_filesystem2();
+  init_parent_memory_note();
   init_paths();
   init_constants2();
   init_settings_manager();
@@ -243343,7 +243525,14 @@ async function buildAgentInfoReminder(context3) {
   if (!context3.systemInfoReminderEnabled || context3.state.hasSentAgentInfo) {
     return null;
   }
+  let parentAgentId;
+  try {
+    const scopeAgentId = await getMcpScopeAgentId(context3.agent.id);
+    if (scopeAgentId !== context3.agent.id)
+      parentAgentId = scopeAgentId;
+  } catch {}
   const reminder = buildAgentInfo({
+    parentAgentId,
     agentInfo: {
       id: context3.agent.id,
       name: context3.agent.name,
@@ -244950,6 +245139,18 @@ async function resolveExternalCodingAgentSecretEnv(parentAgentId, lookupParent)
   return { ...inherited, ...loadSecrets2(parentAgentId) };
 }
 async function runExternalCodingAgent(options, deps = {}) {
+  const parentMemoryNote = buildParentMemoryNote(options.parentAgentId);
+  options = {
+    ...options,
+    mcpReminder: [
+      parentMemoryNote ? `${SYSTEM_REMINDER_OPEN}
+${parentMemoryNote}
+${SYSTEM_REMINDER_CLOSE}` : undefined,
+      options.mcpReminder
+    ].filter(Boolean).join(`
+
+`) || undefined
+  };
   const startedAt = Date.now();
   const secretEnv = await (deps.resolveSecretEnv ?? resolveExternalCodingAgentSecretEnv)(options.parentAgentId);
   const env6 = {
@@ -245116,8 +245317,10 @@ async function runExternalCodingAgent(options, deps = {}) {
 }
 var EXTERNAL_CODING_AGENT_TYPES, EXTERNAL_AGENT_ID_PREFIXES, NATIVE_SESSION_ID_PATTERN, MISSING_EXECUTABLE_PREFIX = "Required executable '", CODEX_NOT_READY_PREFIX = "Codex executable is not ready", CLAUDE_NOT_SIGNED_IN_PREFIX = "claude-code authentication is not ready";
 var init_external_coding_agent = __esm(() => {
+  init_parent_memory_note();
   init_subagent_depth();
   init_subagent_process();
+  init_constants2();
   init_mcp_scope();
   init_engine3();
   init_runtime_context();
@@ -246327,8 +246530,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 +246558,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 +246582,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 +246593,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 +246682,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 +246692,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 +246711,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 +246831,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 +246842,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 +246974,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 +246996,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 +247009,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 +248947,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 +249098,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 +249108,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",
@@ -248948,6 +249167,184 @@ var init_subagent_computer = __esm(() => {
   LOCAL_COMPUTER_SELECTORS = new Set(["local", "self"]);
 });
 
+// src/tools/impl/kill-bash.ts
+function killBackgroundProcess(shell_id) {
+  const proc = backgroundProcesses.get(shell_id);
+  const retainsEntry = proc?.kind === "monitor" || proc?.kind === "workflow";
+  if (!proc || retainsEntry && proc.status !== "running") {
+    return false;
+  }
+  const previousStatus = proc.status;
+  const previousNotificationSuppression = proc.completionNotificationSuppressed;
+  try {
+    proc.completionNotificationSuppressed = true;
+    if (retainsEntry) {
+      proc.status = "failed";
+    }
+    proc.process.kill("SIGTERM");
+    if (proc.kind === "monitor")
+      cancelMonitorBackup(shell_id);
+    clearBackgroundProcessCleanup(shell_id);
+    if (retainsEntry) {
+      scheduleBackgroundProcessCleanup(shell_id);
+      notifyBackgroundProcessStateChanged(proc.runtimeScope);
+    } else {
+      backgroundProcesses.delete(shell_id);
+    }
+    return true;
+  } catch {
+    proc.status = previousStatus;
+    proc.completionNotificationSuppressed = previousNotificationSuppression;
+    return false;
+  }
+}
+var init_kill_bash = __esm(async () => {
+  init_process_manager();
+  await init_monitor_backup();
+});
+
+// src/tools/impl/task-stop.ts
+var exports_task_stop = {};
+__export(exports_task_stop, {
+  task_stop: () => task_stop
+});
+async function cancelRemoteRun(subagentId) {
+  const child = getSubagents().find((agent) => agent.id === subagentId);
+  const target2 = child?.conversationId === "default" ? child.agentId : child?.conversationId;
+  try {
+    if (!target2)
+      throw new Error("its conversation is not known yet");
+    const results = await getBackend().cancelConversation(target2);
+    const outcomes = Object.values(results);
+    if (outcomes.length === 0 || outcomes.some((status) => status !== "cancelled")) {
+      throw new Error("Cloud did not cancel every run");
+    }
+    return { killed: true, output: "Cancelled the remote run" };
+  } catch (error5) {
+    return {
+      killed: false,
+      output: `Couldn't cancel the remote run: ${getErrorMessage2(error5)}`
+    };
+  }
+}
+async function task_stop(args, deps = {}) {
+  validateRequiredParams(args, ["task_id"], "TaskStop");
+  const { task_id } = args;
+  const task = backgroundTasks.get(task_id);
+  if (task) {
+    if (task.status === "running" && task.abortController) {
+      const child = getSubagents().find((agent) => agent.id === task.subagentId);
+      const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
+      let remote;
+      let remoteExternalStopped = false;
+      if (external3?.computer) {
+        try {
+          if (!task.runtimeScope)
+            throw new Error("its parent conversation is not known");
+          const result3 = await (deps.stopRemoteExternal ?? stopRemoteExternalCodingAgent)({
+            agentId: child?.agentId,
+            parentScope: {
+              agentId: task.runtimeScope.agentId,
+              conversationId: task.runtimeScope.conversationId,
+              actingUserId: task.actingUserId
+            }
+          });
+          remote = {
+            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,
+            output: `Couldn't stop the remote external subagent: ${getErrorMessage2(error5)}`
+          };
+        }
+      } else if (task.remote) {
+        remote = await cancelRemoteRun(task.subagentId);
+      }
+      if (remote && !remote.killed)
+        return remote;
+      task.abortController.abort(remoteExternalStopped ? REMOTE_EXTERNAL_WORKER_STOPPED : undefined);
+      task.error = "Aborted by user";
+      await task.completion;
+      task.status = "failed";
+      scheduleBackgroundTaskCleanup(task_id);
+      return remote ?? { killed: true };
+    }
+    return { killed: false };
+  }
+  return { killed: killBackgroundProcess(task_id) };
+}
+var init_task_stop = __esm(async () => {
+  init_subagent_state();
+  init_backend2();
+  init_external_coding_agent();
+  init_process_manager();
+  init_remote_external_coding_agent();
+  await init_kill_bash();
+});
+
+// src/tools/impl/task-abort-hook.ts
+function buildBackgroundTaskAbortHook(taskId, abortController) {
+  const bgTask = backgroundTasks.get(taskId);
+  const remote = bgTask?.remote ?? false;
+  const failSafeAbort = () => !remote && abortController.abort();
+  const hook = () => {
+    init_task_stop().then(() => exports_task_stop).then((m4) => m4.task_stop({ task_id: taskId })).then((result3) => {
+      if (!result3.killed)
+        failSafeAbort();
+      settleInterruptedCancel(bgTask, remote, result3.killed, hook);
+    }).catch(() => {
+      failSafeAbort();
+      settleInterruptedCancel(bgTask, remote, false, hook);
+    });
+  };
+  return hook;
+}
+function settleInterruptedCancel(bgTask, remote, killed, hook) {
+  if (!bgTask)
+    return;
+  const taskLive = bgTask.status === "running";
+  if (remote && !killed && taskLive) {
+    restoreInterruptedSubagentRow(bgTask.subagentId, hook);
+    return;
+  }
+  const row = getSubagents().find((agent) => agent.id === bgTask.subagentId);
+  updateSubagent(bgTask.subagentId, {
+    cancelPending: undefined,
+    stopFailed: undefined,
+    stopOutcome: {
+      attempt: row?.stopAttempts ?? 0,
+      kind: killed ? "stopped" : "natural"
+    }
+  });
+}
+function restoreInterruptedSubagentRow(subagentId, hook) {
+  const row = getSubagents().find((agent) => agent.id === subagentId);
+  if (!row || row.status !== "error" || row.result !== undefined) {
+    if (row) {
+      updateSubagent(subagentId, {
+        cancelPending: undefined,
+        stopOutcome: { attempt: row.stopAttempts ?? 0, kind: "natural" }
+      });
+    }
+    return;
+  }
+  updateSubagent(subagentId, {
+    status: "running",
+    error: undefined,
+    cancelPending: undefined,
+    stopFailed: true,
+    stopOutcome: { attempt: row.stopAttempts ?? 0, kind: "failed" }
+  });
+  registerSubagentAbortHook(subagentId, hook);
+}
+var init_task_abort_hook = __esm(() => {
+  init_subagent_state();
+  init_process_manager();
+});
+
 // src/tools/impl/task-transcript.ts
 function buildTaskResultHeader(subagentType, subagentId, result3, status) {
   return [
@@ -249066,6 +249463,7 @@ function spawnBackgroundSubagentTask(args) {
     actingUserId
   };
   backgroundTasks.set(taskId, bgTask);
+  registerSubagentAbortHook(subagentId, buildBackgroundTaskAbortHook(taskId, abortController));
   writeTaskTranscriptStart(outputFile, description, subagentType);
   const parentAgentIdForSpawn = resolvedParentScope?.agentId;
   const workerMemoryDir = subagentType === "memory" && resolvedParentScope ? memoryScope?.primaryRoot ?? getScopedMemoryFilesystemRoot(resolvedParentScope.agentId) : undefined;
@@ -249097,6 +249495,7 @@ function spawnBackgroundSubagentTask(args) {
     const header = buildTaskResultHeader(subagentType, subagentId, result3, result3.success ? "success" : "error");
     writeTaskTranscriptResult(outputFile, result3, header, !!memoryTask);
     scheduleBackgroundTaskCleanup(taskId);
+    clearSubagentAbortHook(subagentId);
     completeSubagentFn(subagentId, {
       success: result3.success,
       error: result3.error,
@@ -249164,6 +249563,7 @@ Error: ${result3.error || "Subagent execution failed"}`;
 [Task failed]
 `);
     scheduleBackgroundTaskCleanup(taskId);
+    clearSubagentAbortHook(subagentId);
     completeSubagentFn(subagentId, { success: false, error: errorMessage4 });
     try {
       await onComplete?.({
@@ -249522,6 +249922,7 @@ var init_task = __esm(async () => {
   init_process_manager();
   init_remote_external_coding_agent();
   init_subagent_computer();
+  init_task_abort_hook();
   init_task_transcript();
   init_truncation();
   init_background_link();
@@ -250414,118 +250815,6 @@ var init_task_list = __esm(() => {
   init_store();
 });
 
-// src/tools/impl/kill-bash.ts
-function killBackgroundProcess(shell_id) {
-  const proc = backgroundProcesses.get(shell_id);
-  const retainsEntry = proc?.kind === "monitor" || proc?.kind === "workflow";
-  if (!proc || retainsEntry && proc.status !== "running") {
-    return false;
-  }
-  const previousStatus = proc.status;
-  const previousNotificationSuppression = proc.completionNotificationSuppressed;
-  try {
-    proc.completionNotificationSuppressed = true;
-    if (retainsEntry) {
-      proc.status = "failed";
-    }
-    proc.process.kill("SIGTERM");
-    if (proc.kind === "monitor")
-      cancelMonitorBackup(shell_id);
-    clearBackgroundProcessCleanup(shell_id);
-    if (retainsEntry) {
-      scheduleBackgroundProcessCleanup(shell_id);
-      notifyBackgroundProcessStateChanged(proc.runtimeScope);
-    } else {
-      backgroundProcesses.delete(shell_id);
-    }
-    return true;
-  } catch {
-    proc.status = previousStatus;
-    proc.completionNotificationSuppressed = previousNotificationSuppression;
-    return false;
-  }
-}
-var init_kill_bash = __esm(async () => {
-  init_process_manager();
-  await init_monitor_backup();
-});
-
-// src/tools/impl/task-stop.ts
-async function cancelRemoteRun(subagentId) {
-  const child = getSubagents().find((agent) => agent.id === subagentId);
-  const target2 = child?.conversationId === "default" ? child.agentId : child?.conversationId;
-  try {
-    if (!target2)
-      throw new Error("its conversation is not known yet");
-    const results = await getBackend().cancelConversation(target2);
-    const outcomes = Object.values(results);
-    if (outcomes.length === 0 || outcomes.some((status) => status !== "cancelled")) {
-      throw new Error("Cloud did not cancel every run");
-    }
-    return { killed: true, output: "Cancelled the remote run" };
-  } catch (error5) {
-    return {
-      killed: false,
-      output: `Couldn't cancel the remote run: ${getErrorMessage2(error5)}`
-    };
-  }
-}
-async function task_stop(args, deps = {}) {
-  validateRequiredParams(args, ["task_id"], "TaskStop");
-  const { task_id } = args;
-  const task2 = backgroundTasks.get(task_id);
-  if (task2) {
-    if (task2.status === "running" && task2.abortController) {
-      const child = getSubagents().find((agent) => agent.id === task2.subagentId);
-      const external3 = parseExternalCodingAgentId(child?.agentId ?? undefined);
-      let remote;
-      if (external3?.computer) {
-        try {
-          if (!task2.runtimeScope)
-            throw new Error("its parent conversation is not known");
-          const result3 = await (deps.stopRemoteExternal ?? stopRemoteExternalCodingAgent)({
-            agentId: child?.agentId,
-            parentScope: {
-              agentId: task2.runtimeScope.agentId,
-              conversationId: task2.runtimeScope.conversationId,
-              actingUserId: task2.actingUserId
-            }
-          });
-          remote = {
-            killed: result3.stopped,
-            output: result3.stopped ? "Stopped the remote external subagent" : "The remote external subagent was not running"
-          };
-        } catch (error5) {
-          remote = {
-            killed: false,
-            output: `Couldn't stop the remote external subagent: ${getErrorMessage2(error5)}`
-          };
-        }
-      } else if (task2.remote) {
-        remote = await cancelRemoteRun(task2.subagentId);
-      }
-      if (remote && !remote.killed)
-        return remote;
-      task2.abortController.abort();
-      task2.error = "Aborted by user";
-      await task2.completion;
-      task2.status = "failed";
-      scheduleBackgroundTaskCleanup(task_id);
-      return remote ?? { killed: true };
-    }
-    return { killed: false };
-  }
-  return { killed: killBackgroundProcess(task_id) };
-}
-var init_task_stop = __esm(async () => {
-  init_subagent_state();
-  init_backend2();
-  init_external_coding_agent();
-  init_process_manager();
-  init_remote_external_coding_agent();
-  await init_kill_bash();
-});
-
 // src/tools/impl/task-update.ts
 function validateStringArray(value, paramName) {
   if (value === undefined)
@@ -251580,6 +251869,8 @@ ${describeGitHubPullRequestSnapshot(initial2)}
   const controller = new AbortController;
   const secrets2 = {};
   let processState;
+  const persistent = !isManagedCloudRuntime();
+  let timeout;
   const events = createMonitorEventStream({
     emit(event) {
       queueMonitorEvent({
@@ -251618,6 +251909,7 @@ ${describeGitHubPullRequestSnapshot(initial2)}
   processState = {
     process: {
       kill() {
+        clearTimeout(timeout);
         events.cancel();
         controller.abort();
       }
@@ -251632,11 +251924,29 @@ ${describeGitHubPullRequestSnapshot(initial2)}
     kind: "monitor",
     description,
     monitorSource: "github_pull_request",
-    persistent: true,
+    persistent,
     secrets: secrets2
   };
   backgroundProcesses.set(taskId, processState);
   notifyBackgroundProcessStateChanged(scope);
+  if (!persistent) {
+    timeout = setTimeout(() => {
+      if (processState.status !== "running")
+        return;
+      events.finish();
+      if (processState.status !== "running")
+        return;
+      const event = getMonitorTimeoutEvent(MONITOR_MAX_TIMEOUT_MS);
+      output.append(`
+${event}
+`);
+      queueMonitorEvent({ taskId, event, scope, actingUserId, secrets: secrets2 });
+      processState.completionNotificationSuppressed = true;
+      markMonitorFinished(taskId, processState, "failed", null);
+      processState.process.kill();
+    }, MONITOR_MAX_TIMEOUT_MS);
+    unrefTimer(timeout);
+  }
   const wait = deps.wait ?? defaultWait;
   (async () => {
     let previous = initial2;
@@ -251700,12 +252010,12 @@ ${describeGitHubPullRequestSnapshot(initial2)}
     if (processState.status === "running") {
       markMonitorFinished(taskId, processState, "failed", null);
     }
-  });
+  }).finally(() => clearTimeout(timeout));
   return {
     content: [
       {
         type: "text",
-        text: `WatchPR started (task ${taskId}). It will keep watching after CI finishes and report new failures, reviews, comments, conflicts, head changes, merge-state changes, and watcher errors. It stops when the PR merges/closes, on TaskStop, or when this session ends.
+        text: `WatchPR started (task ${taskId}). It will keep watching after CI finishes and report new failures, reviews, comments, conflicts, head changes, merge-state changes, and watcher errors. It stops when the PR merges/closes, on TaskStop, or when this session ends.${persistent ? "" : " A hard 1-hour limit applies in this Cloud sandbox; use Wake or cron for later checks."}
 
 Current state:
 ${describeGitHubPullRequestSnapshot(initial2)}
@@ -251716,7 +252026,7 @@ Output file: ${outputFile}`
     taskId,
     url: ref5.url,
     headSha: initial2.headSha,
-    persistent: true
+    persistent
   };
 }
 var WATCH_POLL_MS = 30000, WATCH_MAX_POLL_MS;
@@ -251874,6 +252184,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 +252455,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 +252486,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 +252614,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();
@@ -252336,10 +252692,12 @@ async function createSdkSpawnerHandle(args, setStage = () => {}) {
     });
     throw error5;
   }
-  const toolScope = await createScriptToolScope(parentAgentId);
+  const backgroundStopController = args.wait ? undefined : new AbortController;
+  const toolScope = await createScriptToolScope(parentAgentId, args.wait ? args.signal : backgroundStopController?.signal);
   return {
     spawner,
     ...toolScope,
+    backgroundStopController,
     cleanup: async () => {
       await toolScope.cleanup();
       await client[Symbol.asyncDispose]?.().catch(() => {
@@ -252399,6 +252757,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),
@@ -252544,7 +252910,7 @@ async function workflow(args) {
   const taskId = getNextWorkflowId();
   const outputFile = createBackgroundOutputFile(taskId);
   const scope = resolveNotificationScope(args.parentScope);
-  const abortController = new AbortController;
+  const abortController = handle2.backgroundStopController ?? new AbortController;
   const processState = {
     process: {
       kill() {
@@ -252590,7 +252956,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}
@@ -253153,7 +253519,7 @@ var init_Monitor2 = __esm(() => {
       persistent: {
         type: "boolean",
         default: false,
-        description: "Run for the lifetime of the session (no timeout). Use for session-length watches like PR monitoring or log tails. Stop with TaskStop."
+        description: "Run until TaskStop or session end. In managed Cloud sandboxes, a hard 1-hour limit still applies; elsewhere there is no timeout. For longer waits in Cloud, use Wake/cron rather than keeping a monitor running."
       },
       backup_after_seconds: {
         type: "integer",
@@ -254316,7 +254682,7 @@ import {
   readFileSync as readFileSync38,
   renameSync as renameSync10,
   rmSync as rmSync18,
-  statSync as statSync18,
+  statSync as statSync19,
   writeFileSync as writeFileSync29
 } from "node:fs";
 import { join as join71 } from "node:path";
@@ -254635,11 +255001,11 @@ function createRecoveryLineageSidecarAccess(params) {
               ownerIsAlive = error5.code !== "ESRCH";
             }
           }
-          const ageMs = Date.now() - statSync18(join71(params.directory, file)).mtimeMs;
+          const ageMs = Date.now() - statSync19(join71(params.directory, file)).mtimeMs;
           if (!ownerIsCurrentWriter && (!ownerIsAlive && ageMs >= staleTemporaryAgeMs || ageMs >= maximumTemporaryAgeMs)) {
             const release = acquireDurableFileLock(join71(params.directory, mainFile), { waitMs: params.lockWaitMs });
             try {
-              const currentAgeMs = Date.now() - statSync18(join71(params.directory, file)).mtimeMs;
+              const currentAgeMs = Date.now() - statSync19(join71(params.directory, file)).mtimeMs;
               if (!ownerIsCurrentWriter && (!ownerIsAlive && currentAgeMs >= staleTemporaryAgeMs || currentAgeMs >= maximumTemporaryAgeMs)) {
                 rmSync18(join71(params.directory, file), { force: true });
                 params.syncDirectory(params.directory);
@@ -257131,7 +257497,7 @@ import {
   openSync as openSync7,
   readFileSync as readFileSync40,
   renameSync as renameSync11,
-  statSync as statSync19,
+  statSync as statSync20,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync31
 } from "node:fs";
@@ -257271,7 +257637,7 @@ function validateDurableStore(value) {
 function readDurableStore(path32) {
   if (!existsSync50(path32))
     return emptyDurableStore();
-  const size2 = statSync19(path32).size;
+  const size2 = statSync20(path32).size;
   if (size2 > MAX_INPUT_DISPOSITION_STORE_BYTES) {
     throw new Error("Accepted-input disposition store exceeds its size limit");
   }
@@ -261164,7 +261530,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 +261580,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 +263793,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 +263808,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 +264387,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 +264474,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 +264494,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 +264544,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 +264564,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;
@@ -264867,7 +265233,7 @@ function isBrowserDeviceMcpOAuthProtocolCommand(value) {
     return false;
   const record6 = value;
   if (record6.type === "browser_device_mcp_oauth") {
-    return Object.keys(record6).length === 6 && typeof record6.request_id === "string" && REQUEST_ID_PATTERN.test(record6.request_id) && typeof record6.handoff_key === "string" && HANDOFF_KEY_PATTERN2.test(record6.handoff_key) && typeof record6.service === "string" && SERVICE_PATTERN.test(record6.service) && typeof record6.server_url === "string" && record6.server_url.length > 0 && record6.server_url.length <= MAX_SERVER_URL_LENGTH && !hasControlCharacters(record6.server_url) && typeof record6.timeout_ms === "number" && Number.isSafeInteger(record6.timeout_ms) && record6.timeout_ms > 0 && record6.timeout_ms <= MAX_TIMEOUT_MS2;
+    return Object.keys(record6).length === 6 && typeof record6.request_id === "string" && REQUEST_ID_PATTERN.test(record6.request_id) && typeof record6.handoff_key === "string" && HANDOFF_KEY_PATTERN2.test(record6.handoff_key) && typeof record6.service === "string" && SERVICE_PATTERN.test(record6.service) && typeof record6.server_url === "string" && record6.server_url.length > 0 && record6.server_url.length <= MAX_SERVER_URL_LENGTH && !hasControlCharacters(record6.server_url) && typeof record6.timeout_ms === "number" && Number.isSafeInteger(record6.timeout_ms) && record6.timeout_ms > 0 && record6.timeout_ms <= MAX_TIMEOUT_MS;
   }
   return record6.type === "browser_device_mcp_oauth_cancel" && Object.keys(record6).length === 2 && typeof record6.operation_id === "string" && REQUEST_ID_PATTERN.test(record6.operation_id);
 }
@@ -264879,7 +265245,7 @@ function hasControlCharacters(value) {
   }
   return false;
 }
-var REQUEST_ID_PATTERN, HANDOFF_KEY_PATTERN2, SERVICE_PATTERN, MAX_SERVER_URL_LENGTH = 2048, MAX_TIMEOUT_MS2 = 285000;
+var REQUEST_ID_PATTERN, HANDOFF_KEY_PATTERN2, SERVICE_PATTERN, MAX_SERVER_URL_LENGTH = 2048, MAX_TIMEOUT_MS = 285000;
 var init_browser_device_mcp_oauth_protocol_inbound = __esm(() => {
   REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
   HANDOFF_KEY_PATTERN2 = /^[A-Za-z0-9_-]{43,128}$/;
@@ -266294,7 +266660,7 @@ __export(exports_memory_scanner, {
   readFileContent: () => readFileContent,
   getFileNodes: () => getFileNodes
 });
-import { readdirSync as readdirSync21, readFileSync as readFileSync42, statSync as statSync20 } from "node:fs";
+import { readdirSync as readdirSync21, readFileSync as readFileSync42, statSync as statSync21 } from "node:fs";
 import { join as join76, relative as relative7 } from "node:path";
 function scanMemoryFilesystem(memoryRoot) {
   const nodes = [];
@@ -266312,10 +266678,10 @@ function scanMemoryFilesystem(memoryRoot) {
       let aIsDir = false;
       let bIsDir = false;
       try {
-        aIsDir = statSync20(aPath).isDirectory();
+        aIsDir = statSync21(aPath).isDirectory();
       } catch {}
       try {
-        bIsDir = statSync20(bPath).isDirectory();
+        bIsDir = statSync21(bPath).isDirectory();
       } catch {}
       if (aIsDir !== bIsDir)
         return aIsDir ? -1 : 1;
@@ -266331,7 +266697,7 @@ function scanMemoryFilesystem(memoryRoot) {
       const fullPath = join76(dir, name);
       let isDir = false;
       try {
-        isDir = statSync20(fullPath).isDirectory();
+        isDir = statSync21(fullPath).isDirectory();
       } catch {
         return;
       }
@@ -266430,7 +266796,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
     const isMemfsEnabledOnServer2 = overrides.isMemfsEnabledOnServer ?? actualIsMemfsEnabledOnServer;
     const { scanMemoryFilesystem: scanMemoryFilesystem2, getFileNodes: getFileNodes2, readFileContent: readFileContent2 } = await Promise.resolve().then(() => (init_memory_scanner(), exports_memory_scanner));
     const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => exports_frontmatter);
-    const { existsSync: existsSync52, statSync: statSync21 } = await import("node:fs");
+    const { existsSync: existsSync52, statSync: statSync22 } = await import("node:fs");
     const { join: join77, posix: posix3 } = await import("node:path");
     const memoryRoot = getMemoryFilesystemRoot2(parsed.agent_id);
     let memfsInitialized = existsSync52(join77(memoryRoot, ".git"));
@@ -266527,7 +266893,7 @@ async function handleListMemoryCommand(parsed, socket, safeSocketSend, overrides
         if (imageMimeType) {
           let size2 = 0;
           try {
-            size2 = statSync21(node.fullPath).size;
+            size2 = statSync22(node.fullPath).size;
           } catch {}
           return {
             relative_path: node.relativePath,
@@ -266750,7 +267116,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 +267142,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 +276401,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile21,
+          readFile: readFile22,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -276076,7 +276442,7 @@ ${lanes.join(`
             return process.memoryUsage().heapUsed;
           },
           getFileSize(path35) {
-            const stat12 = statSync21(path35);
+            const stat12 = statSync22(path35);
             if (stat12 == null ? undefined : stat12.isFile()) {
               return stat12.size;
             }
@@ -276119,7 +276485,7 @@ ${lanes.join(`
           }
         };
         return nodeSystem;
-        function statSync21(path35) {
+        function statSync22(path35) {
           try {
             return _fs.statSync(path35, statSyncOptions);
           } catch {
@@ -276171,7 +276537,7 @@ ${lanes.join(`
             activeSession.post("Profiler.stop", (err, { profile }) => {
               var _a10;
               if (!err) {
-                if ((_a10 = statSync21(profilePath)) == null ? undefined : _a10.isDirectory()) {
+                if ((_a10 = statSync22(profilePath)) == null ? undefined : _a10.isDirectory()) {
                   profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                 }
                 try {
@@ -276228,7 +276594,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);
@@ -276280,7 +276646,7 @@ ${lanes.join(`
               let stat12;
               if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                 const name = combinePaths(path35, entry);
-                stat12 = statSync21(name);
+                stat12 = statSync22(name);
                 if (!stat12) {
                   continue;
                 }
@@ -276304,7 +276670,7 @@ ${lanes.join(`
           return matchFiles(path35, extensions, excludes, includes2, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath6);
         }
         function fileSystemEntryExists(path35, entryKind) {
-          const stat12 = statSync21(path35);
+          const stat12 = statSync22(path35);
           if (!stat12) {
             return false;
           }
@@ -276338,7 +276704,7 @@ ${lanes.join(`
         }
         function getModifiedTime3(path35) {
           var _a10;
-          return (_a10 = statSync21(path35)) == null ? undefined : _a10.mtime;
+          return (_a10 = statSync22(path35)) == null ? undefined : _a10.mtime;
         }
         function setModifiedTime(path35, time3) {
           try {
@@ -307175,7 +307541,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 +307579,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 +307682,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 +307751,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 +307762,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 +375199,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 +375995,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 +376171,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile21,
+        readFile: readFile22,
         directoryExists: directoryExists2,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -437813,7 +438179,7 @@ import {
   mkdirSync as mkdirSync42,
   readdirSync as readdirSync23,
   readFileSync as readFileSync46,
-  statSync as statSync21,
+  statSync as statSync22,
   unlinkSync as unlinkSync13,
   writeFileSync as writeFileSync36
 } from "node:fs";
@@ -438642,7 +439008,7 @@ async function loadLocalMods(options) {
         recordLegacyExtensionLoadedDiagnostic(registry4, owner, source, options.onDiagnostic);
       }
       try {
-        const mtimeMs = statSync21(modPath).mtimeMs;
+        const mtimeMs = statSync22(modPath).mtimeMs;
         const sourceText = readFileSync46(modPath, "utf8");
         recordDeprecatedContextApiSourceDiagnostics(sourceText, (diagnostic) => {
           recordModDiagnostic(registry4, {
@@ -443139,6 +443505,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 +447647,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 +447662,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 +447698,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 +448098,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 +452164,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 +452255,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 +452275,7 @@ var init_hermes = __esm(() => {
               ...timestamp ? { timestamp } : {}
             });
           }
-          const content = contentText3(row.content);
+          const content = contentText2(row.content);
           if (content) {
             emit({
               type: "message",
@@ -451840,7 +452298,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 } : {}
           });
@@ -453351,7 +453809,7 @@ var init_deepagents = __esm(() => {
 });
 
 // node_modules/@letta-ai/trajectory/dist/adapters/listing-shared.js
-import { readdirSync as readdirSync25, statSync as statSync22 } from "node:fs";
+import { readdirSync as readdirSync25, statSync as statSync23 } from "node:fs";
 import { join as join83 } from "node:path";
 function sortListings(items3) {
   return items3.sort((left, right) => {
@@ -453375,7 +453833,7 @@ function safeReadDir(path42) {
 }
 function safeStat(path42) {
   try {
-    const stats = statSync22(path42);
+    const stats = statSync23(path42);
     return { mtimeMs: stats.mtimeMs, sizeBytes: stats.size };
   } catch {
     return;
@@ -453832,7 +454290,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 +454343,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 +454361,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 +454409,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 +454712,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 +454785,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 +455117,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 +456826,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 +457650,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 +458063,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();
@@ -468684,7 +469112,7 @@ var init_memory_tokens = __esm(() => {
 });
 
 // src/cli/subcommands/memory.ts
-import { cpSync, existsSync as existsSync64, mkdirSync as mkdirSync46, rmSync as rmSync22, statSync as statSync23 } from "node:fs";
+import { cpSync, existsSync as existsSync64, mkdirSync as mkdirSync46, rmSync as rmSync22, statSync as statSync24 } from "node:fs";
 import { readdir as readdir12 } from "node:fs/promises";
 import { dirname as dirname35, join as join94 } from "node:path";
 import { parseArgs as parseArgs11 } from "node:util";
@@ -468759,7 +469187,7 @@ async function listBackups(agentId) {
     const path46 = join94(agentRoot, entry.name);
     let createdAt = null;
     try {
-      const stat15 = statSync23(path46);
+      const stat15 = statSync24(path46);
       createdAt = stat15.mtime.toISOString();
     } catch {
       createdAt = null;
@@ -468886,7 +469314,7 @@ async function runMemorySubcommand(argv, deps = {}) {
         console.error(`Backup not found: ${backupPath}`);
         return 1;
       }
-      const stat15 = statSync23(backupPath);
+      const stat15 = statSync24(backupPath);
       if (!stat15.isDirectory()) {
         console.error(`Backup path is not a directory: ${backupPath}`);
         return 1;
@@ -468909,7 +469337,7 @@ async function runMemorySubcommand(argv, deps = {}) {
         return 1;
       }
       if (existsSync64(out)) {
-        const stat15 = statSync23(out);
+        const stat15 = statSync24(out);
         if (stat15.isDirectory()) {
           const contents = await readdir12(out);
           if (contents.length > 0) {
@@ -468957,7 +469385,7 @@ var init_memory7 = __esm(() => {
 });
 
 // src/backend/local/transcript-search.ts
-import { existsSync as existsSync65, readdirSync as readdirSync27, readFileSync as readFileSync48, statSync as statSync24 } from "node:fs";
+import { existsSync as existsSync65, readdirSync as readdirSync27, readFileSync as readFileSync48, statSync as statSync25 } from "node:fs";
 import { join as join95 } from "node:path";
 function readJsonFile3(path46) {
   if (!existsSync65(path46))
@@ -469245,7 +469673,7 @@ function conversationDirectories(storageDir) {
   if (!existsSync65(conversationsDir))
     return [];
   try {
-    return readdirSync27(conversationsDir).map((entry) => join95(conversationsDir, entry)).filter((entryPath) => statSync24(entryPath).isDirectory());
+    return readdirSync27(conversationsDir).map((entry) => join95(conversationsDir, entry)).filter((entryPath) => statSync25(entryPath).isDirectory());
   } catch {
     return [];
   }
@@ -474459,7 +474887,7 @@ import {
   mkdtempSync as mkdtempSync6,
   readFileSync as readFileSync50,
   rmSync as rmSync25,
-  statSync as statSync25,
+  statSync as statSync26,
   writeFileSync as writeFileSync41
 } from "node:fs";
 import { mkdir as mkdir16, readdir as readdir13 } from "node:fs/promises";
@@ -474917,7 +475345,7 @@ async function installSkillDirectory(params) {
   if (!existsSync69(skillMdPath)) {
     throw new Error("No SKILL.md found in the skill directory.");
   }
-  if (!statSync25(sourceDir).isDirectory()) {
+  if (!statSync26(sourceDir).isDirectory()) {
     throw new Error(`Skill source is not a directory: ${sourceDir}`);
   }
   const name = getSkillName(sourceDir);
@@ -474976,7 +475404,7 @@ async function deleteSkillDirectory(params) {
   if (!existsSync69(targetPath)) {
     throw new Error(`Skill "${name}" is not installed at ${targetPath}.`);
   }
-  if (!statSync25(targetPath).isDirectory()) {
+  if (!statSync26(targetPath).isDirectory()) {
     throw new Error(`Skill path is not a directory: ${targetPath}`);
   }
   rmSync25(targetPath, { recursive: true, force: true });
@@ -476874,7 +477302,7 @@ function firstDefinedBoolean(...values4) {
 }
 function normalizeChatTarget(channel, value) {
   const trimmed = value.trim();
-  if (channel === "signal")
+  if (channel === "signal" || channel === "microsoftteams")
     return trimmed;
   const parts = trimmed.split(":").map((part) => part.trim()).filter(Boolean);
   if (parts.length === 2 && /^[a-z_-]+$/i.test(parts[0] ?? "")) {
@@ -482031,88 +482459,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 +482490,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 +483287,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 +483449,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 +483576,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 +483601,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 +483609,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 +483693,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 +483749,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 +483891,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 +483951,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 +484011,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 +484030,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()
       },
@@ -484403,6 +484768,9 @@ Current session AGENT_ID=${process.env.AGENT_ID}; --backend local switches to a
       await exitHeadless(1, "headless_stop_reason_error");
     }
   } catch (error5) {
+    if (sigintSignal.aborted) {
+      await exitInterrupted();
+    }
     markIncompleteToolsAsCancelled(buffers, true, "stream_error");
     const errorDetails = formatErrorDetails2(error5, agent.id);
     trackHeadlessBoundaryError("headless_runtime_exception", error5, "headless_turn_execution");
@@ -484817,6 +485185,30 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
       lineResolver = resolve42;
     });
   }
+  const EXTERNAL_TOOL_WAIT_ABORTED = Symbol("externalToolWaitAborted");
+  async function getNextLineOrAbort(signal) {
+    if (signal?.aborted)
+      return EXTERNAL_TOOL_WAIT_ABORTED;
+    if (lineQueue.length > 0)
+      return lineQueue.shift() ?? null;
+    if (!signal)
+      return getNextLine();
+    return new Promise((resolve42) => {
+      const cleanup = () => signal.removeEventListener("abort", onAbort);
+      const onAbort = () => {
+        cleanup();
+        if (lineResolver === settle3)
+          lineResolver = null;
+        resolve42(EXTERNAL_TOOL_WAIT_ABORTED);
+      };
+      const settle3 = (line) => {
+        cleanup();
+        resolve42(line);
+      };
+      signal.addEventListener("abort", onAbort);
+      lineResolver = settle3;
+    });
+  }
   async function requestPermission(toolCallId, toolName2, toolInput) {
     const requestId = `perm-${toolCallId}`;
     const diffs = await computeDiffPreviews(toolName2, toolInput);
@@ -484977,7 +485369,14 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
         const toolsRequest = message2.request;
         const tools = toolsRequest.tools ?? [];
         registerExternalTools(tools);
-        setExternalToolExecutor(async (toolCallId, toolName2, input) => {
+        setExternalToolExecutor(async (toolCallId, toolName2, input, context3) => {
+          const signal = context3?.signal;
+          if (signal?.aborted) {
+            return {
+              content: [{ type: "text", text: INTERRUPTED_BY_USER }],
+              isError: true
+            };
+          }
           const execRequest = {
             type: "control_request",
             request_id: `ext-${toolCallId}`,
@@ -484989,25 +485388,48 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
             }
           };
           writeWireMessage(execRequest);
-          while (true) {
-            const line2 = await getNextLine();
-            if (line2 === null) {
-              return {
-                content: [{ type: "text", text: "stdin closed" }],
-                isError: true
-              };
-            }
-            if (!line2.trim())
-              continue;
-            try {
-              const msg = JSON.parse(line2);
-              if (msg.type === "control_response" && msg.response?.subtype === "external_tool_result" && msg.response?.tool_call_id === toolCallId) {
+          const deferredLines = [];
+          try {
+            while (true) {
+              const line2 = await getNextLineOrAbort(signal);
+              if (line2 === EXTERNAL_TOOL_WAIT_ABORTED) {
                 return {
-                  content: msg.response.content ?? [{ type: "text", text: "" }],
-                  isError: msg.response.is_error ?? false
+                  content: [{ type: "text", text: INTERRUPTED_BY_USER }],
+                  isError: true
                 };
               }
-            } catch {}
+              if (line2 === null) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: currentAbortController?.signal.aborted ? INTERRUPTED_BY_USER : "stdin closed"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              if (!line2.trim())
+                continue;
+              try {
+                const msg = JSON.parse(line2);
+                if (msg.type === "control_response" && msg.response?.subtype === "external_tool_result") {
+                  if (msg.response.tool_call_id === toolCallId) {
+                    return {
+                      content: msg.response.content ?? [
+                        { type: "text", text: "" }
+                      ],
+                      isError: msg.response.is_error ?? false
+                    };
+                  }
+                  continue;
+                }
+              } catch {}
+              deferredLines.push(line2);
+            }
+          } finally {
+            if (deferredLines.length > 0)
+              lineQueue.unshift(...deferredLines);
           }
         });
         const registerResponse = {
@@ -485427,10 +485849,18 @@ async function runBidirectionalMode(agent, conversationId, effectiveModel, _outp
               }
               const { executeApprovalBatch: executeApprovalBatch2 } = await init_approval_execution().then(() => exports_approval_execution);
               emitLocalToolCalls(decisions, sessionId);
-              const executedResults = await executeApprovalBatch2(decisions, undefined, {
-                toolContextId: turnToolContextId ?? undefined,
-                abortSignal: currentAbortController.signal
-              });
+              let executedResults;
+              try {
+                executedResults = await executeApprovalBatch2(decisions, undefined, {
+                  toolContextId: turnToolContextId ?? undefined,
+                  abortSignal: currentAbortController.signal
+                });
+              } catch (error5) {
+                if (currentAbortController?.signal.aborted) {
+                  break;
+                }
+                throw error5;
+              }
               emitLocalToolReturns(executedResults, sessionId);
               currentInput = responseState.prepare(executedResults, needsUserInput.length === 0);
               continue;
@@ -485548,6 +485978,7 @@ var LLM_API_ERROR_MAX_RETRIES2 = 3, EMPTY_RESPONSE_MAX_RETRIES2 = 2, HEADLESS_ST
 var init_headless = __esm(async () => {
   init_error();
   init_preloaded_skills();
+  init_constants2();
   init_headless_message_sender();
   init_headless_response_state();
   init_headless_startup_backend();
@@ -497505,7 +497936,6 @@ var init_SlashCommandAutocomplete = __esm(async () => {
     "creating-skills",
     "customizing-statusline",
     "initializing-memory",
-    "migrating-memory",
     "syncing-memory-filesystem"
   ]);
   _allCommands = Object.entries(commands).filter(([, { hidden }]) => !hidden).map(([cmd, { desc, order }]) => ({
@@ -498502,6 +498932,7 @@ function Input({
   queueMode = "immediate",
   deferModeSupported = false,
   interruptRequested = false,
+  hasStopFailedTasks = false,
   agentId,
   agentName,
   currentModel,
@@ -498801,7 +499232,7 @@ function Input({
         onBashInterrupt();
         return;
       }
-      if ((streaming3 || interruptRequested) && onInterrupt) {
+      if ((streaming3 || interruptRequested || hasStopFailedTasks) && onInterrupt) {
         onInterrupt();
         return;
       }
@@ -514807,6 +515238,7 @@ function AppView(props) {
     inputEnabled,
     inputVisible,
     interruptRequested,
+    hasStopFailedTasks,
     isAgentBusy,
     liveItems,
     liveTrajectoryElapsedBaseMs,
@@ -515035,6 +515467,7 @@ function AppView(props) {
                   queueMode,
                   deferModeSupported,
                   interruptRequested,
+                  hasStopFailedTasks,
                   agentId,
                   agentName,
                   currentModel: currentModelDisplay,
@@ -516193,6 +516626,12 @@ function useApprovalFlow(ctx) {
     startupApprovals
   ]);
   const sendAllResults = import_react113.useCallback(async (additionalDecision) => {
+    const approvalAbortController = new AbortController;
+    const approvalResultsSnapshot = [...approvalResults];
+    const autoHandledSnapshot = [...autoHandledResults];
+    const autoDeniedSnapshot = [...autoDeniedApprovals];
+    const pendingSnapshot = [...pendingApprovals];
+    const companionResults = buildCompanionResults(autoHandledSnapshot, autoDeniedSnapshot);
     try {
       if (userCancelledRef.current || abortControllerRef.current?.signal.aborted) {
         setStreaming(false);
@@ -516202,12 +516641,13 @@ function useApprovalFlow(ctx) {
         setApprovalResults([]);
         setAutoHandledResults([]);
         setAutoDeniedApprovals([]);
+        clearApprovalToolContext();
+        toolAbortControllerRef.current = null;
+        executingToolCallIdsRef.current = [];
+        interruptQueuedRef.current = false;
+        toolResultsInFlightRef.current = false;
         return;
       }
-      const approvalResultsSnapshot = [...approvalResults];
-      const autoHandledSnapshot = [...autoHandledResults];
-      const autoDeniedSnapshot = [...autoDeniedApprovals];
-      const pendingSnapshot = [...pendingApprovals];
       setPendingApprovals([]);
       setApprovalContexts([]);
       setApprovalResults([]);
@@ -516216,7 +516656,6 @@ function useApprovalFlow(ctx) {
       setStreaming(true);
       openTrajectorySegment();
       buffersRef.current.interrupted = false;
-      const approvalAbortController = new AbortController;
       toolAbortControllerRef.current = approvalAbortController;
       const allDecisions = [
         ...approvalResultsSnapshot,
@@ -516258,23 +516697,10 @@ function useApprovalFlow(ctx) {
           localToolMs: toolRunMs
         });
       }
-      const allResults = [
-        ...autoHandledSnapshot.map((ar) => ({
-          type: "tool",
-          tool_call_id: ar.toolCallId,
-          tool_return: ar.result.toolReturn,
-          status: ar.result.status,
-          stdout: ar.result.stdout,
-          stderr: ar.result.stderr
-        })),
-        ...autoDeniedSnapshot.map((ad) => ({
-          type: "approval",
-          tool_call_id: ad.approval.toolCallId,
-          approve: false,
-          reason: ad.reason
-        })),
-        ...executedResults
-      ];
+      if (toolAbortControllerRef.current !== approvalAbortController) {
+        return;
+      }
+      const allResults = [...companionResults, ...executedResults];
       if (true) {
         const expectedIds = new Set([
           ...autoHandledSnapshot.map((ar) => ar.toolCallId),
@@ -516293,9 +516719,7 @@ function useApprovalFlow(ctx) {
       const wasAborted = approvalAbortController.signal.aborted;
       const userCancelled = userCancelledRef.current;
       if (wasAborted || userCancelled) {
-        if (!interruptQueuedRef.current) {
-          queueApprovalResults(allResults);
-        }
+        queueApprovalResults(allResults);
         setStreaming(false);
         closeTrajectorySegment();
         syncTrajectoryElapsedBase();
@@ -516316,6 +516740,24 @@ function useApprovalFlow(ctx) {
         queueApprovalResults(null);
       }
     } catch (error5) {
+      if (toolAbortControllerRef.current !== approvalAbortController) {
+        return;
+      }
+      if (isUserAbortError(error5)) {
+        markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
+        const merged = overlayPartialResults(queuedApprovalResultsRef.current, [
+          ...error5.partialResults ?? [],
+          ...companionResults
+        ]);
+        if (merged.length > 0) {
+          queueApprovalResults(merged);
+        }
+        setStreaming(false);
+        closeTrajectorySegment();
+        syncTrajectoryElapsedBase();
+        refreshDerived();
+        return;
+      }
       markIncompleteToolsAsCancelled(buffersRef.current, true, "stream_error");
       const errorDetails = formatErrorDetails2(error5, agentId);
       appendError(errorDetails, {
@@ -516327,12 +516769,14 @@ function useApprovalFlow(ctx) {
       syncTrajectoryElapsedBase();
       refreshDerived();
     } finally {
-      clearApprovalToolContext();
-      setIsExecutingTool(false);
-      toolAbortControllerRef.current = null;
-      executingToolCallIdsRef.current = [];
-      interruptQueuedRef.current = false;
-      toolResultsInFlightRef.current = false;
+      if (toolAbortControllerRef.current === approvalAbortController) {
+        clearApprovalToolContext();
+        setIsExecutingTool(false);
+        toolAbortControllerRef.current = null;
+        executingToolCallIdsRef.current = [];
+        interruptQueuedRef.current = false;
+        toolResultsInFlightRef.current = false;
+      }
     }
   }, [
     agentId,
@@ -516660,7 +517104,10 @@ var init_use_approval_flow = __esm(async () => {
   init_debug();
   init_notifications();
   init_turn_input();
-  await init_manager2();
+  await __promiseAll([
+    init_approval_execution(),
+    init_manager2()
+  ]);
   import_react113 = __toESM(require_react(), 1);
 });
 
@@ -517959,6 +518406,7 @@ function useConversationLoop(ctx) {
     precomputedDiffsRef,
     prepareScopedToolExecutionContext,
     processingConversationRef,
+    queuedApprovalResultsRef,
     queueApprovalResults,
     queueSnapshotRef,
     quotaAutoSwapAttemptedRef,
@@ -518856,7 +519304,11 @@ ${feedback}
           const autoAllowedAbortController = abortControllerRef.current ?? new AbortController;
           const shouldTrackAutoAllowed = autoAllowedToolCallIds.length > 0;
           let autoAllowedResults = [];
-          let autoDeniedResults = [];
+          const autoDeniedResults = autoDenied.map((ac) => ({
+            approval: ac.approval,
+            reason: formatPermissionDenial(ac.permission)
+          }));
+          const prebuiltDeniedApprovalResults = buildDeniedResults(autoDeniedResults);
           if (shouldTrackAutoAllowed) {
             setIsExecutingTool(true);
             executingToolCallIdsRef.current = autoAllowedToolCallIds;
@@ -518873,29 +519325,35 @@ ${feedback}
               setToolCallsRunning(buffersRef.current, autoAllowedToolCallIds);
               refreshDerived();
             }
-            const approvalToolContextId = approvalToolContextIdRef.current ?? (await prepareScopedToolExecutionContext(tempModelOverrideRef.current ?? undefined)).preparedToolContext.contextId;
-            autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk2) => onChunk(buffersRef.current, chunk2), {
-              abortSignal: autoAllowedAbortController.signal,
-              onStreamingOutput: updateStreamingOutput,
-              toolContextId: approvalToolContextId
-            }) : [];
-            autoDeniedResults = autoDenied.map((ac) => {
-              const reason = formatPermissionDenial(ac.permission);
+            try {
+              const approvalToolContextId = approvalToolContextIdRef.current ?? (await prepareScopedToolExecutionContext(tempModelOverrideRef.current ?? undefined)).preparedToolContext.contextId;
+              autoAllowedResults = autoAllowed.length > 0 ? await executeAutoAllowedTools(autoAllowed, (chunk2) => onChunk(buffersRef.current, chunk2), {
+                abortSignal: autoAllowedAbortController.signal,
+                onStreamingOutput: updateStreamingOutput,
+                toolContextId: approvalToolContextId
+              }) : [];
+            } catch (error5) {
+              if (shouldTrackAutoAllowed && toolAbortControllerRef.current !== autoAllowedAbortController) {
+                return;
+              }
+              appendAbortPartials(error5, prebuiltDeniedApprovalResults);
+              throw error5;
+            }
+            if (shouldTrackAutoAllowed && toolAbortControllerRef.current !== autoAllowedAbortController) {
+              return;
+            }
+            for (const ad of autoDeniedResults) {
               onChunk(buffersRef.current, {
                 message_type: "tool_return_message",
                 id: "dummy",
                 date: new Date().toISOString(),
-                tool_call_id: ac.approval.toolCallId,
-                tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+                tool_call_id: ad.approval.toolCallId,
+                tool_return: `Error: request to call tool denied. User reason: ${ad.reason}`,
                 status: "error",
                 stdout: null,
                 stderr: null
               });
-              return {
-                approval: ac.approval,
-                reason
-              };
-            });
+            }
             const allResults = [
               ...autoAllowedResults.map((ar) => ({
                 type: "tool",
@@ -518905,12 +519363,7 @@ ${feedback}
                 stdout: ar.result.stdout,
                 stderr: ar.result.stderr
               })),
-              ...autoDeniedResults.map((ad) => ({
-                type: "approval",
-                tool_call_id: ad.approval.toolCallId,
-                approve: false,
-                reason: ad.reason
-              }))
+              ...prebuiltDeniedApprovalResults
             ];
             if (autoAllowedExecutionRef.current) {
               autoAllowedExecutionRef.current.results = allResults;
@@ -519008,7 +519461,7 @@ ${feedback}
               return;
             }
           } finally {
-            if (shouldTrackAutoAllowed) {
+            if (shouldTrackAutoAllowed && toolAbortControllerRef.current === autoAllowedAbortController) {
               setIsExecutingTool(false);
               toolAbortControllerRef.current = null;
               executingToolCallIdsRef.current = [];
@@ -519342,8 +519795,16 @@ ${feedback}
       }
     } catch (e2) {
       debugWarn("message_stream", "Unhandled conversation error: %s", e2 instanceof Error ? e2.stack ?? e2.message : String(e2));
-      markIncompleteToolsAsCancelled(buffersRef.current, true, e2 instanceof APIUserAbortError ? "user_interrupt" : "stream_error");
-      if (EAGER_CANCEL && e2 instanceof APIUserAbortError) {
+      if (abortControllerRef.current !== turnAbortController) {
+        return;
+      }
+      markIncompleteToolsAsCancelled(buffersRef.current, true, isUserAbortError(e2) ? "user_interrupt" : "stream_error");
+      if (EAGER_CANCEL && isUserAbortError(e2)) {
+        const partials = e2.partialResults;
+        const overlaid = partials ? overlayPartialResults(queuedApprovalResultsRef.current, partials) : [];
+        if (overlaid.length > 0) {
+          queueApprovalResults(overlaid);
+        }
         setStreaming(false);
         refreshDerived();
         return;
@@ -520102,18 +520563,23 @@ var init_use_feedback_handler = __esm(() => {
 });
 
 // src/cli/app/use-interrupt-handler.ts
-function hasActiveReflectionSubagentForAgent(agentId) {
+function hasActiveReflectionSubagentForAgent(agentId, conversationId) {
   return getSubagents().some((agent) => {
     if (agent.type.toLowerCase() !== "reflection")
       return false;
     if (agent.status !== "pending" && agent.status !== "running")
       return false;
-    return agent.parentAgentId === agentId;
+    if (agent.parentAgentId !== agentId)
+      return false;
+    return conversationId === undefined || agent.parentConversationId === undefined || agent.parentConversationId === conversationId;
   });
 }
-function interruptSubagentsAndReleaseReflection(agentId) {
-  const interruptedReflection = hasActiveReflectionSubagentForAgent(agentId);
-  interruptActiveSubagents(INTERRUPTED_BY_USER);
+function interruptSubagentsAndReleaseReflection(agentId, conversationId) {
+  const interruptedReflection = hasActiveReflectionSubagentForAgent(agentId, conversationId);
+  interruptActiveSubagents(INTERRUPTED_BY_USER, {
+    agentId,
+    conversationId
+  });
   if (interruptedReflection) {
     releaseReflectionLaunch(agentId);
   }
@@ -520215,7 +520681,7 @@ function useInterruptHandler(ctx) {
       autoAllowedExecutionRef.current = null;
       buffersRef.current.abortGeneration = (buffersRef.current.abortGeneration || 0) + 1;
       const toolsCancelled = markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
-      interruptSubagentsAndReleaseReflection(agentId);
+      interruptSubagentsAndReleaseReflection(agentId, conversationIdRef.current);
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
       }
@@ -520245,6 +520711,16 @@ function useInterruptHandler(ctx) {
           bumpDequeueEpoch: () => setDequeueEpoch((e2) => e2 + 1)
         });
       }
+      const retried = interruptStopFailedSubagents(INTERRUPTED_BY_USER, {
+        agentId,
+        conversationId: conversationIdRef.current
+      });
+      if (retried.length > 0) {
+        if (retried.some((id2) => getSubagents().find((agent) => agent.id === id2)?.type.toLowerCase() === "reflection")) {
+          releaseReflectionLaunch(agentId);
+        }
+        appendError("Retrying stop of background task...", true);
+      }
       return;
     }
     if (waitingForQueueCancelRef.current) {
@@ -520255,7 +520731,7 @@ function useInterruptHandler(ctx) {
       setInterruptRequested(true);
       buffersRef.current.abortGeneration = (buffersRef.current.abortGeneration || 0) + 1;
       const toolsCancelled = markIncompleteToolsAsCancelled(buffersRef.current, true, "user_interrupt");
-      interruptSubagentsAndReleaseReflection(agentId);
+      interruptSubagentsAndReleaseReflection(agentId, conversationIdRef.current);
       abortControllerRef.current?.abort();
       pendingInterruptRecoveryConversationIdRef.current = conversationIdRef.current;
       userCancelledRef.current = true;
@@ -529520,6 +529996,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     precomputedDiffsRef,
     prepareScopedToolExecutionContext,
     processingConversationRef,
+    queuedApprovalResultsRef,
     queueApprovalResults,
     queueSnapshotRef,
     quotaAutoSwapAttemptedRef,
@@ -530276,6 +530753,18 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
     deferredCommitAt
   ]);
   const { agents: subagents } = import_react123.useSyncExternalStore(subscribe2, getSnapshot2);
+  const hasStopFailedTasks = hasStopFailedSubagents({
+    agentId,
+    conversationId
+  });
+  const stopFailedNotifiedRef = import_react123.useRef(new Set);
+  import_react123.useEffect(() => {
+    const { failures, stops } = selectStopFailedNotifications(subagents, stopFailedNotifiedRef.current, { agentId, conversationId });
+    const messages = [...failures, ...stops];
+    if (messages.length > 0) {
+      appendTaskNotificationEvents(messages);
+    }
+  }, [subagents, conversationId, appendTaskNotificationEvents, agentId]);
   const estimatedLiveHeight = import_react123.useMemo(() => {
     const countLines4 = (text3) => {
       if (!text3)
@@ -530523,6 +531012,7 @@ Memory may be stale. Try running: git -C ${getScopedMemoryFilesystemRoot(agentId
         inputEnabled,
         inputVisible,
         interruptRequested: interruptRequested || !!abortControllerRef.current?.signal.aborted,
+        hasStopFailedTasks,
         isAgentBusy,
         liveItems,
         liveTrajectoryElapsedBaseMs,
@@ -534800,4 +535290,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=BF59442F8ED1752A64756E2164756E21
+//# debugId=9CD2133B459655FB64756E2164756E21