@letta-ai/letta-code 0.30.12 → 0.30.13

package/letta.js

@@ -5488,7 +5488,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.30.12",
+    version: "0.30.13",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -144036,7 +144036,7 @@ var general_purpose_default = `---
 name: general-purpose
 description: Full-capability agent for research, planning, and implementation
 tools: Bash, TaskOutput, Edit, KillBash, LS, MultiEdit, Read, TodoWrite, Write
-model: auto
+model: inherit
 ---
 
 You are a general-purpose coding agent that can research, plan, and implement.
@@ -149056,6 +149056,7 @@ var init_truncation = __esm(() => {
   LIMITS = {
     BASH_OUTPUT_CHARS: 30000,
     TASK_OUTPUT_CHARS: 30000,
+    BASH_NOTIFICATION_CHARS: 1e4,
     READ_MAX_LINES: 2000,
     READ_MAX_CHARS_PER_LINE: 2000,
     READ_OUTPUT_CHARS: 30000,
@@ -151006,6 +151007,131 @@ async function ask_user_question(args) {
 }
 var init_ask_user_question = () => {};
 
+// src/utils/message-queue-bridge.ts
+function setMessageQueueAdder(fn) {
+  queueAdder = fn;
+  if (queueAdder && pendingMessages.length > 0) {
+    for (const message of pendingMessages) {
+      queueAdder(message);
+    }
+    pendingMessages.length = 0;
+  }
+}
+function addToMessageQueue(message) {
+  if (queueAdder) {
+    queueAdder(message);
+    return;
+  }
+  if (pendingMessages.length >= MAX_PENDING_MESSAGES) {
+    pendingMessages.shift();
+  }
+  pendingMessages.push(message);
+}
+var queueAdder = null, pendingMessages, MAX_PENDING_MESSAGES = 10;
+var init_message_queue_bridge = __esm(() => {
+  pendingMessages = [];
+});
+
+// src/utils/task-notifications.ts
+function escapeXml(str2) {
+  return str2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function unescapeXml(str2) {
+  return str2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function resolveNotificationScope(parentScope) {
+  if (parentScope?.agentId) {
+    return {
+      agentId: parentScope.agentId,
+      conversationId: parentScope.conversationId || "default"
+    };
+  }
+  try {
+    return {
+      agentId: getCurrentAgentId(),
+      conversationId: getConversationId() ?? "default"
+    };
+  } catch {
+    return;
+  }
+}
+function formatTaskNotification(notification) {
+  const escapedSummary = escapeXml(notification.summary);
+  const escapedResult = escapeXml(notification.result);
+  const usageLines = [];
+  if (notification.usage?.totalTokens !== undefined) {
+    usageLines.push(`total_tokens: ${notification.usage.totalTokens}`);
+  }
+  if (notification.usage?.toolUses !== undefined) {
+    usageLines.push(`tool_uses: ${notification.usage.toolUses}`);
+  }
+  if (notification.usage?.durationMs !== undefined) {
+    usageLines.push(`duration_ms: ${notification.usage.durationMs}`);
+  }
+  const usageBlock = usageLines.length ? `
+<usage>${usageLines.join(`
+`)}</usage>` : "";
+  return `<task-notification>
+<task-id>${notification.taskId}</task-id>
+<status>${notification.status}</status>
+<summary>${escapedSummary}</summary>
+<result>${escapedResult}</result>${usageBlock}
+</task-notification>
+Full transcript available at: ${notification.outputFile}`;
+}
+function extractTaskNotificationsForDisplay(message) {
+  if (!message.includes("<task-notification>")) {
+    return { notifications: [], cleanedText: message };
+  }
+  const notificationRegex = /<task-notification>[\s\S]*?(?:<\/task-notification>|$)(?:\s*Full transcript available at:[^\n]*\n?)?/g;
+  const notifications = [];
+  let match2 = notificationRegex.exec(message);
+  while (match2 !== null) {
+    const xml = match2[0];
+    const summaryMatch = xml.match(/<summary>([\s\S]*?)<\/summary>/);
+    const statusMatch = xml.match(/<status>([\s\S]*?)<\/status>/);
+    const resultMatch = xml.match(/<result>([\s\S]*?)<\/result>/);
+    const result = resultMatch?.[1]?.trim() || "";
+    const isAgentOnlyReminder = result.includes(SYSTEM_REMINDER_OPEN);
+    if (isAgentOnlyReminder) {
+      match2 = notificationRegex.exec(message);
+      continue;
+    }
+    const status = statusMatch?.[1]?.trim();
+    let summary = summaryMatch?.[1]?.trim() || "";
+    summary = unescapeXml(summary);
+    const display = summary || `Agent task ${status || "completed"}`;
+    notifications.push(display);
+    match2 = notificationRegex.exec(message);
+  }
+  const cleanedText = message.replace(notificationRegex, "").replace(/^\s*Full transcript available at:[^\n]*\n?/gm, "").replace(/\n{3,}/g, `
+
+`).trim();
+  return { notifications, cleanedText };
+}
+function appendTaskNotificationEventsToBuffer(summaries, buffer, generateId, flush) {
+  if (summaries.length === 0)
+    return false;
+  for (const summary of summaries) {
+    const eventId = generateId();
+    buffer.byId.set(eventId, {
+      kind: "event",
+      id: eventId,
+      eventType: "task_notification",
+      eventData: {},
+      phase: "finished",
+      summary
+    });
+    buffer.order.push(eventId);
+  }
+  flush?.();
+  return true;
+}
+var init_task_notifications = __esm(() => {
+  init_context();
+  init_constants2();
+});
+
 // src/permissions/shell-analysis.ts
 function tryConsumeSafeRedirect(input, pos) {
   const isAppend = input.startsWith(">>", pos);
@@ -154260,6 +154386,197 @@ var init_shell_env = __esm(() => {
   init_ripgrep_manager();
 });
 
+// src/tools/impl/github-pull-request-tracker.ts
+function executableName(value) {
+  return value.replaceAll("\\", "/").split("/").pop()?.toLowerCase() ?? "";
+}
+function findExecutableIndex(tokens) {
+  let index = 0;
+  while (ENV_ASSIGNMENT.test(tokens[index] ?? "")) {
+    index += 1;
+  }
+  if (executableName(tokens[index] ?? "") === "env") {
+    index += 1;
+    while (index < tokens.length) {
+      const token = tokens[index] ?? "";
+      if (ENV_ASSIGNMENT.test(token)) {
+        index += 1;
+        continue;
+      }
+      if (token === "-u" || token === "--unset") {
+        index += 2;
+        continue;
+      }
+      if (token.startsWith("-")) {
+        index += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  while (ENV_ASSIGNMENT.test(tokens[index] ?? "")) {
+    index += 1;
+  }
+  if (tokens[index] === "command" || tokens[index] === "&") {
+    index += 1;
+  }
+  return index;
+}
+function skipGhGlobalFlags(tokens, startIndex) {
+  let index = startIndex;
+  while (index < tokens.length) {
+    const token = tokens[index] ?? "";
+    if (GH_GLOBAL_FLAGS_WITH_VALUES.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (token.startsWith("--hostname=") || token.startsWith("--repo=") || token.startsWith("-R") && token.length > 2) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+function tokensCreatePullRequest(tokens) {
+  const executableIndex = findExecutableIndex(tokens);
+  if (executableName(tokens[executableIndex] ?? "") !== "gh") {
+    return false;
+  }
+  const prIndex = skipGhGlobalFlags(tokens, executableIndex + 1);
+  if (tokens[prIndex] !== "pr" || tokens[prIndex + 1] !== "create") {
+    return false;
+  }
+  const createArgs = tokens.slice(prIndex + 2);
+  return !createArgs.some((token) => token === "--dry-run" || token === "--web" || token === "-w");
+}
+function isShellExecutable2(value) {
+  const name = executableName(value);
+  return /^(ba|z|a|da)?sh$/.test(name) || name === "cmd" || name === "cmd.exe" || name.includes("powershell") || name.includes("pwsh");
+}
+function shellScriptFromCommand(tokens) {
+  const executableIndex = findExecutableIndex(tokens);
+  if (!isShellExecutable2(tokens[executableIndex] ?? "")) {
+    return;
+  }
+  for (let index = executableIndex + 1;index < tokens.length; index += 1) {
+    const flag = (tokens[index] ?? "").toLowerCase();
+    if (flag === "-c" || flag === "-lc" || flag === "/c" || flag === "-command") {
+      return tokens[index + 1];
+    }
+  }
+  return;
+}
+function isGitHubPullRequestCreateCommand(command) {
+  if (typeof command !== "string") {
+    if (tokensCreatePullRequest(command)) {
+      return true;
+    }
+    const shellScript = shellScriptFromCommand(command);
+    return shellScript ? isGitHubPullRequestCreateCommand(shellScript) : false;
+  }
+  const segments = splitShellSegmentsAllowCommandSubstitution(command) ?? [
+    command
+  ];
+  return segments.some((segment) => tokensCreatePullRequest(tokenizeShellWords(segment)));
+}
+function tagFromOutputLine(line) {
+  const match2 = stripAnsi(line).trim().match(GITHUB_PR_URL);
+  if (!match2) {
+    return;
+  }
+  const [, owner, repo, number7] = match2;
+  if (!owner || !repo || !number7) {
+    return;
+  }
+  return `github:pull-request:${owner.toLowerCase()}:${repo.toLowerCase()}:${number7}`;
+}
+function appendOutputTail(outputByStream, text, stream11) {
+  outputByStream[stream11] = `${outputByStream[stream11]}${text}`.slice(-MAX_TRACKED_OUTPUT_CHARS);
+}
+async function appendConversationTags(backend, conversationId, tags) {
+  const conversation = await backend.retrieveConversation(conversationId);
+  const currentTags = typeof conversation === "object" && conversation !== null ? Reflect.get(conversation, "tags") : undefined;
+  const existingTags = Array.isArray(currentTags) ? currentTags.filter((tag) => typeof tag === "string") : [];
+  const missingTags = tags.filter((tag) => !existingTags.includes(tag));
+  if (missingTags.length === 0) {
+    return;
+  }
+  await backend.updateConversation(conversationId, {
+    tags: [...new Set([...existingTags, ...missingTags])]
+  });
+}
+function queueConversationTagUpdate(backend, conversationId, tags) {
+  const previous = conversationTagUpdateTails.get(conversationId);
+  const update2 = (previous ?? Promise.resolve()).then(() => appendConversationTags(backend, conversationId, tags)).catch((error54) => {
+    debugLog("github-pr-tracking", `Failed to tag conversation ${conversationId}`, error54);
+  });
+  conversationTagUpdateTails.set(conversationId, update2);
+  update2.finally(() => {
+    if (conversationTagUpdateTails.get(conversationId) === update2) {
+      conversationTagUpdateTails.delete(conversationId);
+    }
+  });
+  return update2;
+}
+function createGitHubPullRequestOutputTracker(command, options3) {
+  if (!isGitHubPullRequestCreateCommand(command)) {
+    return;
+  }
+  const conversationId = options3?.conversationId ?? getRuntimeContext()?.conversationId;
+  if (!conversationId || conversationId === "default") {
+    return;
+  }
+  const outputByStream = {
+    stdout: "",
+    stderr: ""
+  };
+  let finishPromise;
+  return {
+    append(text, stream11) {
+      if (finishPromise) {
+        return;
+      }
+      appendOutputTail(outputByStream, text, stream11);
+    },
+    finish() {
+      if (finishPromise) {
+        return finishPromise;
+      }
+      const tags = new Set;
+      for (const line of `${outputByStream.stdout}
+${outputByStream.stderr}`.split(/\r\n|\n|\r/)) {
+        const tag = tagFromOutputLine(line);
+        if (tag) {
+          tags.add(tag);
+        }
+      }
+      if (tags.size === 0) {
+        finishPromise = Promise.resolve();
+        return finishPromise;
+      }
+      try {
+        finishPromise = queueConversationTagUpdate(options3?.backend ?? getBackend(), conversationId, [...tags]);
+      } catch (error54) {
+        debugLog("github-pr-tracking", `Failed to tag conversation ${conversationId}`, error54);
+        finishPromise = Promise.resolve();
+      }
+      return finishPromise;
+    }
+  };
+}
+var ENV_ASSIGNMENT, GITHUB_PR_URL, MAX_TRACKED_OUTPUT_CHARS = 30000, GH_GLOBAL_FLAGS_WITH_VALUES, conversationTagUpdateTails;
+var init_github_pull_request_tracker = __esm(() => {
+  init_strip_ansi();
+  init_backend2();
+  init_runtime_context();
+  init_debug();
+  ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=.*/;
+  GITHUB_PR_URL = /^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/pull\/([1-9]\d*)\/?$/i;
+  GH_GLOBAL_FLAGS_WITH_VALUES = new Set(["--hostname", "--repo", "-R"]);
+  conversationTagUpdateTails = new Map;
+});
+
 // src/tools/impl/shell-runner.ts
 import { spawn as spawn2 } from "node:child_process";
 function buildSpawnError(err, executable, cwd) {
@@ -154281,145 +154598,293 @@ function buildSpawnError(err, executable, cwd) {
   execError.reason = reason;
   return execError;
 }
-function spawnWithLauncher(launcher, options3) {
-  return new Promise((resolve8, reject) => {
-    const [executable, ...args] = launcher;
-    if (!executable) {
-      reject(new ShellExecutionError("Executable is required"));
-      return;
+function buildTimeoutError(stdout, stderr, code2) {
+  return Object.assign(new Error("Command timed out"), {
+    killed: true,
+    signal: "SIGTERM",
+    stdout,
+    stderr,
+    code: code2
+  });
+}
+function buildAbortError(stdout, stderr) {
+  return Object.assign(new Error("The operation was aborted"), {
+    name: "AbortError",
+    code: "ABORT_ERR",
+    stdout,
+    stderr
+  });
+}
+function buildPtyEnv(env3) {
+  const ptyEnv = {};
+  for (const [key, value] of Object.entries(env3)) {
+    if (value !== undefined) {
+      ptyEnv[key] = value;
+    }
+  }
+  ptyEnv.TERM = ptyEnv.TERM || "xterm-256color";
+  ptyEnv.COLORTERM = ptyEnv.COLORTERM || "truecolor";
+  return ptyEnv;
+}
+function killChildProcessTree(childProcess, signal = "SIGTERM") {
+  if (!childProcess.pid) {
+    return;
+  }
+  if (process.platform === "win32") {
+    const taskkill = spawn2("taskkill.exe", ["/pid", String(childProcess.pid), "/t", "/f"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    taskkill.once("error", () => {
+      try {
+        childProcess.kill("SIGKILL");
+      } catch {}
+    });
+    taskkill.once("close", (code2) => {
+      if (code2 === 0)
+        return;
+      try {
+        childProcess.kill("SIGKILL");
+      } catch {}
+    });
+    return;
+  }
+  try {
+    process.kill(-childProcess.pid, signal);
+  } catch {
+    try {
+      childProcess.kill(signal);
+    } catch {}
+  }
+}
+function spawnPipeProcess(launcher, options3, events) {
+  const [executable, ...args] = launcher;
+  if (!executable) {
+    throw new ShellExecutionError("Executable is required");
+  }
+  const childProcess = spawn2(executable, args, {
+    cwd: options3.cwd,
+    env: options3.env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: process.platform !== "win32"
+  });
+  childProcess.stdout?.on("data", (chunk) => {
+    events.output(chunk, "stdout");
+  });
+  childProcess.stderr?.on("data", (chunk) => {
+    events.output(chunk, "stderr");
+  });
+  childProcess.on("error", events.error);
+  childProcess.on("close", events.close);
+  return {
+    kill(signal) {
+      killChildProcessTree(childProcess, signal);
+    },
+    write(_input) {}
+  };
+}
+function spawnPtyBridgeProcess(launcher, options3, events) {
+  const [executable, ...args] = launcher;
+  if (!executable) {
+    throw new ShellExecutionError("Executable is required");
+  }
+  const childProcess = spawn2("node", [
+    "-e",
+    NODE_PTY_BRIDGE_SCRIPT,
+    JSON.stringify({ executable, args, cwd: options3.cwd })
+  ], {
+    cwd: options3.cwd,
+    env: buildPtyEnv(options3.env),
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: process.platform !== "win32"
+  });
+  childProcess.stdout?.on("data", (chunk) => {
+    events.output(chunk, "stdout");
+  });
+  childProcess.stderr?.on("data", (chunk) => {
+    events.output(chunk, "stderr");
+  });
+  childProcess.on("error", events.error);
+  childProcess.on("close", events.close);
+  return {
+    kill(signal) {
+      killChildProcessTree(childProcess, signal);
+    },
+    write(input) {
+      childProcess.stdin?.write(input);
     }
-    if (!isUsableDirectory(options3.cwd)) {
-      reject(buildSpawnError({ code: "ENOENT" }, executable, options3.cwd));
+  };
+}
+function spawnNativePtyProcess(launcher, options3, events) {
+  const [executable, ...args] = launcher;
+  if (!executable) {
+    throw new ShellExecutionError("Executable is required");
+  }
+  const pty = __require("node-pty");
+  const ptyProcess = pty.spawn(executable, args, {
+    name: "xterm-256color",
+    cols: 80,
+    rows: 24,
+    cwd: options3.cwd,
+    env: buildPtyEnv(options3.env)
+  });
+  ptyProcess.onData((data) => events.output(data, "stdout"));
+  ptyProcess.onExit(({ exitCode }) => {
+    events.close(typeof exitCode === "number" ? exitCode : null);
+  });
+  return {
+    kill(signal) {
+      ptyProcess.kill(typeof signal === "string" ? signal : undefined);
+    },
+    write(input) {
+      ptyProcess.write(input);
+    }
+  };
+}
+function spawnPtyProcess(launcher, options3, events) {
+  return typeof Bun !== "undefined" ? spawnPtyBridgeProcess(launcher, options3, events) : spawnNativePtyProcess(launcher, options3, events);
+}
+function startShellProcess(launcher, options3) {
+  const [executable] = launcher;
+  if (!executable) {
+    throw new ShellExecutionError("Executable is required");
+  }
+  if (!isUsableDirectory(options3.cwd)) {
+    throw buildSpawnError({ code: "ENOENT" }, executable, options3.cwd);
+  }
+  noteExpectedWorktreeForLauncher(launcher, options3.cwd);
+  const pullRequestTracker = createGitHubPullRequestOutputTracker(options3.sourceCommand ?? launcher);
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let completed = false;
+  let timedOut = false;
+  let forceKillTimer;
+  let timeoutTimer;
+  let resolveCompletion;
+  let rejectCompletion;
+  const completion = new Promise((resolve8, reject) => {
+    resolveCompletion = resolve8;
+    rejectCompletion = reject;
+  });
+  const cleanup = () => {
+    if (timeoutTimer) {
+      clearTimeout(timeoutTimer);
+      timeoutTimer = undefined;
+    }
+    if (forceKillTimer) {
+      clearTimeout(forceKillTimer);
+      forceKillTimer = undefined;
+    }
+    options3.signal?.removeEventListener("abort", abortHandler);
+  };
+  let processHandle;
+  const terminateProcess = () => {
+    if (process.platform === "win32") {
+      processHandle.kill("SIGKILL");
       return;
     }
-    noteExpectedWorktreeForLauncher(launcher, options3.cwd);
-    const childProcess = spawn2(executable, args, {
-      cwd: options3.cwd,
-      env: options3.env,
-      shell: false,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: process.platform !== "win32"
-    });
-    const killProcessTree = (signal) => {
-      if (childProcess.pid) {
-        if (process.platform === "win32") {
-          const taskkill = spawn2("taskkill.exe", ["/pid", String(childProcess.pid), "/t", "/f"], {
-            stdio: "ignore",
-            windowsHide: true
-          });
-          taskkill.once("error", () => {
-            try {
-              childProcess.kill("SIGKILL");
-            } catch {}
-          });
-          taskkill.once("close", (code2) => {
-            if (code2 === 0)
-              return;
-            try {
-              childProcess.kill("SIGKILL");
-            } catch {}
-          });
-          return;
+    processHandle.kill("SIGTERM");
+    if (!forceKillTimer) {
+      forceKillTimer = setTimeout(() => {
+        if (!completed) {
+          processHandle.kill("SIGKILL");
         }
-        try {
-          process.kill(-childProcess.pid, signal);
-        } catch {
-          try {
-            childProcess.kill(signal);
-          } catch {}
+      }, FORCE_KILL_GRACE_MS);
+    }
+  };
+  const abortHandler = () => {
+    terminateProcess();
+  };
+  const events = {
+    output(data, stream11) {
+      const text = Buffer.isBuffer(data) ? data.toString("utf8") : data;
+      pullRequestTracker?.append(text, stream11);
+      if (options3.captureOutput !== false) {
+        if (stream11 === "stdout") {
+          stdoutChunks.push(Buffer.isBuffer(data) ? data : Buffer.from(data));
+        } else {
+          stderrChunks.push(Buffer.isBuffer(data) ? data : Buffer.from(data));
         }
       }
-    };
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    let timedOut = false;
-    let killTimer = null;
-    let completed = false;
-    const terminateProcess = () => {
-      if (process.platform === "win32") {
-        killProcessTree("SIGKILL");
+      options3.onOutput?.(text, stream11);
+    },
+    error(error54) {
+      if (completed)
         return;
-      }
-      killProcessTree("SIGTERM");
-      if (!killTimer) {
-        killTimer = setTimeout(() => {
-          if (!completed) {
-            killProcessTree("SIGKILL");
-          }
-        }, FORCE_KILL_GRACE_MS);
-      }
-    };
-    const timeoutId = options3.timeoutMs ? setTimeout(() => {
-      timedOut = true;
-      terminateProcess();
-    }, options3.timeoutMs) : null;
-    const abortHandler = () => {
-      terminateProcess();
-    };
-    if (options3.signal) {
-      options3.signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    childProcess.stdout?.on("data", (chunk) => {
-      stdoutChunks.push(chunk);
-      options3.onOutput?.(chunk.toString("utf8"), "stdout");
-    });
-    childProcess.stderr?.on("data", (chunk) => {
-      stderrChunks.push(chunk);
-      options3.onOutput?.(chunk.toString("utf8"), "stderr");
-    });
-    childProcess.on("error", (err) => {
       completed = true;
-      if (timeoutId)
-        clearTimeout(timeoutId);
-      if (killTimer) {
-        clearTimeout(killTimer);
-        killTimer = null;
-      }
-      if (options3.signal) {
-        options3.signal.removeEventListener("abort", abortHandler);
-      }
-      reject(buildSpawnError(err, executable, options3.cwd));
-    });
-    childProcess.on("close", (code2) => {
+      cleanup();
+      pullRequestTracker?.finish();
+      rejectCompletion(buildSpawnError(error54, executable, options3.cwd));
+    },
+    close(code2) {
+      if (completed)
+        return;
       completed = true;
-      if (timeoutId)
-        clearTimeout(timeoutId);
-      if (killTimer) {
-        clearTimeout(killTimer);
-        killTimer = null;
-      }
-      if (options3.signal) {
-        options3.signal.removeEventListener("abort", abortHandler);
-      }
+      cleanup();
+      pullRequestTracker?.finish();
       const stdout = Buffer.concat(stdoutChunks).toString("utf8");
       const stderr = Buffer.concat(stderrChunks).toString("utf8");
       if (timedOut) {
-        reject(Object.assign(new Error("Command timed out"), {
-          killed: true,
-          signal: "SIGTERM",
-          stdout,
-          stderr,
-          code: code2
-        }));
+        rejectCompletion(buildTimeoutError(stdout, stderr, code2));
         return;
       }
       if (options3.signal?.aborted) {
-        reject(Object.assign(new Error("The operation was aborted"), {
-          name: "AbortError",
-          code: "ABORT_ERR",
-          stdout,
-          stderr
-        }));
+        rejectCompletion(buildAbortError(stdout, stderr));
         return;
       }
-      resolve8({ stdout, stderr, exitCode: code2 });
-    });
-  });
+      resolveCompletion({ stdout, stderr, exitCode: code2 });
+    }
+  };
+  try {
+    processHandle = options3.tty ? spawnPtyProcess(launcher, options3, events) : spawnPipeProcess(launcher, options3, events);
+  } catch (error54) {
+    completed = true;
+    cleanup();
+    const failure2 = error54 instanceof Error ? error54 : new Error(String(error54));
+    rejectCompletion(failure2);
+    completion.catch(() => {});
+    throw failure2;
+  }
+  if (options3.timeoutMs) {
+    timeoutTimer = setTimeout(() => {
+      if (completed)
+        return;
+      timedOut = true;
+      terminateProcess();
+    }, options3.timeoutMs);
+  }
+  options3.signal?.addEventListener("abort", abortHandler, { once: true });
+  if (options3.signal?.aborted) {
+    abortHandler();
+  }
+  return { process: processHandle, completion };
+}
+async function spawnWithLauncher(launcher, options3) {
+  return startShellProcess(launcher, options3).completion;
 }
-var ShellExecutionError, FORCE_KILL_GRACE_MS = 2000;
+var ShellExecutionError, NODE_PTY_BRIDGE_SCRIPT = `
+const pty = require("node-pty");
+const config = JSON.parse(process.argv[1]);
+const child = pty.spawn(config.executable, config.args, {
+  name: "xterm-256color",
+  cols: 80,
+  rows: 24,
+  cwd: config.cwd,
+  env: process.env,
+});
+child.onData((data) => process.stdout.write(data));
+child.onExit(({ exitCode }) => process.exit(typeof exitCode === "number" ? exitCode : 1));
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (data) => child.write(data));
+process.on("SIGTERM", () => child.kill("SIGTERM"));
+process.on("SIGINT", () => child.kill("SIGINT"));
+`, FORCE_KILL_GRACE_MS = 2000;
 var init_shell_runner = __esm(() => {
   init_usable_directory();
   init_worktree_ownership();
+  init_github_pull_request_tracker();
   ShellExecutionError = class ShellExecutionError extends Error {
     code;
     executable;
@@ -154940,7 +155405,6 @@ __export(exports_bash, {
   spawnCommand: () => spawnCommand,
   bash: () => bash
 });
-import { spawn as spawn3 } from "node:child_process";
 function rebuildCachedLauncher(command, secretEnv) {
   if (!cachedWorkingLauncher)
     return null;
@@ -154975,6 +155439,7 @@ async function spawnCommand(command, options3) {
       cwd: options3.cwd,
       env: sandboxed.env,
       timeoutMs: options3.timeout,
+      sourceCommand: command,
       signal: options3.signal,
       onOutput: options3.onOutput
     });
@@ -154987,6 +155452,7 @@ async function spawnCommand(command, options3) {
           cwd: options3.cwd,
           env: env3,
           timeoutMs: options3.timeout,
+          sourceCommand: command,
           signal: options3.signal,
           onOutput: options3.onOutput
         });
@@ -155014,6 +155480,7 @@ async function spawnCommand(command, options3) {
         cwd: options3.cwd,
         env: env3,
         timeoutMs: options3.timeout,
+        sourceCommand: command,
         signal: options3.signal,
         onOutput: options3.onOutput
       });
@@ -155033,12 +155500,55 @@ async function spawnCommand(command, options3) {
   const reason = lastError?.message || "Shell unavailable";
   throw new Error(suffix ? `${reason} (tried: ${suffix})` : reason);
 }
+function formatStreamTail(label, retainedLines, totalLines) {
+  if (retainedLines.length === 0) {
+    return;
+  }
+  const tail = retainedLines.slice(-NOTIFICATION_TAIL_LINES);
+  const header = tail.length < totalLines ? `[${label} - last ${tail.length} of ${totalLines} lines]` : `[${label}]`;
+  return `${header}
+${tail.join(`
+`)}`;
+}
+function formatBackgroundOutputTail(bgProcess) {
+  const sections = [
+    formatStreamTail("stdout", bgProcess.stdout, bgProcess.totalStdoutLines ?? bgProcess.stdout.length),
+    formatStreamTail("stderr", bgProcess.stderr, bgProcess.totalStderrLines ?? bgProcess.stderr.length)
+  ].filter(Boolean);
+  return sections.length > 0 ? sections.join(`
+
+`) : "(no output)";
+}
+function notifyBackgroundCompletion(params) {
+  const { bashId, description, outputFile, bgProcess, scope, status, detail } = params;
+  if (bgProcess.completionNotificationSuppressed) {
+    return;
+  }
+  const label = description?.trim() || bgProcess.command;
+  const durationMs = bgProcess.startTime ? Math.max(0, Date.now() - bgProcess.startTime.getTime()) : undefined;
+  const { content: result } = truncateByChars([`$ ${bgProcess.command}`, detail, formatBackgroundOutputTail(bgProcess)].filter(Boolean).join(`
+
+`), LIMITS.BASH_NOTIFICATION_CHARS, "Bash", { useMiddleTruncation: true });
+  addToMessageQueue({
+    kind: "task_notification",
+    text: formatTaskNotification({
+      taskId: bashId,
+      status,
+      summary: `Background command "${label}" ${status}`,
+      result,
+      outputFile,
+      usage: durationMs === undefined ? undefined : { durationMs }
+    }),
+    agentId: scope?.agentId,
+    conversationId: scope?.conversationId
+  });
+}
 async function bash(args) {
   validateRequiredParams(args, ["command"], "Bash");
   const {
     command,
     timeout = 120000,
-    description: _description,
+    description,
     run_in_background = false,
     signal,
     onOutput,
@@ -155096,14 +155606,20 @@ async function bash(args) {
     }
     noteExpectedWorktreeForLauncher(launcher, userCwd);
     const sandboxed = applyShellSandbox(launcher, userCwd, bgEnv);
-    const [bgExecutable, ...bgLauncherArgs] = sandboxed.launcher;
-    const childProcess = spawn3(bgExecutable ?? executable, bgLauncherArgs, {
-      shell: false,
+    let bgProcess;
+    const runningProcess = startShellProcess(sandboxed.launcher, {
       cwd: userCwd,
-      env: sandboxed.env
+      env: sandboxed.env,
+      timeoutMs: timeout > 0 ? timeout : 0,
+      sourceCommand: command,
+      captureOutput: false,
+      onOutput(text, stream11) {
+        appendBackgroundProcessOutput(bgProcess, stream11, text);
+        appendToOutputFile(outputFile, stream11 === "stderr" ? `[stderr] ${text}` : text);
+      }
     });
-    backgroundProcesses.set(bashId, {
-      process: childProcess,
+    bgProcess = {
+      process: runningProcess.process,
       command,
       stdout: [],
       stderr: [],
@@ -155115,51 +155631,46 @@ async function bash(args) {
       totalStdoutLines: 0,
       totalStderrLines: 0,
       runtimeScope: parentScope
-    });
-    const bgProcess = backgroundProcesses.get(bashId);
-    if (!bgProcess) {
-      throw new Error("Failed to track background process state");
-    }
-    childProcess.stdout?.on("data", (data) => {
-      const text = data.toString();
-      appendBackgroundProcessOutput(bgProcess, "stdout", text);
-      appendToOutputFile(outputFile, text);
-    });
-    childProcess.stderr?.on("data", (data) => {
-      const text = data.toString();
-      appendBackgroundProcessOutput(bgProcess, "stderr", text);
-      appendToOutputFile(outputFile, `[stderr] ${text}`);
-    });
-    childProcess.on("exit", (code2) => {
-      bgProcess.status = code2 === 0 ? "completed" : "failed";
-      bgProcess.exitCode = code2;
+    };
+    backgroundProcesses.set(bashId, bgProcess);
+    const notificationScope = resolveNotificationScope(parentScope);
+    runningProcess.completion.then(({ exitCode }) => {
+      bgProcess.status = exitCode === 0 ? "completed" : "failed";
+      bgProcess.exitCode = exitCode;
       appendToOutputFile(outputFile, `
-[exit code: ${code2}]
+[exit code: ${exitCode}]
 `);
+      notifyBackgroundCompletion({
+        bashId,
+        description,
+        outputFile,
+        bgProcess,
+        scope: notificationScope,
+        status: exitCode === 0 ? "completed" : "failed",
+        detail: exitCode === null ? "Terminated by signal before exiting" : `Exit code: ${exitCode}`
+      });
       scheduleBackgroundProcessCleanup(bashId);
-    });
-    childProcess.on("error", (err) => {
+    }, (error54) => {
+      const err = error54;
+      const message = err.killed ? `Command timed out after ${timeout}ms` : err.message;
       bgProcess.status = "failed";
-      appendBackgroundProcessOutput(bgProcess, "stderr", err.message);
-      appendToOutputFile(outputFile, `
-[error] ${err.message}
+      appendBackgroundProcessOutput(bgProcess, "stderr", message);
+      appendToOutputFile(outputFile, err.killed ? `
+[timeout after ${timeout}ms]
+` : `
+[error] ${message}
 `);
+      notifyBackgroundCompletion({
+        bashId,
+        description,
+        outputFile,
+        bgProcess,
+        scope: notificationScope,
+        status: "failed",
+        detail: err.killed ? message : `Error: ${message}`
+      });
       scheduleBackgroundProcessCleanup(bashId);
     });
-    if (timeout && timeout > 0) {
-      const timeoutHandle = setTimeout(() => {
-        if (bgProcess.status === "running") {
-          childProcess.kill("SIGTERM");
-          bgProcess.status = "failed";
-          appendBackgroundProcessOutput(bgProcess, "stderr", `Command timed out after ${timeout}ms`);
-          appendToOutputFile(outputFile, `
-[timeout after ${timeout}ms]
-`);
-          scheduleBackgroundProcessCleanup(bashId);
-        }
-      }, timeout);
-      unrefTimer2(timeoutHandle);
-    }
     return {
       content: [
         {
@@ -155235,10 +155746,12 @@ ${errorMessage}`;
     };
   }
 }
-var cachedWorkingLauncher = null;
+var cachedWorkingLauncher = null, NOTIFICATION_TAIL_LINES = 50;
 var init_bash = __esm(() => {
   init_constants2();
   init_runtime_context();
+  init_message_queue_bridge();
+  init_task_notifications();
   init_worktree_ownership();
   init_process_manager();
   init_shell_env();
@@ -157808,7 +158321,7 @@ var init_enter_worktree_messages = __esm(() => {
 });
 
 // src/tools/impl/enter-worktree.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import {
   copyFile,
@@ -157860,7 +158373,7 @@ This looks like a Windows path-length issue. Try:
 async function runGit2(args, cwd, options3 = {}) {
   const timeoutMs = options3.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS;
   return await new Promise((resolve11, reject) => {
-    const child = spawn4("git", args, {
+    const child = spawn3("git", args, {
       cwd,
       env: getShellEnv(),
       shell: false,
@@ -158535,6 +159048,7 @@ async function runProcess(context3) {
     cwd: context3.cwd,
     env: context3.env,
     timeoutMs: context3.timeout,
+    sourceCommand: context3.sourceCommand,
     signal: context3.signal,
     onOutput: context3.onOutput
   });
@@ -158585,6 +159099,7 @@ async function shell(args) {
   }
   const context3 = {
     command: sandboxed.launcher,
+    sourceCommand: command,
     cwd,
     env: sandboxed.env,
     timeout,
@@ -158694,7 +159209,6 @@ var init_shell = __esm(() => {
 });
 
 // src/tools/impl/exec-command.ts
-import { spawn as spawn5 } from "node:child_process";
 function createAbortError2() {
   const error54 = new Error("The operation was aborted");
   error54.name = "AbortError";
@@ -158884,17 +159398,6 @@ function buildExecLaunchers(args) {
     powershellEnvAliases: envAliases
   });
 }
-function buildPtyEnv(env3) {
-  const ptyEnv = {};
-  for (const [key, value] of Object.entries(env3)) {
-    if (value !== undefined) {
-      ptyEnv[key] = value;
-    }
-  }
-  ptyEnv.TERM = ptyEnv.TERM || "xterm-256color";
-  ptyEnv.COLORTERM = ptyEnv.COLORTERM || "truecolor";
-  return ptyEnv;
-}
 function createSessionOutputAppender(params) {
   return (text, stream11) => {
     appendSessionOutput(params.session, text, stream11);
@@ -158925,117 +159428,6 @@ function markSessionClosed(session, code2) {
   }
   scheduleExecSessionCleanup(session.id);
 }
-function spawnPipeProcess(params) {
-  const [executable, ...args] = params.launcher;
-  if (!executable) {
-    throw new Error("Executable is required");
-  }
-  noteExpectedWorktreeForLauncher(params.launcher, params.cwd);
-  const childProcess = spawn5(executable, args, {
-    cwd: params.cwd,
-    env: params.env,
-    shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: process.platform !== "win32"
-  });
-  const appendOutput = createSessionOutputAppender(params);
-  childProcess.stdout?.on("data", (chunk) => {
-    appendOutput(chunk.toString("utf8"), "stdout");
-  });
-  childProcess.stderr?.on("data", (chunk) => {
-    appendOutput(chunk.toString("utf8"), "stderr");
-  });
-  childProcess.on("error", (error54) => {
-    appendOutput(error54.message, "stderr");
-    markSessionFailed(params.session);
-  });
-  childProcess.on("close", (code2) => {
-    markSessionClosed(params.session, code2);
-  });
-  return {
-    kill(signal) {
-      if (childProcess.pid && process.platform !== "win32") {
-        try {
-          process.kill(-childProcess.pid, signal);
-          return;
-        } catch {}
-      }
-      childProcess.kill(signal);
-    },
-    write(input) {
-      childProcess.stdin?.write(input);
-    }
-  };
-}
-function spawnPtyProcess(params) {
-  const [executable, ...args] = params.launcher;
-  if (!executable) {
-    throw new Error("Executable is required");
-  }
-  noteExpectedWorktreeForLauncher(params.launcher, params.cwd);
-  const appendOutput = createSessionOutputAppender(params);
-  const ptyEnv = buildPtyEnv(params.env);
-  if (typeof Bun !== "undefined") {
-    const childProcess = spawn5("node", [
-      "-e",
-      NODE_PTY_BRIDGE_SCRIPT,
-      JSON.stringify({ executable, args, cwd: params.cwd })
-    ], {
-      cwd: params.cwd,
-      env: ptyEnv,
-      shell: false,
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: process.platform !== "win32"
-    });
-    childProcess.stdout?.on("data", (chunk) => {
-      appendOutput(chunk.toString("utf8"), "stdout");
-    });
-    childProcess.stderr?.on("data", (chunk) => {
-      appendOutput(chunk.toString("utf8"), "stderr");
-    });
-    childProcess.on("error", (error54) => {
-      appendOutput(error54.message, "stderr");
-      markSessionFailed(params.session);
-    });
-    childProcess.on("close", (code2) => {
-      markSessionClosed(params.session, code2);
-    });
-    return {
-      kill(signal) {
-        if (childProcess.pid && process.platform !== "win32") {
-          try {
-            process.kill(-childProcess.pid, signal);
-            return;
-          } catch {}
-        }
-        childProcess.kill(signal);
-      },
-      write(input) {
-        childProcess.stdin?.write(input);
-      }
-    };
-  }
-  const pty = __require("node-pty");
-  const ptyProcess = pty.spawn(executable, args, {
-    name: "xterm-256color",
-    cols: 80,
-    rows: 24,
-    cwd: params.cwd,
-    env: ptyEnv
-  });
-  ptyProcess.onData((data) => appendOutput(data, "stdout"));
-  ptyProcess.onExit(({ exitCode }) => {
-    markSessionClosed(params.session, typeof exitCode === "number" ? exitCode : null);
-  });
-  return {
-    kill(signal) {
-      ptyProcess.kill(typeof signal === "string" ? signal : undefined);
-    },
-    write(input) {
-      ptyProcess.write(input);
-    }
-  };
-}
 async function waitForSessionOutput(params) {
   const startTime = Date.now();
   const deadline = startTime + params.yieldTimeMs;
@@ -159089,22 +159481,25 @@ async function startExecSession(args) {
     tty: args.tty ?? false
   };
   execSessions.set(id2, session);
-  let processLauncher;
+  const appendOutput = createSessionOutputAppender({ session, outputFile });
+  let runningProcess;
   try {
-    const spawnProcess = session.tty ? spawnPtyProcess : spawnPipeProcess;
-    processLauncher = spawnProcess({
-      launcher,
+    runningProcess = startShellProcess(launcher, {
       cwd,
       env: spawnEnv,
-      session,
-      outputFile
+      timeoutMs: 0,
+      sourceCommand: args.cmd,
+      signal: args.signal,
+      tty: session.tty,
+      captureOutput: false,
+      onOutput: appendOutput
     });
   } catch (error54) {
     execSessions.delete(id2);
     throw error54;
   }
   backgroundProcesses.set(id2, {
-    process: processLauncher,
+    process: runningProcess.process,
     command: args.cmd,
     stdout: [],
     stderr: [],
@@ -159120,9 +159515,12 @@ async function startExecSession(args) {
   if (session.status !== "running") {
     scheduleBackgroundProcessCleanup(id2);
   }
-  args.signal?.addEventListener("abort", () => {
-    processLauncher.kill("SIGTERM");
-  }, { once: true });
+  runningProcess.completion.then(({ exitCode }) => markSessionClosed(session, exitCode), (error54) => {
+    if (error54 instanceof ShellExecutionError) {
+      appendOutput(error54.message, "stderr");
+    }
+    markSessionFailed(session);
+  });
   return session;
 }
 async function exec_command(args) {
@@ -159198,23 +159596,7 @@ async function write_stdin(args) {
     output: formattedOutput
   };
 }
-var DEFAULT_EXEC_YIELD_TIME_MS = 1e4, DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250, MIN_YIELD_TIME_MS = 250, MIN_EMPTY_WRITE_STDIN_YIELD_TIME_MS = 5000, MAX_YIELD_TIME_MS = 30000, MAX_EMPTY_WRITE_STDIN_YIELD_TIME_MS = 300000, DEFAULT_MAX_OUTPUT_TOKENS = 1e4, MAX_INLINE_OUTPUT_CHARS, MAX_SESSION_OUTPUT_CHARS = 1e6, EXEC_SESSION_CLEANUP_MS, NODE_PTY_BRIDGE_SCRIPT = `
-const pty = require("node-pty");
-const config = JSON.parse(process.argv[1]);
-const child = pty.spawn(config.executable, config.args, {
-  name: "xterm-256color",
-  cols: 80,
-  rows: 24,
-  cwd: config.cwd,
-  env: process.env,
-});
-child.onData((data) => process.stdout.write(data));
-child.onExit(({ exitCode }) => process.exit(typeof exitCode === "number" ? exitCode : 1));
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (data) => child.write(data));
-process.on("SIGTERM", () => child.kill("SIGTERM"));
-process.on("SIGINT", () => child.kill("SIGINT"));
-`, execSessions;
+var DEFAULT_EXEC_YIELD_TIME_MS = 1e4, DEFAULT_WRITE_STDIN_YIELD_TIME_MS = 250, MIN_YIELD_TIME_MS = 250, MIN_EMPTY_WRITE_STDIN_YIELD_TIME_MS = 5000, MAX_YIELD_TIME_MS = 30000, MAX_EMPTY_WRITE_STDIN_YIELD_TIME_MS = 300000, DEFAULT_MAX_OUTPUT_TOKENS = 1e4, MAX_INLINE_OUTPUT_CHARS, MAX_SESSION_OUTPUT_CHARS = 1e6, EXEC_SESSION_CLEANUP_MS, execSessions;
 var init_exec_command = __esm(() => {
   init_runtime_context();
   init_worktree_ownership();
@@ -159222,6 +159604,7 @@ var init_exec_command = __esm(() => {
   init_shell();
   init_shell_env();
   init_shell_launchers();
+  init_shell_runner();
   init_shell_sandbox();
   init_truncation();
   MAX_INLINE_OUTPUT_CHARS = LIMITS.BASH_OUTPUT_CHARS;
@@ -159521,6 +159904,7 @@ async function kill_bash(args) {
   if (!proc)
     return { killed: false };
   try {
+    proc.completionNotificationSuppressed = true;
     proc.process.kill("SIGTERM");
     clearBackgroundProcessCleanup(shell_id);
     backgroundProcesses.delete(shell_id);
@@ -162500,7 +162884,7 @@ async function convertHeicToJpegWithSips(buffer) {
 var init_image_resize_sips = () => {};
 
 // src/utils/image-resize.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync16 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function resolveImageWorkerPath() {
@@ -162513,7 +162897,7 @@ function resolveImageWorkerPath() {
 function resizeWithSharpWorker(buffer, inputMediaType) {
   return new Promise((resolve18, reject) => {
     const workerPath = resolveImageWorkerPath();
-    const child = spawn6(process.execPath, [workerPath, inputMediaType], {
+    const child = spawn4(process.execPath, [workerPath, inputMediaType], {
       shell: false,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
@@ -163609,7 +163993,7 @@ var require_cross_spawn = __commonJS((exports, module3) => {
   var cp = __require("child_process");
   var parse8 = require_parse3();
   var enoent = require_enoent();
-  function spawn7(command, args, options3) {
+  function spawn5(command, args, options3) {
     const parsed = parse8(command, args, options3);
     const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
@@ -163621,8 +164005,8 @@ var require_cross_spawn = __commonJS((exports, module3) => {
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
   }
-  module3.exports = spawn7;
-  module3.exports.spawn = spawn7;
+  module3.exports = spawn5;
+  module3.exports.spawn = spawn5;
   module3.exports.sync = spawnSync3;
   module3.exports._parse = parse8;
   module3.exports._enoent = enoent;
@@ -163630,13 +164014,13 @@ var require_cross_spawn = __commonJS((exports, module3) => {
 
 // src/utils/package-manager-spawn.ts
 import {
-  spawn as spawn7
+  spawn as spawn5
 } from "node:child_process";
 function isWindowsCommandShim(command) {
   return /\.(?:cmd|bat)$/i.test(command);
 }
 function getPackageManagerProcessFactory({
-  nativeSpawn = spawn7,
+  nativeSpawn = spawn5,
   platform: platform2 = process.platform,
   windowsSpawn = import_cross_spawn.default
 } = {}) {
@@ -163737,9 +164121,9 @@ var init_typescript = __esm(() => {
           throw new Error("LSP auto-download is disabled. Please install typescript-language-server manually: npm install -g typescript-language-server typescript");
         }
         console.log("[LSP] Installing typescript-language-server and typescript...");
-        const { spawn: spawn8 } = await import("node:child_process");
+        const { spawn: spawn6 } = await import("node:child_process");
         return new Promise((resolve18, reject) => {
-          const proc = spawn8("npm", ["install", "-g", "typescript-language-server", "typescript"], {
+          const proc = spawn6("npm", ["install", "-g", "typescript-language-server", "typescript"], {
             stdio: "inherit"
           });
           proc.on("exit", (code2) => {
@@ -163812,7 +164196,7 @@ class LSPManager {
       return existing.client;
     }
     try {
-      const { spawn: spawn8 } = await import("node:child_process");
+      const { spawn: spawn6 } = await import("node:child_process");
       const rootUri = process.cwd();
       if (serverDef.autoInstall) {
         const isAvailable = await serverDef.autoInstall.check();
@@ -163826,7 +164210,7 @@ class LSPManager {
         console.error(`[LSP] ${serverDef.id} has no command configured`);
         return null;
       }
-      const proc = spawn8(command, serverDef.command.slice(1), {
+      const proc = spawn6(command, serverDef.command.slice(1), {
         cwd: rootUri,
         env: {
           ...process.env,
@@ -172641,6 +173025,9 @@ async function resolveSubagentModel(options3) {
     }
     return "letta/auto-memory";
   }
+  if (isInheritModel(effectiveRecommendedModel) && parentModelHandle) {
+    return parentModelHandle;
+  }
   let recommendedHandle = null;
   if (effectiveRecommendedModel && !isInheritModel(effectiveRecommendedModel)) {
     recommendedHandle = resolveModel(effectiveRecommendedModel);
@@ -172850,7 +173237,7 @@ var init_subagent_stream = __esm(() => {
 });
 
 // src/agent/subagents/manager.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { platform as platform2 } from "node:os";
 function isProviderNotSupportedError(errorOutput) {
   return errorOutput.includes("Provider") && errorOutput.includes("is not supported") && errorOutput.includes("supported providers:");
@@ -173067,7 +173454,7 @@ async function executeSubagent(type3, config3, model, userPrompt, subagentId, is
     if (sandbox) {
       debugLog("subagent", `memory subagent child sandboxed via ${sandbox.backend}`);
     }
-    const proc2 = spawn8(spawnLauncher.command, spawnLauncher.args, {
+    const proc2 = spawn6(spawnLauncher.command, spawnLauncher.args, {
       cwd: subagentWorkingDirectory,
       env: spawnEnv
     });
@@ -173334,114 +173721,6 @@ var init_manager3 = __esm(() => {
   ]);
 });
 
-// src/utils/message-queue-bridge.ts
-function setMessageQueueAdder(fn) {
-  queueAdder = fn;
-  if (queueAdder && pendingMessages.length > 0) {
-    for (const message of pendingMessages) {
-      queueAdder(message);
-    }
-    pendingMessages.length = 0;
-  }
-}
-function addToMessageQueue(message) {
-  if (queueAdder) {
-    queueAdder(message);
-    return;
-  }
-  if (pendingMessages.length >= MAX_PENDING_MESSAGES) {
-    pendingMessages.shift();
-  }
-  pendingMessages.push(message);
-}
-var queueAdder = null, pendingMessages, MAX_PENDING_MESSAGES = 10;
-var init_message_queue_bridge = __esm(() => {
-  pendingMessages = [];
-});
-
-// src/utils/task-notifications.ts
-function escapeXml(str2) {
-  return str2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function unescapeXml(str2) {
-  return str2.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-}
-function formatTaskNotification(notification) {
-  const escapedSummary = escapeXml(notification.summary);
-  const escapedResult = escapeXml(notification.result);
-  const usageLines = [];
-  if (notification.usage?.totalTokens !== undefined) {
-    usageLines.push(`total_tokens: ${notification.usage.totalTokens}`);
-  }
-  if (notification.usage?.toolUses !== undefined) {
-    usageLines.push(`tool_uses: ${notification.usage.toolUses}`);
-  }
-  if (notification.usage?.durationMs !== undefined) {
-    usageLines.push(`duration_ms: ${notification.usage.durationMs}`);
-  }
-  const usageBlock = usageLines.length ? `
-<usage>${usageLines.join(`
-`)}</usage>` : "";
-  return `<task-notification>
-<task-id>${notification.taskId}</task-id>
-<status>${notification.status}</status>
-<summary>${escapedSummary}</summary>
-<result>${escapedResult}</result>${usageBlock}
-</task-notification>
-Full transcript available at: ${notification.outputFile}`;
-}
-function extractTaskNotificationsForDisplay(message) {
-  if (!message.includes("<task-notification>")) {
-    return { notifications: [], cleanedText: message };
-  }
-  const notificationRegex = /<task-notification>[\s\S]*?(?:<\/task-notification>|$)(?:\s*Full transcript available at:[^\n]*\n?)?/g;
-  const notifications = [];
-  let match3 = notificationRegex.exec(message);
-  while (match3 !== null) {
-    const xml = match3[0];
-    const summaryMatch = xml.match(/<summary>([\s\S]*?)<\/summary>/);
-    const statusMatch = xml.match(/<status>([\s\S]*?)<\/status>/);
-    const resultMatch = xml.match(/<result>([\s\S]*?)<\/result>/);
-    const result = resultMatch?.[1]?.trim() || "";
-    const isAgentOnlyReminder = result.includes(SYSTEM_REMINDER_OPEN);
-    if (isAgentOnlyReminder) {
-      match3 = notificationRegex.exec(message);
-      continue;
-    }
-    const status = statusMatch?.[1]?.trim();
-    let summary = summaryMatch?.[1]?.trim() || "";
-    summary = unescapeXml(summary);
-    const display = summary || `Agent task ${status || "completed"}`;
-    notifications.push(display);
-    match3 = notificationRegex.exec(message);
-  }
-  const cleanedText = message.replace(notificationRegex, "").replace(/^\s*Full transcript available at:[^\n]*\n?/gm, "").replace(/\n{3,}/g, `
-
-`).trim();
-  return { notifications, cleanedText };
-}
-function appendTaskNotificationEventsToBuffer(summaries, buffer, generateId, flush) {
-  if (summaries.length === 0)
-    return false;
-  for (const summary of summaries) {
-    const eventId = generateId();
-    buffer.byId.set(eventId, {
-      kind: "event",
-      id: eventId,
-      eventType: "task_notification",
-      eventData: {},
-      phase: "finished",
-      summary
-    });
-    buffer.order.push(eventId);
-  }
-  flush?.();
-  return true;
-}
-var init_task_notifications = __esm(() => {
-  init_constants2();
-});
-
 // src/tools/impl/task.ts
 var exports_task = {};
 __export(exports_task, {
@@ -173491,22 +173770,6 @@ ${result.report}
 [Task failed]
 `);
 }
-function resolveParentScope(parentScope) {
-  if (parentScope?.agentId) {
-    return {
-      agentId: parentScope.agentId,
-      conversationId: parentScope.conversationId || "default"
-    };
-  }
-  try {
-    return {
-      agentId: getCurrentAgentId(),
-      conversationId: getConversationId() ?? "default"
-    };
-  } catch {
-    return;
-  }
-}
 async function waitForBackgroundSubagentLink(subagentId, timeoutMs = null, signal) {
   const deadline = timeoutMs !== null && timeoutMs > 0 ? Date.now() + timeoutMs : null;
   while (true) {
@@ -173597,7 +173860,7 @@ function spawnBackgroundSubagentTask(args) {
     deps
   } = args;
   const shouldEmitCompletionNotification = emitCompletionNotification ?? !silentCompletion;
-  const resolvedParentScope = resolveParentScope(parentScope);
+  const resolvedParentScope = resolveNotificationScope(parentScope);
   const spawnSubagentFn = deps?.spawnSubagentImpl ?? spawnSubagent;
   const addToMessageQueueFn = deps?.addToMessageQueueImpl ?? addToMessageQueue;
   const formatTaskNotificationFn = deps?.formatTaskNotificationImpl ?? formatTaskNotification;
@@ -173804,7 +174067,7 @@ async function task(args) {
   }
   const prompt = inputPrompt;
   const isBackground = args.run_in_background ?? config3.background;
-  const resolvedParentScope = resolveParentScope(args.parentScope);
+  const resolvedParentScope = resolveNotificationScope(args.parentScope);
   if (isBackground) {
     const { taskId, outputFile: outputFile2, subagentId: subagentId2 } = spawnBackgroundSubagentTask({
       subagentType: subagent_type,
@@ -232312,7 +232575,7 @@ function parsePositiveIntFlag(options3) {
 }
 
 // src/cli/helpers/file-autocomplete.ts
-import { spawn as spawn9, spawnSync as spawnSync3 } from "node:child_process";
+import { spawn as spawn7, spawnSync as spawnSync3 } from "node:child_process";
 import {
   chmodSync as chmodSync5,
   createWriteStream as createWriteStream3,
@@ -232458,7 +232721,7 @@ async function walkDirectoryWithFd(baseDir, fdPath, query2, maxResults, signal)
       resolve29([]);
       return;
     }
-    const child = spawn9(fdPath, args, {
+    const child = spawn7(fdPath, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -250219,7 +250482,7 @@ var init_runtime6 = __esm(() => {
 });
 
 // src/channels/signal/setup-runtime.ts
-import { execFileSync as execFileSync5, spawn as spawn10 } from "node:child_process";
+import { execFileSync as execFileSync5, spawn as spawn8 } from "node:child_process";
 import { existsSync as existsSync35 } from "node:fs";
 function getSignalDockerRunCommand() {
   return [
@@ -250281,7 +250544,7 @@ function runNativeSignalCli(args) {
 }
 function runNativeSignalCliInteractive(args, onOutput) {
   return new Promise((resolve30) => {
-    const child = spawn10("signal-cli", args, {
+    const child = spawn8("signal-cli", args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let output = "";
@@ -268958,7 +269221,7 @@ var init_core5 = __esm(() => {
 });
 
 // node_modules/@letta-ai/trajectory/dist/adapters/deepagents/index.js
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import { accessSync as accessSync2, constants as constants5 } from "node:fs";
 import { homedir as homedir27 } from "node:os";
 import { join as join48 } from "node:path";
@@ -268989,7 +269252,7 @@ async function loadDeepAgentsCheckpoint(checkpoint2) {
   const python = checkpoint2.pythonExecutable ?? process.env.PYTHON ?? "python3";
   const helper = resolveHelperPath();
   return await new Promise((resolve31, reject) => {
-    const child = spawn11(python, [helper], {
+    const child = spawn9(python, [helper], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
@@ -462626,7 +462889,7 @@ var init_mod_commands = __esm(async () => {
 });
 
 // src/websocket/listener/commands.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 async function handleExecuteCommand(command, socket, conversationRuntime, opts) {
   const scope = {
     agent_id: conversationRuntime.agentId,
@@ -462833,7 +463096,7 @@ function scheduleRemoteRestart(connectionName, log2) {
   setTimeout(async () => {
     await flushRemoteSettingsWrites();
     log2(`spawning replacement listener: ${process.execPath} ${entrypoint} remote --env-name ${connectionName}`);
-    const child = spawn12(process.execPath, [entrypoint, "remote", "--env-name", connectionName], {
+    const child = spawn10(process.execPath, [entrypoint, "remote", "--env-name", connectionName], {
       cwd: process.cwd(),
       detached: true,
       env: process.env,
@@ -464398,7 +464661,8 @@ function dispatchInboundMessageWhenReady(params) {
     emitListenerStatus(listener, options3.onStatusChange, options3.connectionId);
     rememberAcceptedInputDisposition(runtime, clientMessageId, "started");
     acknowledgeInput({ accepted: true, disposition: "started" });
-    await processIncomingMessage(incoming, getOrCreateProcessTransport(listener), runtime, options3.onStatusChange, options3.connectionId);
+    const attributedIncoming = actingUserId && incoming.actingUserId !== actingUserId ? { ...incoming, actingUserId } : incoming;
+    await processIncomingMessage(attributedIncoming, getOrCreateProcessTransport(listener), runtime, options3.onStatusChange, options3.connectionId);
     emitListenerStatus(listener, options3.onStatusChange, options3.connectionId);
     if (runtime.queueRuntime.length > 0 || runtime.queuePumpScheduled || runtime.queuePumpActive) {
       scheduleQueuePump(runtime, socket, options3, processQueuedTurn);
@@ -468641,7 +468905,7 @@ __export(exports_gateway_supervisor, {
   startChannelGatewaySupervisor: () => startChannelGatewaySupervisor,
   CHANNEL_GATEWAY_READY_SIGNAL: () => CHANNEL_GATEWAY_READY_SIGNAL
 });
-import { spawn as spawn13 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 function resolveLauncher(cwd2) {
   const invocation = resolveLettaInvocation(process.env, process.argv, process.execPath, cwd2);
   if (invocation)
@@ -468686,7 +468950,7 @@ async function startChannelGatewaySupervisor(options3) {
   const launch = () => {
     if (stopping)
       return;
-    child = (options3.spawnProcess ?? spawn13)(launcher.command, childArgs, {
+    child = (options3.spawnProcess ?? spawn11)(launcher.command, childArgs, {
       cwd: cwd2,
       env: options3.env ?? process.env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -470981,7 +471245,7 @@ var init_messages10 = __esm(() => {
 });
 
 // src/mods/package-installer.ts
-import { spawn as spawn14 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync55,
@@ -471839,7 +472103,7 @@ var init_package_installer = __esm(() => {
   init_package_registry();
   init_package_manager_spawn();
   SKIPPED_PACKAGE_COPY_NAMES = new Set([".git", "node_modules"]);
-  spawnGitInstallProcess = spawn14;
+  spawnGitInstallProcess = spawn12;
 });
 
 // src/mods/package-scaffolder.ts
@@ -492975,7 +493239,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.30.12"
+    version: "0.30.13"
   };
 });
 
@@ -546178,7 +546442,7 @@ The deployment target for this project is CITATION-DOGFOOD-OK.
 });
 
 // src/mods/learning-harness.ts
-import { spawn as spawn16 } from "node:child_process";
+import { spawn as spawn14 } from "node:child_process";
 import { access as access3, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile32, writeFile as writeFile22 } from "node:fs/promises";
 import path45 from "node:path";
 function slugify2(value) {
@@ -547118,7 +547382,7 @@ async function writeHistoryArtifacts(params) {
 async function defaultCommandRunner(command, args, options3) {
   const startedAt = Date.now();
   return new Promise((resolve39) => {
-    const child = spawn16(command, args, {
+    const child = spawn14(command, args, {
       cwd: options3.cwd,
       env: options3.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -560076,4 +560340,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=88D7420381F4049564756E2164756E21
+//# debugId=A52BE38779C3A2C664756E2164756E21