@letta-ai/letta-code 0.34.30 → 0.34.32

package/letta.js

@@ -6044,7 +6044,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.34.30",
+    version: "0.34.32",
     lettaStartupLogProtocol: 1,
     lettaConfigDirProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
@@ -6322,7 +6322,7 @@ var init_package = __esm(() => {
     },
     lettaLifecycleProtocol: 1,
     lettaRuntimeGraphProtocol: 1,
-    lettaRuntimeGraphSha512: "sha512-E2rWRJpy7Cl1ZMcUvyUnnuFDfi7+nyq4GfZ6TzfxSrpiuiYWPXRRJOzb0KBdgHYRJRi+rdXWWKkZwvy9lgmLew==",
+    lettaRuntimeGraphSha512: "sha512-k6/hR2IHpEKzR+Q6apFf2XdWJ1VIJXHIq74pZMH5EoGipLTIwCfuBzQnj1lmMiLaZC5+KXjGNgW9a4ZZb8/02A==",
     patchedDependencies: {
       "@earendil-works/pi-ai@0.99.1": "patches/@earendil-works%2Fpi-ai@0.99.1.patch"
     }
@@ -116346,11 +116346,10 @@ var init_pi_model_factory = __esm(() => {
 
 // src/backend/dev/pi-request-headers.ts
 function resolvePiRequestHeaders(input) {
-  if (input.provider !== "opencode-go")
-    return input.configuredHeaders;
   return {
     ...input.configuredHeaders,
-    "x-opencode-session": input.conversationId
+    "x-letta-request-kind": input.requestKind,
+    ...input.provider === "opencode-go" ? { "x-opencode-session": input.conversationId } : {}
   };
 }
 
@@ -116930,13 +116929,14 @@ async function runGenerateText(input, transcript2, defaultPrompt) {
   const headers = resolvePiRequestHeaders({
     provider: resolved2.model.provider,
     configuredHeaders: resolved2.headers,
-    conversationId: input.conversationId
+    conversationId: input.conversationId,
+    requestKind: "compaction"
   });
   const options = {
     ...resolved2.providerOptions,
     ...resolved2.apiKey ? { apiKey: resolved2.apiKey } : {},
     ...resolved2.timeout !== false ? { timeoutMs: resolved2.timeout } : {},
-    ...headers ? { headers } : {},
+    headers,
     ...input.abortSignal ? { signal: input.abortSignal } : {},
     ...reasoning ? { reasoning } : {},
     maxRetries: 0,
@@ -117869,9 +117869,8 @@ function anthropicEffortForSettings(modelSettings) {
   const nestedReasoning = isRecord2(modelSettings.reasoning) ? modelSettings.reasoning : undefined;
   return stringValue2(modelSettings.effort) ?? stringValue2(nestedReasoning?.reasoning_effort) ?? stringValue2(modelSettings.reasoning_effort);
 }
-function maxTokensForSettings(modelSettings) {
-  const maxTokens = modelSettings.max_tokens;
-  return typeof maxTokens === "number" && Number.isFinite(maxTokens) ? maxTokens : undefined;
+function finiteNumberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 function serviceTierForSettings(model, modelSettings) {
   if (model.api !== "openai-codex-responses")
@@ -118017,19 +118016,23 @@ class PiStreamAdapter {
     const headers = resolvePiRequestHeaders({
       provider: resolved2.model.provider,
       configuredHeaders: resolved2.headers,
-      conversationId: input.conversationId
+      conversationId: input.conversationId,
+      requestKind: "turn"
     });
+    const maxTokens = finiteNumberValue(input.agent.model_settings.max_tokens);
+    const temperature = finiteNumberValue(input.agent.model_settings.temperature);
     const options = {
       ...resolved2.providerOptions,
       ...resolved2.apiKey ? { apiKey: resolved2.apiKey } : {},
       ...resolved2.timeout !== false ? { timeoutMs: resolved2.timeout } : {},
-      ...headers ? { headers } : {},
+      headers,
       ...this.abortSignal ? { signal: this.abortSignal } : {},
       maxRetries: 0,
       sessionId: input.conversationId,
       ...isRecord2(input.agent.model_settings.sampling_params) ? { samplingParams: input.agent.model_settings.sampling_params } : {},
       ...reasoning ? { reasoning } : {},
-      ...maxTokensForSettings(input.agent.model_settings) ? { maxTokens: maxTokensForSettings(input.agent.model_settings) } : {},
+      ...maxTokens ? { maxTokens } : {},
+      ...temperature !== undefined ? { temperature } : {},
       ...serviceTierForSettings(resolved2.model, input.agent.model_settings) ? {
         serviceTier: serviceTierForSettings(resolved2.model, input.agent.model_settings)
       } : {},
@@ -118037,6 +118040,19 @@ class PiStreamAdapter {
         parallelToolCalls: boolValue(input.agent.model_settings.parallel_tool_calls)
       } : {}
     };
+    const verbosity = input.agent.model_settings.verbosity;
+    if ((resolved2.model.api === "openai-responses" || resolved2.model.api === "openai-codex-responses") && (verbosity === "low" || verbosity === "medium" || verbosity === "high")) {
+      const existing = options.onPayload;
+      options.onPayload = async (payload, model) => {
+        const next = await existing?.(payload, model) ?? payload;
+        if (!isRecord2(next))
+          return next;
+        return {
+          ...next,
+          text: { ...isRecord2(next.text) ? next.text : {}, verbosity }
+        };
+      };
+    }
     if (resolved2.model.api === "openai-responses") {
       options.onPayload = withOpenAIResponsesReplayIdSanitizer(options.onPayload);
     }
@@ -161584,7 +161600,21 @@ var init_shared_agent_listing = __esm(() => {
   init_request();
 });
 
+// src/utils/stdin.ts
+function readStdin() {
+  return new Promise((resolve12, reject2) => {
+    let value = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk2) => {
+      value += chunk2;
+    });
+    process.stdin.on("end", () => resolve12(value));
+    process.stdin.on("error", reject2);
+  });
+}
+
 // src/cli/subcommands/agents.ts
+import { readFile as readFile6 } from "node:fs/promises";
 import { parseArgs as parseArgs2 } from "node:util";
 function printUsage() {
   console.log(`
@@ -161608,8 +161638,12 @@ Create Options:
   --description <text>  Agent description
   --tags <tag1,tag2>    Tags (comma-separated)
   --pinned              Pin the created agent globally
+  --body <path>         Create from a JSON agent create request instead of the
+                        options above ("-" reads stdin)
 
-  Creates a memfs-enabled agent with persona.md pre-populated.
+  Creates a memfs-enabled agent with persona.md pre-populated. With --body, the
+  request's system prompt, model settings, compaction settings, memory blocks,
+  and tags are used as given.
 
 Notes:
   - Output is JSON only.
@@ -161661,8 +161695,44 @@ async function runAgentsSubcommand(argv) {
   printUsage();
   return 1;
 }
+async function readCreateBody(source) {
+  const text2 = source === "-" ? await readStdin() : await readFile6(source, "utf8");
+  const body3 = JSON.parse(text2);
+  if (!body3 || typeof body3 !== "object" || Array.isArray(body3)) {
+    throw new Error("--body must contain a JSON object");
+  }
+  return body3;
+}
+async function createAgentFromBody(source) {
+  const { prepareRawCreateAgentBodyForMemfs: prepareRawCreateAgentBodyForMemfs2, enableMemfsIfCloud: enableMemfsIfCloud2 } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
+  const body3 = await prepareRawCreateAgentBodyForMemfs2(await readCreateBody(source));
+  const agent = await getBackend().createAgent(body3);
+  await enableMemfsIfCloud2(agent.id, { agentTags: agent.tags });
+  return agent.id;
+}
+async function printCreatedAgent(agentId, pinned) {
+  if (pinned) {
+    settingsManager.pinAgent(agentId);
+  }
+  const updatedAgent = await getBackend().retrieveAgent(agentId);
+  console.log(JSON.stringify(updatedAgent, null, 2));
+  return 0;
+}
 async function runCreateAction(values4) {
   await settingsManager.initialize();
+  if (typeof values4.body === "string") {
+    const conflicting = BODY_EXCLUSIVE_OPTIONS.filter((option2) => values4[option2] !== undefined);
+    if (conflicting.length > 0) {
+      console.error(`--body cannot be combined with ${conflicting.map((option2) => `--${option2}`).join(", ")}`);
+      return 1;
+    }
+    try {
+      return await printCreatedAgent(await createAgentFromBody(values4.body), Boolean(values4.pinned));
+    } catch (error4) {
+      console.error(error4 instanceof Error ? error4.message : String(error4));
+      return 1;
+    }
+  }
   const personalityInput = values4.personality;
   const personality = personalityInput ? resolvePersonalityId(personalityInput) : undefined;
   if (personalityInput && !personality) {
@@ -161702,12 +161772,7 @@ async function runCreateAction(values4) {
         agentTags: result2.agent.tags
       });
     }
-    if (values4.pinned) {
-      settingsManager.pinAgent(agentId);
-    }
-    const updatedAgent = await getBackend().retrieveAgent(agentId);
-    console.log(JSON.stringify(updatedAgent, null, 2));
-    return 0;
+    return await printCreatedAgent(agentId, Boolean(values4.pinned));
   } catch (error4) {
     console.error(error4 instanceof Error ? error4.message : String(error4));
     return 1;
@@ -161766,7 +161831,7 @@ async function runListAction(values4) {
     return 1;
   }
 }
-var AGENTS_OPTIONS;
+var AGENTS_OPTIONS, BODY_EXCLUSIVE_OPTIONS;
 var init_agents7 = __esm(() => {
   init_create5();
   init_personality();
@@ -161787,8 +161852,16 @@ var init_agents7 = __esm(() => {
     model: { type: "string" },
     personality: { type: "string" },
     description: { type: "string" },
-    pinned: { type: "boolean" }
+    pinned: { type: "boolean" },
+    body: { type: "string" }
   };
+  BODY_EXCLUSIVE_OPTIONS = [
+    "name",
+    "model",
+    "personality",
+    "description",
+    "tags"
+  ];
 });
 
 // src/cli/subcommands/backend.ts
@@ -164589,6 +164662,13 @@ import {
 function isWindowsCommandShim(command) {
   return /\.(?:cmd|bat)$/i.test(command);
 }
+function getCommandProcessFactory({
+  nativeSpawn = spawn5,
+  platform: platform4 = process.platform,
+  windowsSpawn = import_cross_spawn.default
+} = {}) {
+  return platform4 === "win32" ? windowsSpawn : nativeSpawn;
+}
 function getPackageManagerProcessFactory({
   nativeSpawn = spawn5,
   platform: platform4 = process.platform,
@@ -169755,7 +169835,7 @@ var init_attachment_download = __esm(() => {
 });
 
 // src/channels/slack/file-upload.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { basename as basename12, extname as extname4 } from "node:path";
 function resolveUploadMimeType(filePath) {
   switch (extname4(filePath).toLowerCase()) {
@@ -169782,7 +169862,7 @@ async function uploadSlackFile(slackClient, msg) {
   if (!msg.mediaPath) {
     throw new Error("mediaPath is required for Slack file uploads.");
   }
-  const buffer = await readFile6(msg.mediaPath);
+  const buffer = await readFile7(msg.mediaPath);
   const uploadFileName = msg.fileName ?? basename12(msg.mediaPath);
   const uploadTitle = msg.title ?? uploadFileName;
   const uploadMimeType = resolveUploadMimeType(uploadFileName);
@@ -193322,8 +193402,8 @@ var require_CronFileParser = __commonJS((exports) => {
 
   class CronFileParser {
     static async parseFile(filePath) {
-      const { readFile: readFile7 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
-      const data = await readFile7(filePath, "utf8");
+      const { readFile: readFile8 } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+      const data = await readFile8(filePath, "utf8");
       return CronFileParser.#parseContent(data);
     }
     static parseFileSync(filePath) {
@@ -211550,7 +211630,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.34.30"
+    version: "0.34.32"
   };
 });
 
@@ -213670,7 +213750,7 @@ import {
   rmSync as rmSync9,
   writeFileSync as writeFileSync21
 } from "node:fs";
-import { link as link3, mkdir as mkdir8, readFile as readFile7, rm as rm5, writeFile as writeFile9 } from "node:fs/promises";
+import { link as link3, mkdir as mkdir8, readFile as readFile8, rm as rm5, writeFile as writeFile9 } from "node:fs/promises";
 import path10 from "node:path";
 function hasErrorCode(error5, code2) {
   return typeof error5 === "object" && error5 !== null && "code" in error5 && error5.code === code2;
@@ -213703,7 +213783,7 @@ function getRecoverableLockTokenSync(lockPath) {
 }
 async function getRecoverableLockToken(lockPath) {
   try {
-    const ownerToken = await readFile7(lockPath, "utf-8");
+    const ownerToken = await readFile8(lockPath, "utf-8");
     return isLockOwnerProcessAlive(ownerToken) ? null : ownerToken;
   } catch {
     return null;
@@ -213812,7 +213892,7 @@ async function recoverStaleLock(lockPath, staleToken, recoveryOwner) {
         return false;
       let claimOwner;
       try {
-        claimOwner = await readFile7(claimPath, "utf-8");
+        claimOwner = await readFile8(claimPath, "utf-8");
       } catch {
         return false;
       }
@@ -213829,7 +213909,7 @@ async function recoverStaleLock(lockPath, staleToken, recoveryOwner) {
       }
       return false;
     }
-    if (await readFile7(lockPath, "utf-8") !== staleToken)
+    if (await readFile8(lockPath, "utf-8") !== staleToken)
       return false;
     await rm5(lockPath, { force: true });
     return true;
@@ -213870,7 +213950,7 @@ async function reclaimAbandonedLock(lockPath, allowDuringAcquisition = false) {
   if (acquisitionInProgress && !allowDuringAcquisition)
     return false;
   try {
-    if (await readFile7(handle2.lockPath, "utf-8") !== handle2.ownerToken) {
+    if (await readFile8(handle2.lockPath, "utf-8") !== handle2.ownerToken) {
       abandonedLock = null;
       return false;
     }
@@ -214003,7 +214083,7 @@ async function releaseRemoteSettingsLock(handle2) {
     return;
   let released = false;
   try {
-    if (await readFile7(handle2.lockPath, "utf-8") !== handle2.ownerToken) {
+    if (await readFile8(handle2.lockPath, "utf-8") !== handle2.ownerToken) {
       released = true;
     } else {
       await rm5(handle2.lockPath, { force: true });
@@ -214052,7 +214132,7 @@ import {
   rmSync as rmSync10,
   writeFileSync as writeFileSync22
 } from "node:fs";
-import { readFile as readFile8, rm as rm6, writeFile as writeFile10 } from "node:fs/promises";
+import { readFile as readFile9, rm as rm6, writeFile as writeFile10 } from "node:fs/promises";
 import path11 from "node:path";
 function getRemoteSettingsPath() {
   return path11.join(resolveGlobalConfigDir(), "remote-settings.json");
@@ -214215,7 +214295,7 @@ function readCurrentRemoteSettingsSync(settingsPath) {
 }
 async function readCurrentRemoteSettings(settingsPath) {
   try {
-    const settings3 = JSON.parse(await readFile8(settingsPath, "utf-8"));
+    const settings3 = JSON.parse(await readFile9(settingsPath, "utf-8"));
     const repairJournals = readCwdRepairJournals(settingsPath);
     return {
       repairJournals,
@@ -216284,7 +216364,7 @@ var WriteStdin_default = "Writes characters to an existing unified exec session
 var init_WriteStdin = () => {};
 
 // src/utils/text-files.ts
-import { readFile as readFile9, writeFile as writeFile11 } from "node:fs/promises";
+import { readFile as readFile10, writeFile as writeFile11 } from "node:fs/promises";
 function getUtf16Bom(bytes) {
   if (bytes.length < 2)
     return null;
@@ -216312,7 +216392,7 @@ function decodeUtf8TextStrict(bytes, filePath) {
   }
 }
 async function readUtf8TextStrict(filePath) {
-  const bytes = await readFile9(filePath);
+  const bytes = await readFile10(filePath);
   return decodeUtf8TextStrict(bytes, filePath);
 }
 async function writeUtf8Text(filePath, content) {
@@ -217083,7 +217163,7 @@ var init_manager = __esm(() => {
 });
 
 // src/tools/impl/artifact-files.ts
-import { mkdir as mkdir9, readFile as readFile10, stat as stat5, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile11, stat as stat5, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname18, isAbsolute as isAbsolute10, join as join46, relative as relative4, resolve as resolve15 } from "node:path";
 function assertArtifactsExperimentEnabled(toolName2) {
   if (!experimentManager.isEnabled("artifacts")) {
@@ -217140,7 +217220,7 @@ async function read_artifact_file(args) {
   if (stats.size > MAX_READ_FILE_BYTES) {
     throw new Error(`read_artifact_file: file is too large to read (${stats.size} bytes)`);
   }
-  const buffer = await readFile10(absolutePath);
+  const buffer = await readFile11(absolutePath);
   return {
     path: relativePath,
     content: buffer.toString(encoding),
@@ -229375,6 +229455,673 @@ var init_analyzer = __esm(() => {
   ];
 });
 
+// src/agent/mcp-originator-authority-file.ts
+import { createHash as createHash9, randomUUID as randomUUID32 } from "node:crypto";
+import {
+  closeSync as closeSync7,
+  existsSync as existsSync39,
+  fsyncSync as fsyncSync3,
+  mkdirSync as mkdirSync32,
+  openSync as openSync7,
+  readFileSync as readFileSync35,
+  renameSync as renameSync10,
+  unlinkSync as unlinkSync10,
+  writeFileSync as writeFileSync26
+} from "node:fs";
+import { dirname as dirname25, join as join55 } from "node:path";
+function isValidGeneration(generation4) {
+  return typeof generation4 === "number" && Number.isSafeInteger(generation4) && generation4 >= 0;
+}
+function isValidUpdatedAtMs(updatedAtMs, nowMs) {
+  return typeof updatedAtMs === "number" && Number.isSafeInteger(updatedAtMs) && updatedAtMs >= 0 && updatedAtMs <= nowMs + UPDATED_AT_FUTURE_SKEW_MS;
+}
+function authorityPersistentPath() {
+  if (persistencePathOverride !== undefined)
+    return persistencePathOverride;
+  if (false)
+    ;
+  let serverUrl;
+  try {
+    serverUrl = getServerUrl();
+  } catch {
+    serverUrl = process.env.LETTA_BASE_URL ?? "uninitialized";
+  }
+  return authorityPersistentPathForServer(serverUrl);
+}
+function authorityPersistentPathForServer(serverUrl) {
+  const namespace = createHash9("sha256").update(serverUrl).digest("hex").slice(0, 24);
+  return join55(resolveGlobalConfigDir(), "state", namespace, "mcp-originator-authority-v1.json");
+}
+function mergeRetirementIntents(a2, b3) {
+  if (a2 === undefined)
+    return b3;
+  if (b3 === undefined)
+    return a2;
+  return STATE_RANK[a2] >= STATE_RANK[b3] ? a2 : b3;
+}
+function mergeRecords(a2, b3) {
+  if (!b3)
+    return a2;
+  const floor2 = Math.max(a2.floor ?? -1, b3.floor ?? -1);
+  const state2 = STATE_RANK[a2.state] >= STATE_RANK[b3.state] ? a2.state : b3.state;
+  const retiringTo = state2 === "live" ? mergeRetirementIntents(a2.retiringTo, b3.retiringTo) : undefined;
+  return {
+    ...floor2 >= 0 ? { floor: floor2 } : {},
+    state: state2,
+    ...retiringTo !== undefined ? { retiringTo } : {},
+    updatedAtMs: Math.max(a2.updatedAtMs, b3.updatedAtMs)
+  };
+}
+function readAuthorityRecords(path18) {
+  const records = new Map;
+  if (!existsSync39(path18))
+    return { records, degraded: false };
+  try {
+    const parsed = JSON.parse(readFileSync35(path18, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || typeof parsed.records !== "object" || parsed.records === null || Array.isArray(parsed.records))
+      return { records, degraded: true };
+    const nowMs = Date.now();
+    for (const [runId, record6] of Object.entries(parsed.records)) {
+      const retiringTo = record6?.retiringTo;
+      if (record6 && (record6.state === "live" || record6.state === "headerless" || record6.state === "terminal") && (retiringTo === undefined || retiringTo === "headerless" || retiringTo === "terminal") && isValidUpdatedAtMs(record6.updatedAtMs, nowMs) && (record6.floor === undefined || isValidGeneration(record6.floor))) {
+        records.set(runId, {
+          ...record6.floor !== undefined ? { floor: record6.floor } : {},
+          state: record6.state,
+          ...record6.state === "live" && retiringTo !== undefined ? { retiringTo } : {},
+          updatedAtMs: record6.updatedAtMs
+        });
+      } else {
+        return { records, degraded: true };
+      }
+    }
+    return { records, degraded: false };
+  } catch {
+    return { records, degraded: true };
+  }
+}
+function writeAuthorityRecords(path18, records) {
+  mkdirSync32(dirname25(path18), { recursive: true, mode: 448 });
+  const file = {
+    version: 1,
+    records: Object.fromEntries(records)
+  };
+  const tmp = `${path18}.${process.pid}.${randomUUID32()}.tmp`;
+  try {
+    writeFileSync26(tmp, JSON.stringify(file), { mode: 384, flag: "wx" });
+    const fd = openSync7(tmp, "r+");
+    try {
+      fsyncSync3(fd);
+    } finally {
+      closeSync7(fd);
+    }
+    renameSync10(tmp, path18);
+    fsyncDirectory(dirname25(path18));
+  } catch (error5) {
+    try {
+      unlinkSync10(tmp);
+    } catch {}
+    throw error5;
+  }
+}
+var UPDATED_AT_FUTURE_SKEW_MS, persistencePathOverride, STATE_RANK;
+var init_mcp_originator_authority_file = __esm(() => {
+  init_server_url();
+  init_settings_path();
+  init_durable_file_lock();
+  UPDATED_AT_FUTURE_SKEW_MS = 24 * 60 * 60 * 1000;
+  STATE_RANK = {
+    live: 0,
+    headerless: 1,
+    terminal: 2
+  };
+});
+
+// src/agent/mcp-originator-authority.ts
+import { mkdirSync as mkdirSync33 } from "node:fs";
+import { dirname as dirname26 } from "node:path";
+function pruneExpired(nowMs) {
+  let pruned = false;
+  for (const [runId, record6] of recordsBySuperRunId) {
+    if (nowMs - record6.updatedAtMs > recordTtlMs) {
+      recordsBySuperRunId.delete(runId);
+      pruned = true;
+    }
+  }
+  return pruned;
+}
+function authorityTransaction(mutate) {
+  const path18 = authorityPersistentPath();
+  if (!path18) {
+    return mutate(recordsBySuperRunId, { degraded: false }).result;
+  }
+  mkdirSync33(dirname26(path18), { recursive: true, mode: 448 });
+  const release = acquireDurableFileLock(path18, { waitMs: 2000 });
+  try {
+    const { records: disk, degraded } = readAuthorityRecords(path18);
+    if (!degraded) {
+      const memory3 = new Map(recordsBySuperRunId);
+      recordsBySuperRunId.clear();
+      for (const [runId, record6] of disk) {
+        recordsBySuperRunId.set(runId, mergeRecords(record6, memory3.get(runId)) ?? record6);
+      }
+      for (const [runId, record6] of memory3) {
+        if (!disk.has(runId))
+          recordsBySuperRunId.set(runId, record6);
+      }
+      pruneExpired(Date.now());
+      resumeDurableRetirementIntents();
+    }
+    const { result: result2, changed } = mutate(recordsBySuperRunId, { degraded });
+    if (changed && !degraded)
+      writeAuthorityRecords(path18, recordsBySuperRunId);
+    return result2;
+  } finally {
+    release();
+  }
+}
+function mutateDurableFirst(label, mutate) {
+  if (!authorityPersistentPath()) {
+    mutate(recordsBySuperRunId);
+    return true;
+  }
+  for (let attempt2 = 1;attempt2 <= 3; attempt2 += 1) {
+    try {
+      const persisted = authorityTransaction((records, ctx) => {
+        if (ctx.degraded)
+          return { result: false, changed: false };
+        mutate(records);
+        return { result: true, changed: true };
+      });
+      if (persisted)
+        return true;
+      console.error(`[mcp-originator-authority] durable file is degraded for ${label}; the boundary holds in this process but is NOT durable across restart`);
+      mutate(recordsBySuperRunId);
+      return false;
+    } catch (error5) {
+      console.error(`[mcp-originator-authority] durable write failed for ${label} (attempt ${attempt2}/3)`, error5);
+    }
+  }
+  console.error(`[mcp-originator-authority] durable write failed for ${label} after retries; the boundary still holds in this process but is NOT durable across restart`);
+  mutate(recordsBySuperRunId);
+  return false;
+}
+function scheduleRetirementRetry() {
+  if (pendingRetirements.size === 0)
+    return;
+  if (retirementRetryTimer !== undefined)
+    return;
+  if (false)
+    ;
+  retirementRetryTimer = setTimeout(() => {
+    retirementRetryTimer = undefined;
+    retryPendingMcpOriginatorRetirements();
+  }, retirementRetryIntervalMs);
+  retirementRetryTimer.unref?.();
+}
+function retryPendingMcpOriginatorRetirements() {
+  const nowMs = Date.now();
+  let processed = 0;
+  for (const [runId, pending2] of pendingRetirements) {
+    if (nowMs - pending2.createdAtMs > recordTtlMs) {
+      console.error(`[mcp-originator-authority] pending ${pending2.state} retirement for ${runId} outlived the ${Math.round(recordTtlMs / 60000)}-minute record TTL; dropping the retry (any token it fenced is dead at the server-side ceiling)`);
+      pendingRetirements.delete(runId);
+      continue;
+    }
+    if (processed >= MAX_RETIREMENT_RETRIES_PER_TICK) {
+      continue;
+    }
+    processed += 1;
+    const durable = mutateDurableFirst(`retirement retry (${pending2.state}) for ${runId}`, (records) => touchRecords(records, runId, pending2.generation, pending2.state, {
+      preserveUpdatedAt: true
+    }));
+    if (durable)
+      pendingRetirements.delete(runId);
+  }
+  if (pendingRetirements.size > 0)
+    scheduleRetirementRetry();
+}
+function persistRetirementIntent(runId, state2, generation4) {
+  const path18 = authorityPersistentPath();
+  if (!path18)
+    return;
+  try {
+    const release = acquireDurableFileLock(path18, { waitMs: 2000 });
+    try {
+      const { records: disk, degraded } = readAuthorityRecords(path18);
+      if (degraded) {
+        console.error(`[mcp-originator-authority] durable file is degraded for the retirement intent (${state2}) for ${runId}; the boundary holds in this process only`);
+        return;
+      }
+      const existing = disk.get(runId);
+      if (existing && existing.state !== "live")
+        return;
+      const floor2 = generation4 !== undefined && isValidGeneration(generation4) ? Math.max(existing?.floor ?? -1, generation4) : existing?.floor;
+      disk.set(runId, {
+        ...floor2 !== undefined && floor2 >= 0 ? { floor: floor2 } : {},
+        state: "live",
+        retiringTo: mergeRetirementIntents(existing?.retiringTo, state2) ?? state2,
+        updatedAtMs: existing?.updatedAtMs ?? Date.now()
+      });
+      writeAuthorityRecords(path18, disk);
+    } finally {
+      release();
+    }
+  } catch (error5) {
+    console.error(`[mcp-originator-authority] durable retirement intent (${state2}) write failed for ${runId}; peers cannot see the boundary until a retry lands the mark`, error5);
+  }
+}
+function resumeDurableRetirementIntents() {
+  for (const [runId, record6] of recordsBySuperRunId) {
+    if (record6.state !== "live" || record6.retiringTo === undefined)
+      continue;
+    const existing = pendingRetirements.get(runId);
+    if (existing && existing.createdAtMs <= record6.updatedAtMs)
+      continue;
+    pendingRetirements.set(runId, {
+      state: record6.retiringTo,
+      ...record6.floor !== undefined ? { generation: record6.floor } : {},
+      createdAtMs: Math.min(existing?.createdAtMs ?? record6.updatedAtMs, record6.updatedAtMs)
+    });
+  }
+  scheduleRetirementRetry();
+}
+function registerPendingRetirement(runId, state2, generation4, durable) {
+  if (durable) {
+    const pending2 = pendingRetirements.get(runId);
+    if (pending2 && STATE_RANK[pending2.state] <= STATE_RANK[state2]) {
+      pendingRetirements.delete(runId);
+    }
+    return;
+  }
+  persistRetirementIntent(runId, state2, generation4);
+  const existing = pendingRetirements.get(runId);
+  const merged = {
+    state: existing && STATE_RANK[existing.state] > STATE_RANK[state2] ? existing.state : state2,
+    createdAtMs: existing?.createdAtMs ?? Date.now()
+  };
+  const mergedGeneration = generation4 ?? existing?.generation;
+  if (mergedGeneration !== undefined)
+    merged.generation = mergedGeneration;
+  pendingRetirements.set(runId, merged);
+  scheduleRetirementRetry();
+}
+function touchRecords(records, runId, generation4, state2, options) {
+  const existing = records.get(runId);
+  const usableGeneration = generation4 !== undefined && isValidGeneration(generation4) ? generation4 : undefined;
+  const floor2 = usableGeneration === undefined ? existing?.floor : Math.max(existing?.floor ?? -1, usableGeneration);
+  const nextState = state2 === undefined ? existing?.state ?? "live" : existing?.state !== undefined && STATE_RANK[existing.state] > STATE_RANK[state2] ? existing.state : state2;
+  records.set(runId, {
+    ...floor2 !== undefined ? { floor: floor2 } : {},
+    state: nextState,
+    ...nextState === "live" && existing?.retiringTo !== undefined ? { retiringTo: existing.retiringTo } : {},
+    updatedAtMs: options?.preserveUpdatedAt === true && existing !== undefined ? existing.updatedAtMs : Date.now()
+  });
+}
+function admitMcpOriginatorDelivery(runId, generation4) {
+  if (generation4 !== undefined && !isValidGeneration(generation4)) {
+    console.error(`[mcp-originator-authority] malformed generation for ${runId}; denying admission (fail-closed)`);
+    return { admitted: false, permanent: true };
+  }
+  if (!authorityPersistentPath()) {
+    const record6 = recordsBySuperRunId.get(runId);
+    if (record6) {
+      if (record6.state !== "live" || record6.retiringTo !== undefined)
+        return { admitted: false, permanent: true };
+      if (record6.floor !== undefined && (generation4 === undefined || generation4 < record6.floor))
+        return { admitted: false, permanent: true };
+    }
+    touchRecords(recordsBySuperRunId, runId, generation4);
+    return { admitted: true };
+  }
+  try {
+    return authorityTransaction((records, ctx) => {
+      if (ctx.degraded) {
+        console.error(`[mcp-originator-authority] durable file is degraded; denying admission for ${runId} (fail-closed, retryable)`);
+        return {
+          result: { admitted: false, permanent: false },
+          changed: false
+        };
+      }
+      const record6 = records.get(runId);
+      if (record6) {
+        if (record6.state !== "live" || record6.retiringTo !== undefined)
+          return {
+            result: { admitted: false, permanent: true },
+            changed: false
+          };
+        if (record6.floor !== undefined && (generation4 === undefined || generation4 < record6.floor))
+          return {
+            result: { admitted: false, permanent: true },
+            changed: false
+          };
+      }
+      touchRecords(records, runId, generation4);
+      return { result: { admitted: true }, changed: true };
+    });
+  } catch (error5) {
+    console.error(`[mcp-originator-authority] admission transaction failed for ${runId}; denying the delivery (fail-closed, retryable)`, error5);
+    return { admitted: false, permanent: false };
+  }
+}
+function mcpOriginatorAuthorityPermitsUse(runId, generation4) {
+  if (generation4 !== undefined && !isValidGeneration(generation4)) {
+    console.error(`[mcp-originator-authority] malformed generation for ${runId}; withdrawing the token (fail-closed)`);
+    return false;
+  }
+  try {
+    return authorityTransaction((records, ctx) => {
+      if (ctx.degraded)
+        return { result: false, changed: false };
+      const record6 = records.get(runId);
+      if (!record6)
+        return { result: true, changed: false };
+      if (record6.state !== "live" || record6.retiringTo !== undefined)
+        return { result: false, changed: false };
+      if (record6.floor !== undefined && generation4 !== undefined && generation4 < record6.floor)
+        return { result: false, changed: false };
+      return { result: true, changed: false };
+    });
+  } catch (error5) {
+    console.error(`[mcp-originator-authority] use check failed for ${runId}; withdrawing the token (fail-closed)`, error5);
+    return false;
+  }
+}
+function markMcpOriginatorHeaderless(runId, deletedGeneration) {
+  const durable = mutateDurableFirst(`headerless mark for ${runId}`, (records) => touchRecords(records, runId, deletedGeneration, "headerless"));
+  registerPendingRetirement(runId, "headerless", deletedGeneration, durable);
+  return durable;
+}
+function markMcpOriginatorTerminal(runId, deletedGeneration) {
+  const durable = mutateDurableFirst(`terminal mark for ${runId}`, (records) => touchRecords(records, runId, deletedGeneration, "terminal"));
+  registerPendingRetirement(runId, "terminal", deletedGeneration, durable);
+  return durable;
+}
+var AUTHORITY_RECORD_TTL_MS, recordTtlMs, recordsBySuperRunId, pendingRetirements, retirementRetryTimer, retirementRetryIntervalMs = 30000, MAX_RETIREMENT_RETRIES_PER_TICK = 25;
+var init_mcp_originator_authority = __esm(() => {
+  init_durable_file_lock();
+  init_mcp_originator_authority_file();
+  AUTHORITY_RECORD_TTL_MS = 2 * 60 * 60 * 1000;
+  recordTtlMs = AUTHORITY_RECORD_TTL_MS;
+  recordsBySuperRunId = new Map;
+  pendingRetirements = new Map;
+});
+
+// src/agent/mcp-originator-keepalive.ts
+async function runKeepaliveTick(superRunId) {
+  const entry = keepalives.get(superRunId);
+  if (!entry || entry.ticking)
+    return;
+  const token2 = entry.hooks?.getToken();
+  if (!token2) {
+    stopMcpOriginatorKeepalive(superRunId);
+    return;
+  }
+  entry.ticking = true;
+  try {
+    const result2 = await verifyWithHardBound(token2, verifyTimeoutMs);
+    if (entry.hooks?.getToken() !== token2) {
+      return;
+    }
+    entry.consecutiveFailures = 0;
+    if (!result2.valid) {
+      console.warn(`[mcp-originator-keepalive] server denied the originator token for super run ${superRunId}; withdrawing it (turn continues unattributed)`);
+      entry.hooks?.withdraw();
+      stopMcpOriginatorKeepalive(superRunId);
+      return;
+    }
+  } catch (error5) {
+    if (entry.hooks?.getToken() !== token2) {
+      return;
+    }
+    entry.consecutiveFailures += 1;
+    if (entry.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+      console.error(`[mcp-originator-keepalive] renewal failed ${entry.consecutiveFailures} times for super run ${superRunId}; stopping renewal (the server-side TTL now bounds the token):`, error5 instanceof Error ? error5.message : error5);
+      stopMcpOriginatorKeepalive(superRunId);
+      return;
+    }
+  } finally {
+    entry.ticking = false;
+    if (schedulingEnabled && keepalives.get(superRunId) === entry) {
+      const delay3 = entry.verifyAsap ? 0 : nextDelayMs(entry.consecutiveFailures);
+      entry.verifyAsap = false;
+      entry.timer = setTimeout(() => {
+        runKeepaliveTick(superRunId);
+      }, delay3);
+      entry.timer?.unref();
+    }
+  }
+}
+function nextDelayMs(consecutiveFailures) {
+  if (consecutiveFailures <= 0)
+    return intervalMs;
+  const lastDelay = FAILURE_RETRY_DELAYS_MS[FAILURE_RETRY_DELAYS_MS.length - 1];
+  return FAILURE_RETRY_DELAYS_MS[Math.min(consecutiveFailures, FAILURE_RETRY_DELAYS_MS.length) - 1] ?? lastDelay ?? intervalMs;
+}
+function verifyWithHardBound(token2, budgetMs) {
+  return new Promise((resolve27, reject2) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      reject2(new Error(`[mcp-originator-keepalive] verify exceeded the ${budgetMs}ms hard bound`));
+    }, budgetMs);
+    verifyImpl(token2, AbortSignal.timeout(budgetMs)).then((result2) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve27(result2);
+    }, (error5) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      reject2(error5 instanceof Error ? error5 : new Error(String(error5)));
+    });
+  });
+}
+function startMcpOriginatorKeepalive(superRunId, hooks) {
+  const existing = keepalives.get(superRunId);
+  if (existing) {
+    existing.hooks = hooks;
+    existing.consecutiveFailures = 0;
+    existing.verifyAsap = true;
+    if (schedulingEnabled && !existing.ticking) {
+      clearTimeout(existing.timer);
+      existing.verifyAsap = false;
+      existing.timer = setTimeout(() => {
+        runKeepaliveTick(superRunId);
+      }, 0);
+      existing.timer?.unref();
+    }
+    return;
+  }
+  const entry = {
+    timer: schedulingEnabled ? setTimeout(() => {
+      runKeepaliveTick(superRunId);
+    }, 0) : undefined,
+    consecutiveFailures: 0,
+    ticking: false,
+    verifyAsap: false,
+    hooks
+  };
+  entry.timer?.unref();
+  keepalives.set(superRunId, entry);
+}
+function stopMcpOriginatorKeepalive(superRunId) {
+  const entry = keepalives.get(superRunId);
+  if (!entry)
+    return;
+  clearTimeout(entry.timer);
+  keepalives.delete(superRunId);
+}
+function stopAllMcpOriginatorKeepalives() {
+  for (const runId of [...keepalives.keys()]) {
+    stopMcpOriginatorKeepalive(runId);
+  }
+}
+var DEFAULT_KEEPALIVE_INTERVAL_MS = 120000, MAX_CONSECUTIVE_FAILURES = 3, FAILURE_RETRY_DELAYS_MS, VERIFY_TIMEOUT_MS = 30000, defaultVerify = async (token2, signal) => apiRequest("POST", "/v1/mcp-originator-tokens/verify", { token: token2 }, { signal }), verifyImpl, intervalMs, verifyTimeoutMs, keepalives, schedulingEnabled = true;
+var init_mcp_originator_keepalive = __esm(() => {
+  init_request();
+  FAILURE_RETRY_DELAYS_MS = [15000, 30000];
+  verifyImpl = defaultVerify;
+  intervalMs = DEFAULT_KEEPALIVE_INTERVAL_MS;
+  verifyTimeoutMs = VERIFY_TIMEOUT_MS;
+  keepalives = new Map;
+});
+
+// src/agent/mcp-originator-tokens.ts
+function getMcpOriginatorToken(superRunId) {
+  if (!superRunId)
+    return;
+  const entry = entriesBySuperRunId.get(superRunId);
+  if (!entry || entry.token === null)
+    return;
+  if (!mcpOriginatorAuthorityPermitsUse(superRunId, entry.generation)) {
+    deleteMcpOriginatorToken(superRunId);
+    return;
+  }
+  return entry.token;
+}
+function deleteMcpOriginatorToken(superRunId) {
+  entriesBySuperRunId.delete(superRunId);
+  stopMcpOriginatorKeepalive(superRunId);
+}
+function keepaliveHooks(superRunId) {
+  return {
+    getToken: () => getMcpOriginatorToken(superRunId),
+    withdraw: () => deleteMcpOriginatorToken(superRunId)
+  };
+}
+function clearMcpOriginatorTokens() {
+  entriesBySuperRunId.clear();
+  stopAllMcpOriginatorKeepalives();
+}
+function readMcpOriginatorDelivery(payload) {
+  const wire = typeof payload === "object" && payload !== null ? payload : {};
+  const superRunId = typeof wire.super_run_id === "string" && wire.super_run_id.length > 0 ? wire.super_run_id : undefined;
+  const token2 = typeof wire.mcp_originator_token === "string" && wire.mcp_originator_token.length > 0 ? wire.mcp_originator_token : undefined;
+  const generation4 = typeof wire.mcp_originator_generation === "number" && Number.isInteger(wire.mcp_originator_generation) && wire.mcp_originator_generation >= 0 && Number.isSafeInteger(wire.mcp_originator_generation) ? wire.mcp_originator_generation : undefined;
+  return {
+    ...superRunId ? { superRunId } : {},
+    ...token2 ? { token: token2 } : {},
+    ...generation4 !== undefined ? { generation: generation4 } : {},
+    ...wire.mcp_originator_generation !== undefined && generation4 === undefined ? { malformedGeneration: true } : {}
+  };
+}
+function deliveryIsAtLeastAsNew(existing, incomingGeneration) {
+  if (existing.generation === undefined)
+    return true;
+  if (incomingGeneration === undefined)
+    return false;
+  return incomingGeneration >= existing.generation;
+}
+function denyMalformedGeneration(frame, delivery, context3) {
+  const rawGeneration = frame?.mcp_originator_generation;
+  console.error(`[MCP originator] run ${delivery.superRunId}: ${context3}denying delivery with malformed generation (type=${typeof rawGeneration}${typeof rawGeneration === "string" ? ` length=${rawGeneration.length}` : ""})`);
+  return "denied_permanent";
+}
+function installPreGatedMcpOriginatorDelivery(delivery, options) {
+  if (!delivery.superRunId || delivery.malformedGeneration)
+    return;
+  const existing = entriesBySuperRunId.get(delivery.superRunId);
+  if (delivery.token) {
+    if (existing) {
+      if (!deliveryIsAtLeastAsNew(existing, delivery.generation))
+        return;
+    } else if (options?.allowCreate === false && options?.mayRecreateOwner?.() !== true) {
+      return;
+    }
+    entriesBySuperRunId.set(delivery.superRunId, {
+      token: delivery.token,
+      ...delivery.generation !== undefined ? { generation: delivery.generation } : existing?.generation !== undefined ? { generation: existing.generation } : {}
+    });
+    startMcpOriginatorKeepalive(delivery.superRunId, keepaliveHooks(delivery.superRunId));
+    return;
+  }
+  if (!existing)
+    return;
+  if (!deliveryIsAtLeastAsNew(existing, delivery.generation))
+    return;
+  entriesBySuperRunId.set(delivery.superRunId, {
+    token: null,
+    ...delivery.generation !== undefined ? { generation: delivery.generation } : existing.generation !== undefined ? { generation: existing.generation } : {}
+  });
+  stopMcpOriginatorKeepalive(delivery.superRunId);
+}
+function recordMcpOriginatorDelivery(frame, options) {
+  const delivery = readMcpOriginatorDelivery(frame);
+  if (!delivery.superRunId)
+    return "none";
+  if (delivery.malformedGeneration) {
+    return denyMalformedGeneration(frame, delivery, "");
+  }
+  const admission = admitMcpOriginatorDelivery(delivery.superRunId, delivery.generation);
+  if (!admission.admitted) {
+    return admission.permanent ? "denied_permanent" : "denied_retryable";
+  }
+  installPreGatedMcpOriginatorDelivery(delivery, options);
+  return "admitted";
+}
+function gateMcpOriginatorDeliveryAdmission(frame) {
+  const delivery = readMcpOriginatorDelivery(frame);
+  if (!delivery.superRunId)
+    return { verdict: "none" };
+  if (delivery.malformedGeneration) {
+    return {
+      verdict: denyMalformedGeneration(frame, delivery, "pre-commit gate ")
+    };
+  }
+  const admission = admitMcpOriginatorDelivery(delivery.superRunId, delivery.generation);
+  if (!admission.admitted) {
+    return {
+      verdict: admission.permanent ? "denied_permanent" : "denied_retryable"
+    };
+  }
+  return { verdict: "admitted", delivery };
+}
+function retireMcpOriginatorTokensOnOriginSwap(turnSuperRunId, queuedSuperRunId) {
+  if (queuedSuperRunId === turnSuperRunId)
+    return;
+  for (const runId of [turnSuperRunId, queuedSuperRunId]) {
+    if (!runId)
+      continue;
+    const generation4 = entriesBySuperRunId.get(runId)?.generation;
+    if (markMcpOriginatorHeaderless(runId, generation4)) {
+      deleteMcpOriginatorToken(runId);
+    } else {
+      console.error(`[mcp-originator-tokens] headerless mark for ${runId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
+    }
+  }
+}
+function retireMcpOriginatorTokenOnTerminal(superRunId) {
+  if (!superRunId)
+    return;
+  const generation4 = entriesBySuperRunId.get(superRunId)?.generation;
+  if (markMcpOriginatorTerminal(superRunId, generation4)) {
+    deleteMcpOriginatorToken(superRunId);
+  } else {
+    console.error(`[mcp-originator-tokens] terminal mark for ${superRunId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
+  }
+}
+function retireMcpOriginatorTokenOnMixedMerge(superRunId) {
+  if (!superRunId)
+    return;
+  const generation4 = entriesBySuperRunId.get(superRunId)?.generation;
+  if (markMcpOriginatorHeaderless(superRunId, generation4)) {
+    deleteMcpOriginatorToken(superRunId);
+  } else {
+    console.error(`[mcp-originator-tokens] mixed-merge headerless mark for ${superRunId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
+  }
+}
+var entriesBySuperRunId;
+var init_mcp_originator_tokens = __esm(() => {
+  init_mcp_originator_authority();
+  init_mcp_originator_keepalive();
+  entriesBySuperRunId = new Map;
+});
+
 // src/utils/message-image-normalization.ts
 function isSupportedBase64ImageMediaType(mediaType) {
   return SUPPORTED_BASE64_IMAGE_MEDIA_TYPES.has(mediaType);
@@ -229717,13 +230464,13 @@ var init_approval_result_normalization = __esm(() => {
 
 // src/agent/client-skills-watcher.ts
 import {
-  existsSync as existsSync39,
+  existsSync as existsSync40,
   readdirSync as readdirSync14,
   realpathSync as realpathSync8,
   statSync as statSync18,
   watch as watch2
 } from "node:fs";
-import { dirname as dirname25, relative as relative6, resolve as resolve27, sep as sep7 } from "node:path";
+import { dirname as dirname27, relative as relative6, resolve as resolve27, sep as sep7 } from "node:path";
 function defaultWatchFunction(path18, options, listener) {
   return watch2(path18, options, listener);
 }
@@ -229737,7 +230484,7 @@ function isDirectory(path18) {
 function findNearestExistingDirectory(path18) {
   let candidate = resolve27(path18);
   while (!isDirectory(candidate)) {
-    const parent = dirname25(candidate);
+    const parent = dirname27(candidate);
     if (parent === candidate) {
       return null;
     }
@@ -229817,7 +230564,7 @@ class ClientSkillsWatcher {
     const watchPaths = new Set;
     let recursive = false;
     let awaitedChild = null;
-    if (existsSync39(root2)) {
+    if (existsSync40(root2)) {
       recursive = true;
       watchPaths.add(root2);
       collectSymlinkDirectoryTargets(root2, watchPaths, new Set);
@@ -229870,16 +230617,16 @@ __export(exports_skills2, {
   SKILLS_DIR: () => SKILLS_DIR,
   PROJECT_SKILLS_DIR: () => PROJECT_SKILLS_DIR
 });
-import { existsSync as existsSync40 } from "node:fs";
-import { readdir as readdir4, readFile as readFile11, realpath as realpath3, stat as stat6 } from "node:fs/promises";
-import { dirname as dirname26, join as join55 } from "node:path";
+import { existsSync as existsSync41 } from "node:fs";
+import { readdir as readdir4, readFile as readFile12, realpath as realpath3, stat as stat6 } from "node:fs/promises";
+import { dirname as dirname28, join as join56 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function getBundledSkillsPath() {
-  const thisDir = dirname26(fileURLToPath6(import.meta.url));
+  const thisDir = dirname28(fileURLToPath6(import.meta.url));
   if (thisDir.includes("src/agent") || thisDir.includes("src\\agent")) {
-    return join55(thisDir, "../skills/builtin");
+    return join56(thisDir, "../skills/builtin");
   }
-  return join55(thisDir, "skills");
+  return join56(thisDir, "skills");
 }
 function compareSkills(a2, b3) {
   return a2.id.localeCompare(b3.id) || a2.source.localeCompare(b3.source) || a2.path.localeCompare(b3.path);
@@ -229926,10 +230673,10 @@ function isSkillAvailableForAgent(skill, agentId) {
   return true;
 }
 function getGlobalSkillsDir(env6 = process.env) {
-  return join55(resolveGlobalStateDir(env6, env6.HOME || env6.USERPROFILE || "~"), "skills");
+  return join56(resolveGlobalStateDir(env6, env6.HOME || env6.USERPROFILE || "~"), "skills");
 }
 function getAgentSkillsDir(agentId) {
-  return join55(resolveGlobalStateDir(), "agents", agentId, "memory/skills");
+  return join56(resolveGlobalStateDir(), "agents", agentId, "memory/skills");
 }
 async function getBundledSkills() {
   const bundledPath = getBundledSkillsPath();
@@ -229938,7 +230685,7 @@ async function getBundledSkills() {
 }
 async function discoverSkillsFromDir(skillsPath, source) {
   const errors6 = [];
-  if (!existsSync40(skillsPath)) {
+  if (!existsSync41(skillsPath)) {
     return { skills: [], errors: [] };
   }
   const skills = [];
@@ -229952,7 +230699,7 @@ async function discoverSkillsFromDir(skillsPath, source) {
   }
   return { skills, errors: errors6 };
 }
-async function discoverSkills(projectSkillsPath = join55(process.cwd(), SKILLS_DIR), agentId, options) {
+async function discoverSkills(projectSkillsPath = join56(process.cwd(), SKILLS_DIR), agentId, options) {
   const allErrors = [];
   const skillsById = new Map;
   const sourceSet = new Set(options?.sources ?? ALL_SKILL_SOURCES);
@@ -230007,7 +230754,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors6, source, vi
   try {
     const entries = await readdir4(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join55(currentPath, entry.name);
+      const fullPath = join56(currentPath, entry.name);
       try {
         let isDirectory2 = entry.isDirectory();
         let isFile = entry.isFile();
@@ -230046,7 +230793,7 @@ async function findSkillFiles(currentPath, rootPath, skills, errors6, source, vi
   }
 }
 async function parseSkillFile(filePath, rootPath, source) {
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile12(filePath, "utf-8");
   const { frontmatter, body: body3 } = parseFrontmatter(content);
   const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
   const relativePath = filePath.slice(normalizedRoot.length + 1);
@@ -230107,12 +230854,12 @@ var init_skills5 = __esm(() => {
     "video-generation",
     "working-across-computers"
   ]);
-  PROJECT_SKILLS_DIR = join55(".agents", "skills");
+  PROJECT_SKILLS_DIR = join56(".agents", "skills");
 });
 
 // src/agent/shared-memory-skills.ts
-import { existsSync as existsSync41 } from "node:fs";
-import { dirname as dirname27, join as join56 } from "node:path";
+import { existsSync as existsSync42 } from "node:fs";
+import { dirname as dirname29, join as join57 } from "node:path";
 function getAttachedRepositoriesCache() {
   const global2 = globalThis;
   if (!global2[ATTACHED_REPOSITORIES_CACHE_KEY]) {
@@ -230187,7 +230934,7 @@ async function resolveSharedMemorySkillsContext(options) {
   for (const repository of repositories.sort((a2, b3) => a2.name.localeCompare(b3.name) || a2.id.localeCompare(b3.id))) {
     try {
       const repositoryName = validateAgentRepositoryName2(repository.name);
-      skillsDirs.push(join56(getRepositoryMountDir2(agentId, repositoryName), "skills"));
+      skillsDirs.push(join57(getRepositoryMountDir2(agentId, repositoryName), "skills"));
     } catch (error5) {
       errors6.push({
         path: `shared-memory:${repository.name}`,
@@ -230201,10 +230948,10 @@ async function discoverSharedMemorySkills(skillsDirs) {
   const skillsById = new Map;
   const errors6 = [];
   for (const dir of skillsDirs) {
-    const repositoryMount = dirname27(dir);
+    const repositoryMount = dirname29(dir);
     if (isCheckoutPending(repositoryMount))
       continue;
-    if (!existsSync41(repositoryMount)) {
+    if (!existsSync42(repositoryMount)) {
       errors6.push({
         path: repositoryMount,
         message: "Attached repository is not mounted locally"
@@ -230250,8 +230997,8 @@ __export(exports_client_skills, {
   buildClientSkillsUpdateReminder: () => buildClientSkillsUpdateReminder,
   buildClientSkillsPayload: () => buildClientSkillsPayload
 });
-import { existsSync as existsSync42 } from "node:fs";
-import { join as join57, resolve as resolve28 } from "node:path";
+import { existsSync as existsSync43 } from "node:fs";
+import { join as join58, resolve as resolve28 } from "node:path";
 function getCache2() {
   const global2 = globalThis;
   if (!global2[CLIENT_SKILLS_CACHE_KEY]) {
@@ -230379,12 +231126,12 @@ function buildClientSkillsUpdateReminder(previous, current) {
 function getMemorySkillsDirs(agentId) {
   const dirs = new Set;
   const scopedMemoryDir = resolveScopedMemoryDir({ agentId });
-  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync42(scopedMemoryDir)) {
-    dirs.add(join57(scopedMemoryDir.trim(), "skills"));
+  if (scopedMemoryDir && scopedMemoryDir.trim().length > 0 && existsSync43(scopedMemoryDir)) {
+    dirs.add(join58(scopedMemoryDir.trim(), "skills"));
   } else {
     const fallbackMemoryDir = (process.env.LETTA_MEMORY_DIR || process.env.MEMORY_DIR || "").trim();
     if (fallbackMemoryDir) {
-      dirs.add(join57(fallbackMemoryDir, "skills"));
+      dirs.add(join58(fallbackMemoryDir, "skills"));
     }
   }
   return Array.from(dirs);
@@ -230426,8 +231173,8 @@ function toClientSkill(skill) {
 function resolveSkillDiscoveryContext(options) {
   const workingDirectory = options.workingDirectory ?? process.cwd();
   const configuredSkillsDirectory = options.skillsDirectory ?? getSkillsDirectory();
-  const legacySkillsDirectory = join57(workingDirectory, SKILLS_DIR);
-  const primaryProjectSkillsDirectory = join57(workingDirectory, PROJECT_SKILLS_DIR);
+  const legacySkillsDirectory = join58(workingDirectory, SKILLS_DIR);
+  const primaryProjectSkillsDirectory = join58(workingDirectory, PROJECT_SKILLS_DIR);
   const skillSources = options.skillSources ?? getSkillSources();
   const bundledSkills = skillSources.includes("bundled") ? undefined : options.bundledSkills ?? getBundledSkillAllowlist();
   return {
@@ -230894,6 +231641,13 @@ async function sendMessageStreamWithBackend(backend3, conversationId, messages,
   if (actingUserId) {
     extraHeaders[ACTING_USER_ID_HEADER] = actingUserId;
   }
+  const originatorSuperRunId = executionRuntimeContext ? executionRuntimeContext.mcpOriginatorSuperRunId : getRuntimeContext()?.mcpOriginatorSuperRunId;
+  const originatorToken = getMcpOriginatorToken(originatorSuperRunId);
+  if (originatorToken && originatorSuperRunId) {
+    extraHeaders[MCP_ORIGINATOR_TOKEN_HEADER] = originatorToken;
+    extraHeaders[MCP_ORIGINATOR_ISOLATION_HEADER] = "1";
+    extraHeaders[MCP_ORIGINATOR_SUPER_RUN_HEADER] = originatorSuperRunId;
+  }
   const messageSummary = normalizedMessages.map((item) => {
     if (item.type === "approval") {
       return `approval:${item.approvals?.length ?? 0}`;
@@ -230963,9 +231717,10 @@ async function sendMessageStreamWithBackend(backend3, conversationId, messages,
   });
   return stream11;
 }
-var streamRequestStartTimes, streamToolContextIds, RESPONSE_STATE_HEADER = "X-Letta-Response-State", RESPONSE_STATE_CACHE_SCOPE = "approval_boundary", CLOUD_API_SHUTDOWN_MAX_RETRIES = 3, CLOUD_API_SHUTDOWN_DEFAULT_RETRY_DELAY_MS = 1000, responseStateIdsByScope, sentClientSkillsByBackend, streamRequestContexts;
+var streamRequestStartTimes, streamToolContextIds, RESPONSE_STATE_HEADER = "X-Letta-Response-State", RESPONSE_STATE_CACHE_SCOPE = "approval_boundary", MCP_ORIGINATOR_TOKEN_HEADER = "x-letta-mcp-originator-token", MCP_ORIGINATOR_ISOLATION_HEADER = "x-letta-mcp-originator-isolation", MCP_ORIGINATOR_SUPER_RUN_HEADER = "x-letta-mcp-originator-super-run-id", CLOUD_API_SHUTDOWN_MAX_RETRIES = 3, CLOUD_API_SHUTDOWN_DEFAULT_RETRY_DELAY_MS = 1000, responseStateIdsByScope, sentClientSkillsByBackend, streamRequestContexts;
 var init_message = __esm(async () => {
   init_error();
+  init_mcp_originator_tokens();
   init_backend2();
   init_disk_space();
   init_runtime_context();
@@ -232382,673 +233137,6 @@ var init_manager2 = __esm(async () => {
   MOD_SECRET_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 });
 
-// src/agent/mcp-originator-authority-file.ts
-import { createHash as createHash9, randomUUID as randomUUID32 } from "node:crypto";
-import {
-  closeSync as closeSync7,
-  existsSync as existsSync43,
-  fsyncSync as fsyncSync3,
-  mkdirSync as mkdirSync32,
-  openSync as openSync7,
-  readFileSync as readFileSync35,
-  renameSync as renameSync10,
-  unlinkSync as unlinkSync10,
-  writeFileSync as writeFileSync26
-} from "node:fs";
-import { dirname as dirname28, join as join58 } from "node:path";
-function isValidGeneration(generation4) {
-  return typeof generation4 === "number" && Number.isSafeInteger(generation4) && generation4 >= 0;
-}
-function isValidUpdatedAtMs(updatedAtMs, nowMs) {
-  return typeof updatedAtMs === "number" && Number.isSafeInteger(updatedAtMs) && updatedAtMs >= 0 && updatedAtMs <= nowMs + UPDATED_AT_FUTURE_SKEW_MS;
-}
-function authorityPersistentPath() {
-  if (persistencePathOverride !== undefined)
-    return persistencePathOverride;
-  if (false)
-    ;
-  let serverUrl;
-  try {
-    serverUrl = getServerUrl();
-  } catch {
-    serverUrl = process.env.LETTA_BASE_URL ?? "uninitialized";
-  }
-  return authorityPersistentPathForServer(serverUrl);
-}
-function authorityPersistentPathForServer(serverUrl) {
-  const namespace = createHash9("sha256").update(serverUrl).digest("hex").slice(0, 24);
-  return join58(resolveGlobalConfigDir(), "state", namespace, "mcp-originator-authority-v1.json");
-}
-function mergeRetirementIntents(a2, b3) {
-  if (a2 === undefined)
-    return b3;
-  if (b3 === undefined)
-    return a2;
-  return STATE_RANK[a2] >= STATE_RANK[b3] ? a2 : b3;
-}
-function mergeRecords(a2, b3) {
-  if (!b3)
-    return a2;
-  const floor2 = Math.max(a2.floor ?? -1, b3.floor ?? -1);
-  const state2 = STATE_RANK[a2.state] >= STATE_RANK[b3.state] ? a2.state : b3.state;
-  const retiringTo = state2 === "live" ? mergeRetirementIntents(a2.retiringTo, b3.retiringTo) : undefined;
-  return {
-    ...floor2 >= 0 ? { floor: floor2 } : {},
-    state: state2,
-    ...retiringTo !== undefined ? { retiringTo } : {},
-    updatedAtMs: Math.max(a2.updatedAtMs, b3.updatedAtMs)
-  };
-}
-function readAuthorityRecords(path18) {
-  const records = new Map;
-  if (!existsSync43(path18))
-    return { records, degraded: false };
-  try {
-    const parsed = JSON.parse(readFileSync35(path18, "utf8"));
-    if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || typeof parsed.records !== "object" || parsed.records === null || Array.isArray(parsed.records))
-      return { records, degraded: true };
-    const nowMs = Date.now();
-    for (const [runId, record6] of Object.entries(parsed.records)) {
-      const retiringTo = record6?.retiringTo;
-      if (record6 && (record6.state === "live" || record6.state === "headerless" || record6.state === "terminal") && (retiringTo === undefined || retiringTo === "headerless" || retiringTo === "terminal") && isValidUpdatedAtMs(record6.updatedAtMs, nowMs) && (record6.floor === undefined || isValidGeneration(record6.floor))) {
-        records.set(runId, {
-          ...record6.floor !== undefined ? { floor: record6.floor } : {},
-          state: record6.state,
-          ...record6.state === "live" && retiringTo !== undefined ? { retiringTo } : {},
-          updatedAtMs: record6.updatedAtMs
-        });
-      } else {
-        return { records, degraded: true };
-      }
-    }
-    return { records, degraded: false };
-  } catch {
-    return { records, degraded: true };
-  }
-}
-function writeAuthorityRecords(path18, records) {
-  mkdirSync32(dirname28(path18), { recursive: true, mode: 448 });
-  const file = {
-    version: 1,
-    records: Object.fromEntries(records)
-  };
-  const tmp = `${path18}.${process.pid}.${randomUUID32()}.tmp`;
-  try {
-    writeFileSync26(tmp, JSON.stringify(file), { mode: 384, flag: "wx" });
-    const fd = openSync7(tmp, "r+");
-    try {
-      fsyncSync3(fd);
-    } finally {
-      closeSync7(fd);
-    }
-    renameSync10(tmp, path18);
-    fsyncDirectory(dirname28(path18));
-  } catch (error5) {
-    try {
-      unlinkSync10(tmp);
-    } catch {}
-    throw error5;
-  }
-}
-var UPDATED_AT_FUTURE_SKEW_MS, persistencePathOverride, STATE_RANK;
-var init_mcp_originator_authority_file = __esm(() => {
-  init_server_url();
-  init_settings_path();
-  init_durable_file_lock();
-  UPDATED_AT_FUTURE_SKEW_MS = 24 * 60 * 60 * 1000;
-  STATE_RANK = {
-    live: 0,
-    headerless: 1,
-    terminal: 2
-  };
-});
-
-// src/agent/mcp-originator-authority.ts
-import { mkdirSync as mkdirSync33 } from "node:fs";
-import { dirname as dirname29 } from "node:path";
-function pruneExpired(nowMs) {
-  let pruned = false;
-  for (const [runId, record6] of recordsBySuperRunId) {
-    if (nowMs - record6.updatedAtMs > recordTtlMs) {
-      recordsBySuperRunId.delete(runId);
-      pruned = true;
-    }
-  }
-  return pruned;
-}
-function authorityTransaction(mutate) {
-  const path18 = authorityPersistentPath();
-  if (!path18) {
-    return mutate(recordsBySuperRunId, { degraded: false }).result;
-  }
-  mkdirSync33(dirname29(path18), { recursive: true, mode: 448 });
-  const release = acquireDurableFileLock(path18, { waitMs: 2000 });
-  try {
-    const { records: disk, degraded } = readAuthorityRecords(path18);
-    if (!degraded) {
-      const memory3 = new Map(recordsBySuperRunId);
-      recordsBySuperRunId.clear();
-      for (const [runId, record6] of disk) {
-        recordsBySuperRunId.set(runId, mergeRecords(record6, memory3.get(runId)) ?? record6);
-      }
-      for (const [runId, record6] of memory3) {
-        if (!disk.has(runId))
-          recordsBySuperRunId.set(runId, record6);
-      }
-      pruneExpired(Date.now());
-      resumeDurableRetirementIntents();
-    }
-    const { result: result2, changed } = mutate(recordsBySuperRunId, { degraded });
-    if (changed && !degraded)
-      writeAuthorityRecords(path18, recordsBySuperRunId);
-    return result2;
-  } finally {
-    release();
-  }
-}
-function mutateDurableFirst(label, mutate) {
-  if (!authorityPersistentPath()) {
-    mutate(recordsBySuperRunId);
-    return true;
-  }
-  for (let attempt2 = 1;attempt2 <= 3; attempt2 += 1) {
-    try {
-      const persisted = authorityTransaction((records, ctx) => {
-        if (ctx.degraded)
-          return { result: false, changed: false };
-        mutate(records);
-        return { result: true, changed: true };
-      });
-      if (persisted)
-        return true;
-      console.error(`[mcp-originator-authority] durable file is degraded for ${label}; the boundary holds in this process but is NOT durable across restart`);
-      mutate(recordsBySuperRunId);
-      return false;
-    } catch (error5) {
-      console.error(`[mcp-originator-authority] durable write failed for ${label} (attempt ${attempt2}/3)`, error5);
-    }
-  }
-  console.error(`[mcp-originator-authority] durable write failed for ${label} after retries; the boundary still holds in this process but is NOT durable across restart`);
-  mutate(recordsBySuperRunId);
-  return false;
-}
-function scheduleRetirementRetry() {
-  if (pendingRetirements.size === 0)
-    return;
-  if (retirementRetryTimer !== undefined)
-    return;
-  if (false)
-    ;
-  retirementRetryTimer = setTimeout(() => {
-    retirementRetryTimer = undefined;
-    retryPendingMcpOriginatorRetirements();
-  }, retirementRetryIntervalMs);
-  retirementRetryTimer.unref?.();
-}
-function retryPendingMcpOriginatorRetirements() {
-  const nowMs = Date.now();
-  let processed = 0;
-  for (const [runId, pending2] of pendingRetirements) {
-    if (nowMs - pending2.createdAtMs > recordTtlMs) {
-      console.error(`[mcp-originator-authority] pending ${pending2.state} retirement for ${runId} outlived the ${Math.round(recordTtlMs / 60000)}-minute record TTL; dropping the retry (any token it fenced is dead at the server-side ceiling)`);
-      pendingRetirements.delete(runId);
-      continue;
-    }
-    if (processed >= MAX_RETIREMENT_RETRIES_PER_TICK) {
-      continue;
-    }
-    processed += 1;
-    const durable = mutateDurableFirst(`retirement retry (${pending2.state}) for ${runId}`, (records) => touchRecords(records, runId, pending2.generation, pending2.state, {
-      preserveUpdatedAt: true
-    }));
-    if (durable)
-      pendingRetirements.delete(runId);
-  }
-  if (pendingRetirements.size > 0)
-    scheduleRetirementRetry();
-}
-function persistRetirementIntent(runId, state2, generation4) {
-  const path18 = authorityPersistentPath();
-  if (!path18)
-    return;
-  try {
-    const release = acquireDurableFileLock(path18, { waitMs: 2000 });
-    try {
-      const { records: disk, degraded } = readAuthorityRecords(path18);
-      if (degraded) {
-        console.error(`[mcp-originator-authority] durable file is degraded for the retirement intent (${state2}) for ${runId}; the boundary holds in this process only`);
-        return;
-      }
-      const existing = disk.get(runId);
-      if (existing && existing.state !== "live")
-        return;
-      const floor2 = generation4 !== undefined && isValidGeneration(generation4) ? Math.max(existing?.floor ?? -1, generation4) : existing?.floor;
-      disk.set(runId, {
-        ...floor2 !== undefined && floor2 >= 0 ? { floor: floor2 } : {},
-        state: "live",
-        retiringTo: mergeRetirementIntents(existing?.retiringTo, state2) ?? state2,
-        updatedAtMs: existing?.updatedAtMs ?? Date.now()
-      });
-      writeAuthorityRecords(path18, disk);
-    } finally {
-      release();
-    }
-  } catch (error5) {
-    console.error(`[mcp-originator-authority] durable retirement intent (${state2}) write failed for ${runId}; peers cannot see the boundary until a retry lands the mark`, error5);
-  }
-}
-function resumeDurableRetirementIntents() {
-  for (const [runId, record6] of recordsBySuperRunId) {
-    if (record6.state !== "live" || record6.retiringTo === undefined)
-      continue;
-    const existing = pendingRetirements.get(runId);
-    if (existing && existing.createdAtMs <= record6.updatedAtMs)
-      continue;
-    pendingRetirements.set(runId, {
-      state: record6.retiringTo,
-      ...record6.floor !== undefined ? { generation: record6.floor } : {},
-      createdAtMs: Math.min(existing?.createdAtMs ?? record6.updatedAtMs, record6.updatedAtMs)
-    });
-  }
-  scheduleRetirementRetry();
-}
-function registerPendingRetirement(runId, state2, generation4, durable) {
-  if (durable) {
-    const pending2 = pendingRetirements.get(runId);
-    if (pending2 && STATE_RANK[pending2.state] <= STATE_RANK[state2]) {
-      pendingRetirements.delete(runId);
-    }
-    return;
-  }
-  persistRetirementIntent(runId, state2, generation4);
-  const existing = pendingRetirements.get(runId);
-  const merged = {
-    state: existing && STATE_RANK[existing.state] > STATE_RANK[state2] ? existing.state : state2,
-    createdAtMs: existing?.createdAtMs ?? Date.now()
-  };
-  const mergedGeneration = generation4 ?? existing?.generation;
-  if (mergedGeneration !== undefined)
-    merged.generation = mergedGeneration;
-  pendingRetirements.set(runId, merged);
-  scheduleRetirementRetry();
-}
-function touchRecords(records, runId, generation4, state2, options) {
-  const existing = records.get(runId);
-  const usableGeneration = generation4 !== undefined && isValidGeneration(generation4) ? generation4 : undefined;
-  const floor2 = usableGeneration === undefined ? existing?.floor : Math.max(existing?.floor ?? -1, usableGeneration);
-  const nextState = state2 === undefined ? existing?.state ?? "live" : existing?.state !== undefined && STATE_RANK[existing.state] > STATE_RANK[state2] ? existing.state : state2;
-  records.set(runId, {
-    ...floor2 !== undefined ? { floor: floor2 } : {},
-    state: nextState,
-    ...nextState === "live" && existing?.retiringTo !== undefined ? { retiringTo: existing.retiringTo } : {},
-    updatedAtMs: options?.preserveUpdatedAt === true && existing !== undefined ? existing.updatedAtMs : Date.now()
-  });
-}
-function admitMcpOriginatorDelivery(runId, generation4) {
-  if (generation4 !== undefined && !isValidGeneration(generation4)) {
-    console.error(`[mcp-originator-authority] malformed generation for ${runId}; denying admission (fail-closed)`);
-    return { admitted: false, permanent: true };
-  }
-  if (!authorityPersistentPath()) {
-    const record6 = recordsBySuperRunId.get(runId);
-    if (record6) {
-      if (record6.state !== "live" || record6.retiringTo !== undefined)
-        return { admitted: false, permanent: true };
-      if (record6.floor !== undefined && (generation4 === undefined || generation4 < record6.floor))
-        return { admitted: false, permanent: true };
-    }
-    touchRecords(recordsBySuperRunId, runId, generation4);
-    return { admitted: true };
-  }
-  try {
-    return authorityTransaction((records, ctx) => {
-      if (ctx.degraded) {
-        console.error(`[mcp-originator-authority] durable file is degraded; denying admission for ${runId} (fail-closed, retryable)`);
-        return {
-          result: { admitted: false, permanent: false },
-          changed: false
-        };
-      }
-      const record6 = records.get(runId);
-      if (record6) {
-        if (record6.state !== "live" || record6.retiringTo !== undefined)
-          return {
-            result: { admitted: false, permanent: true },
-            changed: false
-          };
-        if (record6.floor !== undefined && (generation4 === undefined || generation4 < record6.floor))
-          return {
-            result: { admitted: false, permanent: true },
-            changed: false
-          };
-      }
-      touchRecords(records, runId, generation4);
-      return { result: { admitted: true }, changed: true };
-    });
-  } catch (error5) {
-    console.error(`[mcp-originator-authority] admission transaction failed for ${runId}; denying the delivery (fail-closed, retryable)`, error5);
-    return { admitted: false, permanent: false };
-  }
-}
-function mcpOriginatorAuthorityPermitsUse(runId, generation4) {
-  if (generation4 !== undefined && !isValidGeneration(generation4)) {
-    console.error(`[mcp-originator-authority] malformed generation for ${runId}; withdrawing the token (fail-closed)`);
-    return false;
-  }
-  try {
-    return authorityTransaction((records, ctx) => {
-      if (ctx.degraded)
-        return { result: false, changed: false };
-      const record6 = records.get(runId);
-      if (!record6)
-        return { result: true, changed: false };
-      if (record6.state !== "live" || record6.retiringTo !== undefined)
-        return { result: false, changed: false };
-      if (record6.floor !== undefined && generation4 !== undefined && generation4 < record6.floor)
-        return { result: false, changed: false };
-      return { result: true, changed: false };
-    });
-  } catch (error5) {
-    console.error(`[mcp-originator-authority] use check failed for ${runId}; withdrawing the token (fail-closed)`, error5);
-    return false;
-  }
-}
-function markMcpOriginatorHeaderless(runId, deletedGeneration) {
-  const durable = mutateDurableFirst(`headerless mark for ${runId}`, (records) => touchRecords(records, runId, deletedGeneration, "headerless"));
-  registerPendingRetirement(runId, "headerless", deletedGeneration, durable);
-  return durable;
-}
-function markMcpOriginatorTerminal(runId, deletedGeneration) {
-  const durable = mutateDurableFirst(`terminal mark for ${runId}`, (records) => touchRecords(records, runId, deletedGeneration, "terminal"));
-  registerPendingRetirement(runId, "terminal", deletedGeneration, durable);
-  return durable;
-}
-var AUTHORITY_RECORD_TTL_MS, recordTtlMs, recordsBySuperRunId, pendingRetirements, retirementRetryTimer, retirementRetryIntervalMs = 30000, MAX_RETIREMENT_RETRIES_PER_TICK = 25;
-var init_mcp_originator_authority = __esm(() => {
-  init_durable_file_lock();
-  init_mcp_originator_authority_file();
-  AUTHORITY_RECORD_TTL_MS = 2 * 60 * 60 * 1000;
-  recordTtlMs = AUTHORITY_RECORD_TTL_MS;
-  recordsBySuperRunId = new Map;
-  pendingRetirements = new Map;
-});
-
-// src/agent/mcp-originator-keepalive.ts
-async function runKeepaliveTick(superRunId) {
-  const entry = keepalives.get(superRunId);
-  if (!entry || entry.ticking)
-    return;
-  const token2 = entry.hooks?.getToken();
-  if (!token2) {
-    stopMcpOriginatorKeepalive(superRunId);
-    return;
-  }
-  entry.ticking = true;
-  try {
-    const result2 = await verifyWithHardBound(token2, verifyTimeoutMs);
-    if (entry.hooks?.getToken() !== token2) {
-      return;
-    }
-    entry.consecutiveFailures = 0;
-    if (!result2.valid) {
-      console.warn(`[mcp-originator-keepalive] server denied the originator token for super run ${superRunId}; withdrawing it (turn continues unattributed)`);
-      entry.hooks?.withdraw();
-      stopMcpOriginatorKeepalive(superRunId);
-      return;
-    }
-  } catch (error5) {
-    if (entry.hooks?.getToken() !== token2) {
-      return;
-    }
-    entry.consecutiveFailures += 1;
-    if (entry.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-      console.error(`[mcp-originator-keepalive] renewal failed ${entry.consecutiveFailures} times for super run ${superRunId}; stopping renewal (the server-side TTL now bounds the token):`, error5 instanceof Error ? error5.message : error5);
-      stopMcpOriginatorKeepalive(superRunId);
-      return;
-    }
-  } finally {
-    entry.ticking = false;
-    if (schedulingEnabled && keepalives.get(superRunId) === entry) {
-      const delay3 = entry.verifyAsap ? 0 : nextDelayMs(entry.consecutiveFailures);
-      entry.verifyAsap = false;
-      entry.timer = setTimeout(() => {
-        runKeepaliveTick(superRunId);
-      }, delay3);
-      entry.timer?.unref();
-    }
-  }
-}
-function nextDelayMs(consecutiveFailures) {
-  if (consecutiveFailures <= 0)
-    return intervalMs;
-  const lastDelay = FAILURE_RETRY_DELAYS_MS[FAILURE_RETRY_DELAYS_MS.length - 1];
-  return FAILURE_RETRY_DELAYS_MS[Math.min(consecutiveFailures, FAILURE_RETRY_DELAYS_MS.length) - 1] ?? lastDelay ?? intervalMs;
-}
-function verifyWithHardBound(token2, budgetMs) {
-  return new Promise((resolve30, reject2) => {
-    let settled = false;
-    const timer = setTimeout(() => {
-      if (settled)
-        return;
-      settled = true;
-      reject2(new Error(`[mcp-originator-keepalive] verify exceeded the ${budgetMs}ms hard bound`));
-    }, budgetMs);
-    verifyImpl(token2, AbortSignal.timeout(budgetMs)).then((result2) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve30(result2);
-    }, (error5) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      reject2(error5 instanceof Error ? error5 : new Error(String(error5)));
-    });
-  });
-}
-function startMcpOriginatorKeepalive(superRunId, hooks) {
-  const existing = keepalives.get(superRunId);
-  if (existing) {
-    existing.hooks = hooks;
-    existing.consecutiveFailures = 0;
-    existing.verifyAsap = true;
-    if (schedulingEnabled && !existing.ticking) {
-      clearTimeout(existing.timer);
-      existing.verifyAsap = false;
-      existing.timer = setTimeout(() => {
-        runKeepaliveTick(superRunId);
-      }, 0);
-      existing.timer?.unref();
-    }
-    return;
-  }
-  const entry = {
-    timer: schedulingEnabled ? setTimeout(() => {
-      runKeepaliveTick(superRunId);
-    }, 0) : undefined,
-    consecutiveFailures: 0,
-    ticking: false,
-    verifyAsap: false,
-    hooks
-  };
-  entry.timer?.unref();
-  keepalives.set(superRunId, entry);
-}
-function stopMcpOriginatorKeepalive(superRunId) {
-  const entry = keepalives.get(superRunId);
-  if (!entry)
-    return;
-  clearTimeout(entry.timer);
-  keepalives.delete(superRunId);
-}
-function stopAllMcpOriginatorKeepalives() {
-  for (const runId of [...keepalives.keys()]) {
-    stopMcpOriginatorKeepalive(runId);
-  }
-}
-var DEFAULT_KEEPALIVE_INTERVAL_MS = 120000, MAX_CONSECUTIVE_FAILURES = 3, FAILURE_RETRY_DELAYS_MS, VERIFY_TIMEOUT_MS = 30000, defaultVerify = async (token2, signal) => apiRequest("POST", "/v1/mcp-originator-tokens/verify", { token: token2 }, { signal }), verifyImpl, intervalMs, verifyTimeoutMs, keepalives, schedulingEnabled = true;
-var init_mcp_originator_keepalive = __esm(() => {
-  init_request();
-  FAILURE_RETRY_DELAYS_MS = [15000, 30000];
-  verifyImpl = defaultVerify;
-  intervalMs = DEFAULT_KEEPALIVE_INTERVAL_MS;
-  verifyTimeoutMs = VERIFY_TIMEOUT_MS;
-  keepalives = new Map;
-});
-
-// src/agent/mcp-originator-tokens.ts
-function getMcpOriginatorToken(superRunId) {
-  if (!superRunId)
-    return;
-  const entry = entriesBySuperRunId.get(superRunId);
-  if (!entry || entry.token === null)
-    return;
-  if (!mcpOriginatorAuthorityPermitsUse(superRunId, entry.generation)) {
-    deleteMcpOriginatorToken(superRunId);
-    return;
-  }
-  return entry.token;
-}
-function deleteMcpOriginatorToken(superRunId) {
-  entriesBySuperRunId.delete(superRunId);
-  stopMcpOriginatorKeepalive(superRunId);
-}
-function keepaliveHooks(superRunId) {
-  return {
-    getToken: () => getMcpOriginatorToken(superRunId),
-    withdraw: () => deleteMcpOriginatorToken(superRunId)
-  };
-}
-function clearMcpOriginatorTokens() {
-  entriesBySuperRunId.clear();
-  stopAllMcpOriginatorKeepalives();
-}
-function readMcpOriginatorDelivery(payload) {
-  const wire = typeof payload === "object" && payload !== null ? payload : {};
-  const superRunId = typeof wire.super_run_id === "string" && wire.super_run_id.length > 0 ? wire.super_run_id : undefined;
-  const token2 = typeof wire.mcp_originator_token === "string" && wire.mcp_originator_token.length > 0 ? wire.mcp_originator_token : undefined;
-  const generation4 = typeof wire.mcp_originator_generation === "number" && Number.isInteger(wire.mcp_originator_generation) && wire.mcp_originator_generation >= 0 && Number.isSafeInteger(wire.mcp_originator_generation) ? wire.mcp_originator_generation : undefined;
-  return {
-    ...superRunId ? { superRunId } : {},
-    ...token2 ? { token: token2 } : {},
-    ...generation4 !== undefined ? { generation: generation4 } : {},
-    ...wire.mcp_originator_generation !== undefined && generation4 === undefined ? { malformedGeneration: true } : {}
-  };
-}
-function deliveryIsAtLeastAsNew(existing, incomingGeneration) {
-  if (existing.generation === undefined)
-    return true;
-  if (incomingGeneration === undefined)
-    return false;
-  return incomingGeneration >= existing.generation;
-}
-function denyMalformedGeneration(frame, delivery, context3) {
-  const rawGeneration = frame?.mcp_originator_generation;
-  console.error(`[MCP originator] run ${delivery.superRunId}: ${context3}denying delivery with malformed generation (type=${typeof rawGeneration}${typeof rawGeneration === "string" ? ` length=${rawGeneration.length}` : ""})`);
-  return "denied_permanent";
-}
-function installPreGatedMcpOriginatorDelivery(delivery, options) {
-  if (!delivery.superRunId || delivery.malformedGeneration)
-    return;
-  const existing = entriesBySuperRunId.get(delivery.superRunId);
-  if (delivery.token) {
-    if (existing) {
-      if (!deliveryIsAtLeastAsNew(existing, delivery.generation))
-        return;
-    } else if (options?.allowCreate === false && options?.mayRecreateOwner?.() !== true) {
-      return;
-    }
-    entriesBySuperRunId.set(delivery.superRunId, {
-      token: delivery.token,
-      ...delivery.generation !== undefined ? { generation: delivery.generation } : existing?.generation !== undefined ? { generation: existing.generation } : {}
-    });
-    startMcpOriginatorKeepalive(delivery.superRunId, keepaliveHooks(delivery.superRunId));
-    return;
-  }
-  if (!existing)
-    return;
-  if (!deliveryIsAtLeastAsNew(existing, delivery.generation))
-    return;
-  entriesBySuperRunId.set(delivery.superRunId, {
-    token: null,
-    ...delivery.generation !== undefined ? { generation: delivery.generation } : existing.generation !== undefined ? { generation: existing.generation } : {}
-  });
-  stopMcpOriginatorKeepalive(delivery.superRunId);
-}
-function recordMcpOriginatorDelivery(frame, options) {
-  const delivery = readMcpOriginatorDelivery(frame);
-  if (!delivery.superRunId)
-    return "none";
-  if (delivery.malformedGeneration) {
-    return denyMalformedGeneration(frame, delivery, "");
-  }
-  const admission = admitMcpOriginatorDelivery(delivery.superRunId, delivery.generation);
-  if (!admission.admitted) {
-    return admission.permanent ? "denied_permanent" : "denied_retryable";
-  }
-  installPreGatedMcpOriginatorDelivery(delivery, options);
-  return "admitted";
-}
-function gateMcpOriginatorDeliveryAdmission(frame) {
-  const delivery = readMcpOriginatorDelivery(frame);
-  if (!delivery.superRunId)
-    return { verdict: "none" };
-  if (delivery.malformedGeneration) {
-    return {
-      verdict: denyMalformedGeneration(frame, delivery, "pre-commit gate ")
-    };
-  }
-  const admission = admitMcpOriginatorDelivery(delivery.superRunId, delivery.generation);
-  if (!admission.admitted) {
-    return {
-      verdict: admission.permanent ? "denied_permanent" : "denied_retryable"
-    };
-  }
-  return { verdict: "admitted", delivery };
-}
-function retireMcpOriginatorTokensOnOriginSwap(turnSuperRunId, queuedSuperRunId) {
-  if (queuedSuperRunId === turnSuperRunId)
-    return;
-  for (const runId of [turnSuperRunId, queuedSuperRunId]) {
-    if (!runId)
-      continue;
-    const generation4 = entriesBySuperRunId.get(runId)?.generation;
-    if (markMcpOriginatorHeaderless(runId, generation4)) {
-      deleteMcpOriginatorToken(runId);
-    } else {
-      console.error(`[mcp-originator-tokens] headerless mark for ${runId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
-    }
-  }
-}
-function retireMcpOriginatorTokenOnTerminal(superRunId) {
-  if (!superRunId)
-    return;
-  const generation4 = entriesBySuperRunId.get(superRunId)?.generation;
-  if (markMcpOriginatorTerminal(superRunId, generation4)) {
-    deleteMcpOriginatorToken(superRunId);
-  } else {
-    console.error(`[mcp-originator-tokens] terminal mark for ${superRunId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
-  }
-}
-function retireMcpOriginatorTokenOnMixedMerge(superRunId) {
-  if (!superRunId)
-    return;
-  const generation4 = entriesBySuperRunId.get(superRunId)?.generation;
-  if (markMcpOriginatorHeaderless(superRunId, generation4)) {
-    deleteMcpOriginatorToken(superRunId);
-  } else {
-    console.error(`[mcp-originator-tokens] mixed-merge headerless mark for ${superRunId} is NOT durable; keeping the volatile entry (unusable in this process) so restart cannot resurrect authority`);
-  }
-}
-var entriesBySuperRunId;
-var init_mcp_originator_tokens = __esm(() => {
-  init_mcp_originator_authority();
-  init_mcp_originator_keepalive();
-  entriesBySuperRunId = new Map;
-});
-
 // src/backend/api/unified-mcp.ts
 var exports_unified_mcp = {};
 __export(exports_unified_mcp, {
@@ -233209,14 +233297,14 @@ async function runUnifiedMcpTool(params) {
     body: { args: params.args },
     ...params.originatorToken ? {
       headers: {
-        [MCP_ORIGINATOR_TOKEN_HEADER]: params.originatorToken,
-        [MCP_ORIGINATOR_ISOLATION_HEADER]: "1"
+        [MCP_ORIGINATOR_TOKEN_HEADER2]: params.originatorToken,
+        [MCP_ORIGINATOR_ISOLATION_HEADER2]: "1"
       }
     } : {}
   }), params.timeoutMs ?? 60000, "Running agent MCP tool");
   return parseRunResult(value);
 }
-var MCP_ORIGINATOR_TOKEN_HEADER = "x-letta-mcp-originator-token", MCP_ORIGINATOR_ISOLATION_HEADER = "x-letta-mcp-originator-isolation";
+var MCP_ORIGINATOR_TOKEN_HEADER2 = "x-letta-mcp-originator-token", MCP_ORIGINATOR_ISOLATION_HEADER2 = "x-letta-mcp-originator-isolation";
 var init_unified_mcp = () => {};
 
 // src/mcp-runtime.ts
@@ -233328,7 +233416,7 @@ var init_mcp_runtime = __esm(() => {
 });
 
 // src/cli/subcommands/mcp-io.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 function writeMcpOutput(stream11, message) {
   return new Promise((resolve30, reject2) => {
     let settled = false;
@@ -233425,20 +233513,9 @@ async function loadMcpToolArgs(inline, file, deps) {
     return parseJsonObject(inline, "Invalid --args JSON");
   if (!file)
     return {};
-  const raw2 = file === "-" ? await (deps.readStdin ?? readStdin)() : await (deps.readFile ?? ((path18) => readFile13(path18, "utf8")))(file);
+  const raw2 = file === "-" ? await (deps.readStdin ?? readStdin)() : await (deps.readFile ?? ((path18) => readFile14(path18, "utf8")))(file);
   return parseJsonObject(raw2, `Invalid arguments in ${file}`);
 }
-function readStdin() {
-  return new Promise((resolve30, reject2) => {
-    let value = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk2) => {
-      value += chunk2;
-    });
-    process.stdin.on("end", () => resolve30(value));
-    process.stdin.on("error", reject2);
-  });
-}
 function parseJsonObject(raw2, label) {
   let parsed;
   try {
@@ -235614,11 +235691,11 @@ var init_worktree_lock = __esm(() => {
 });
 
 // src/tools/impl/enter-worktree-messages.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import path19 from "node:path";
 async function readProjectInstructions(worktreePath) {
   try {
-    const content = (await readFile14(path19.join(worktreePath, "AGENTS.md"), "utf8")).trim();
+    const content = (await readFile15(path19.join(worktreePath, "AGENTS.md"), "utf8")).trim();
     if (!content)
       return null;
     const truncated = truncateByChars(content, LIMITS.READ_OUTPUT_CHARS, "EnterWorktree");
@@ -237904,7 +237981,7 @@ import {
   lstat,
   mkdir as mkdir10,
   readdir as readdir6,
-  readFile as readFile15,
+  readFile as readFile16,
   realpath as realpath4,
   rmdir,
   stat as stat8,
@@ -238013,7 +238090,7 @@ async function readProvisionConfig(primaryRoot) {
     include: []
   };
   try {
-    const raw2 = await readFile15(path22.join(primaryRoot, ".letta", "settings.json"), "utf8");
+    const raw2 = await readFile16(path22.join(primaryRoot, ".letta", "settings.json"), "utf8");
     const parsed = JSON.parse(raw2);
     const worktree = parsed.worktree;
     if (!worktree) {
@@ -238100,7 +238177,7 @@ async function copyLocalSettingsFile(primaryRoot, worktreePath) {
 }
 async function readWorktreeIncludeEntries(primaryRoot) {
   try {
-    const raw2 = await readFile15(path22.join(primaryRoot, ".worktreeinclude"), "utf8");
+    const raw2 = await readFile16(path22.join(primaryRoot, ".worktreeinclude"), "utf8");
     return raw2.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {
     return [];
@@ -243834,7 +243911,7 @@ async function terminateSubagentProcessTree(childProcess2, forceKillGraceMs) {
   await waitForProcessGroupExit(pid, FORCE_KILL_SETTLE_MS);
 }
 function spawnSubagentProcess(command, args, options) {
-  const childProcess2 = spawn10(command, args, {
+  const childProcess2 = getCommandProcessFactory()(command, args, {
     cwd: options.cwd,
     env: options.env,
     detached: process.platform !== "win32"
@@ -243878,7 +243955,9 @@ function spawnManagedWorkloadProcess(command, args, options) {
   return spawnSubagentProcess(managedCommand, managedArgs, options);
 }
 var DEFAULT_FORCE_KILL_GRACE_MS = 2000, FORCE_KILL_SETTLE_MS = 500, PROCESS_EXIT_POLL_MS = 20;
-var init_subagent_process = () => {};
+var init_subagent_process = __esm(() => {
+  init_package_manager_spawn();
+});
 
 // src/utils/native-cli-env.ts
 import { homedir as homedir17 } from "node:os";
@@ -244356,7 +244435,6 @@ var init_claude_stream_session = __esm(() => {
 });
 
 // src/tools/impl/codex-app-server.ts
-import { spawn as nodeSpawn } from "node:child_process";
 import { createInterface as createInterface9 } from "node:readline";
 async function listCodexModels(cwd2, env6) {
   const controller = new AbortController;
@@ -244377,6 +244455,11 @@ async function listCodexModels(cwd2, env6) {
     }))
   };
   const client = new CodexAppServerClient(transport3, () => {}, () => {});
+  let startError;
+  running.process.once("error", (error5) => {
+    startError = error5.code === "ENOENT" ? new Error("Required executable 'codex' was not found on PATH") : error5;
+    client.dispose();
+  });
   const timer = setTimeout(() => client.dispose(), 30000);
   try {
     await client.initialize();
@@ -244395,6 +244478,10 @@ async function listCodexModels(cwd2, env6) {
         cursors.add(cursor);
     } while (cursor);
     return models3;
+  } catch (error5) {
+    client.dispose();
+    await running.completion;
+    throw startError ?? error5;
   } finally {
     clearTimeout(timer);
     client.dispose();
@@ -244409,7 +244496,7 @@ function textInput(text2) {
 }
 function spawnTransport(options) {
   const [command = "codex", ...args] = wrapManagedWorkloadLauncher(["codex", "app-server", "--stdio"], { env: options.env });
-  const child = nodeSpawn(command, args, {
+  const child = getCommandProcessFactory()(command, args, {
     cwd: options.cwd,
     env: options.env,
     stdio: ["pipe", "pipe", "pipe"],
@@ -244419,7 +244506,7 @@ function spawnTransport(options) {
     stdin: child.stdin,
     stdout: child.stdout,
     stderr: child.stderr,
-    kill: () => child.kill(),
+    kill: () => process.platform === "win32" ? void killWindowsProcessTree(child) : child.kill(),
     exited: new Promise((resolve35) => {
       child.once("close", (code2, signal) => resolve35({ code: code2, signal }));
     })
@@ -244499,7 +244586,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.34.30"
+        version: "0.34.32"
       },
       capabilities: null
     });
@@ -244915,6 +245002,7 @@ var sessions2, sessionCreations, DEFAULT_IDLE_TIMEOUT_MS, CODEX_NOT_SIGNED_IN_ER
 var init_codex_app_server = __esm(() => {
   init_subagent_process();
   init_native_cli_env();
+  init_package_manager_spawn();
   sessions2 = new Map;
   sessionCreations = new Map;
   DEFAULT_IDLE_TIMEOUT_MS = 5 * 60000;
@@ -250024,12 +250112,12 @@ var init_manager4 = __esm(async () => {
 // src/agent/memory-conflict-repair.ts
 import { execFile as execFile15 } from "node:child_process";
 import { randomUUID as randomUUID42 } from "node:crypto";
-import { readFile as readFile16, rm as rm9, writeFile as writeFile13 } from "node:fs/promises";
+import { readFile as readFile17, rm as rm9, writeFile as writeFile13 } from "node:fs/promises";
 import { join as join68 } from "node:path";
 import { promisify as promisify15 } from "node:util";
 async function readOptional(path29) {
   try {
-    return (await readFile16(path29, "utf8")).trim();
+    return (await readFile17(path29, "utf8")).trim();
   } catch {
     return "";
   }
@@ -250070,7 +250158,7 @@ async function attemptPath(memoryDir) {
 }
 async function readAttempt(path29) {
   try {
-    return JSON.parse(await readFile16(path29, "utf8"));
+    return JSON.parse(await readFile17(path29, "utf8"));
   } catch {
     return {};
   }
@@ -252249,7 +252337,7 @@ __export(exports_skill, {
   getResolvedSkillsDir: () => getResolvedSkillsDir
 });
 import { existsSync as existsSync46, readdirSync as readdirSync17 } from "node:fs";
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 import { dirname as dirname30, join as join70 } from "node:path";
 async function readSkillFromRoot(skillsRoot, skillId) {
   const discovery = await discoverSkills(skillsRoot, undefined, {
@@ -252261,7 +252349,7 @@ async function readSkillFromRoot(skillsRoot, skillId) {
     return null;
   }
   try {
-    const content = await readFile17(discoveredSkill.path, "utf-8");
+    const content = await readFile18(discoveredSkill.path, "utf-8");
     return { content, path: discoveredSkill.path };
   } catch {
     return null;
@@ -252345,7 +252433,7 @@ async function readSkillContent(skillId, skillsDir, agentId, options = {}) {
   const sharedSkill = sharedMemoryDiscovery.skills.find((candidate) => candidate.id === skillId);
   if (sharedSkill) {
     try {
-      const content = await readFile17(sharedSkill.path, "utf-8");
+      const content = await readFile18(sharedSkill.path, "utf-8");
       return { content, path: sharedSkill.path };
     } catch {}
   }
@@ -252358,14 +252446,14 @@ async function readSkillContent(skillId, skillsDir, agentId, options = {}) {
   if (bundledSkill?.path && isSkillAvailableForAgent(bundledSkill, agentId)) {
     try {
       const path30 = bundledSkill.path;
-      const content = await readFile17(path30, "utf-8");
+      const content = await readFile18(path30, "utf-8");
       return { content, path: path30 };
     } catch {}
   }
   try {
     const bundledSkillsDir = join70(process.cwd(), "skills", "skills");
     const bundledSkillPath = join70(bundledSkillsDir, skillId, "SKILL.md");
-    const content = await readFile17(bundledSkillPath, "utf-8");
+    const content = await readFile18(bundledSkillPath, "utf-8");
     return { content, path: bundledSkillPath };
   } catch {
     throw new Error(`Skill "${skillId}" not found. Check that the skill name is correct and that it appears in the available skills list.`);
@@ -253991,7 +254079,7 @@ var init_sdk_loader = __esm(() => {
 });
 
 // src/agent/preloaded-skills.ts
-import { readFile as readFile18 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 async function loadPreloadedSkills(ids, options = {}) {
   if (ids.length === 0)
     return "";
@@ -254006,7 +254094,7 @@ async function loadPreloadedSkills(ids, options = {}) {
       continue;
     try {
       contents.push(`<${id2}>
-${await readFile18(path31, "utf-8")}
+${await readFile19(path31, "utf-8")}
 </${id2}>`);
     } catch {}
   }
@@ -263420,7 +263508,7 @@ var init_environments4 = __esm(() => {
 });
 
 // src/cli/subcommands/feedback.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 import { parseArgs as parseArgs8 } from "node:util";
 function printUsage6(stdout = console.log) {
   stdout(`
@@ -263470,7 +263558,7 @@ async function runFeedbackSubcommand(argv, deps = {}) {
   let rawMessage = typeof inlineMessage === "string" ? inlineMessage : "";
   if (typeof messageFile === "string") {
     try {
-      rawMessage = await (deps.readMessageFile ?? ((path32) => readFile19(path32, "utf8")))(messageFile);
+      rawMessage = await (deps.readMessageFile ?? ((path32) => readFile20(path32, "utf8")))(messageFile);
     } catch {
       stderr(`Could not read feedback file: ${messageFile}`);
       return 1;
@@ -265688,7 +265776,7 @@ var init_listen_log = __esm(() => {
 
 // src/utils/machine-metadata.ts
 import { execFile as execFile17 } from "node:child_process";
-import { readFile as readFile20 } from "node:fs/promises";
+import { readFile as readFile21 } from "node:fs/promises";
 import { cpus, totalmem } from "node:os";
 function getMachineMetadata() {
   machineMetadata ??= collectMachineMetadata().catch(() => ({
@@ -265703,7 +265791,7 @@ function localSources() {
     architecture: process.arch,
     cpu: cpus()[0]?.model,
     memoryBytes: Math.min(totalmem(), limit4 || Number.POSITIVE_INFINITY),
-    read: (path32, signal) => readFile20(path32, { encoding: "utf8", signal }),
+    read: (path32, signal) => readFile21(path32, { encoding: "utf8", signal }),
     run: (command, args, signal) => new Promise((resolve38, reject2) => {
       execFile17(command, args, {
         encoding: "utf8",
@@ -266282,7 +266370,7 @@ var init_auth3 = __esm(() => {
 
 // src/websocket/listener/manual-instance-lock.ts
 import { createHash as createHash15, randomUUID as randomUUID50 } from "node:crypto";
-import { link as link4, mkdir as mkdir12, readFile as readFile21, rm as rm11, unlink as unlink3, writeFile as writeFile15 } from "node:fs/promises";
+import { link as link4, mkdir as mkdir12, readFile as readFile22, rm as rm11, unlink as unlink3, writeFile as writeFile15 } from "node:fs/promises";
 import { uptime as uptime2 } from "node:os";
 import path32 from "node:path";
 function hasErrorCode3(error5, code2) {
@@ -266381,7 +266469,7 @@ async function recoverDeadOwner(lockPath, staleContents, recoveryOwnerContents,
       }
       let claimContents;
       try {
-        claimContents = await readFile21(claimPath, "utf-8");
+        claimContents = await readFile22(claimPath, "utf-8");
       } catch (error5) {
         if (hasErrorCode3(error5, "ENOENT")) {
           continue;
@@ -266401,7 +266489,7 @@ async function recoverDeadOwner(lockPath, staleContents, recoveryOwnerContents,
     }
     let currentContents;
     try {
-      currentContents = await readFile21(lockPath, "utf-8");
+      currentContents = await readFile22(lockPath, "utf-8");
     } catch (error5) {
       return hasErrorCode3(error5, "ENOENT");
     }
@@ -266453,7 +266541,7 @@ async function acquireManualListenerLock(scope, overrides = {}) {
             return;
           let currentContents;
           try {
-            currentContents = await readFile21(lockPath, "utf-8");
+            currentContents = await readFile22(lockPath, "utf-8");
           } catch (error5) {
             if (hasErrorCode3(error5, "ENOENT")) {
               released = true;
@@ -266473,7 +266561,7 @@ async function acquireManualListenerLock(scope, overrides = {}) {
     }
     let incumbentContents;
     try {
-      incumbentContents = await readFile21(lockPath, "utf-8");
+      incumbentContents = await readFile22(lockPath, "utf-8");
     } catch (error5) {
       if (hasErrorCode3(error5, "ENOENT")) {
         continue;
@@ -269047,7 +269135,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
           ensureLocalMemfsCheckout: ensureLocalMemfsCheckout2,
           isMemfsEnabledOnServer: isMemfsEnabledOnServer2
         } = await Promise.resolve().then(() => (init_memory_filesystem2(), exports_memory_filesystem));
-        const { readFile: readFile22 } = await import("node:fs/promises");
+        const { readFile: readFile23 } = await import("node:fs/promises");
         const { existsSync: existsSync52 } = await import("node:fs");
         const { isAbsolute: isAbsolute25, join: join80, normalize: normalize5, relative: relative8, sep: sep8 } = await import("node:path");
         if (isAbsolute25(parsed.path) || parsed.path.length === 0) {
@@ -269073,7 +269161,7 @@ function handleMemoryProtocolCommand(parsed, context3) {
             return;
           }
         }
-        const buffer = await readFile22(absolutePath);
+        const buffer = await readFile23(absolutePath);
         const content = encoding === "base64" ? buffer.toString("base64") : buffer.toString("utf-8");
         const pathspec = rel.split(sep8).join("/");
         safeSocketSend(socket, {
@@ -278361,7 +278449,7 @@ ${lanes.join(`
           writeOutputIsTTY() {
             return process.stdout.isTTY;
           },
-          readFile: readFile22,
+          readFile: readFile23,
           writeFile: writeFile22,
           watchFile: watchFile2,
           watchDirectory,
@@ -278554,7 +278642,7 @@ ${lanes.join(`
         function fsWatchWorker(fileOrDirectory, recursive, callback) {
           return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
         }
-        function readFile22(fileName, _encoding) {
+        function readFile23(fileName, _encoding) {
           let buffer;
           try {
             buffer = _fs.readFileSync(fileName);
@@ -309501,7 +309589,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, readFile22) {
+    function parseCommandLineWorker(diagnostics2, commandLine, readFile23) {
       const options = {};
       let watchOptions;
       const fileNames = [];
@@ -309539,7 +309627,7 @@ ${lanes.join(`
         }
       }
       function parseResponseFile(fileName) {
-        const text3 = tryReadFile(fileName, readFile22 || ((fileName2) => sys.readFile(fileName2)));
+        const text3 = tryReadFile(fileName, readFile23 || ((fileName2) => sys.readFile(fileName2)));
         if (!isString7(text3)) {
           errors6.push(text3);
           return;
@@ -309642,8 +309730,8 @@ ${lanes.join(`
       unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
       optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
     };
-    function parseCommandLine2(commandLine, readFile22) {
-      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile22);
+    function parseCommandLine2(commandLine, readFile23) {
+      return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile23);
     }
     function getOptionFromName(optionName, allowShort) {
       return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
@@ -309711,8 +309799,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, readFile22) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile22);
+    function readConfigFile(fileName, readFile23) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile23);
       return isString7(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
     }
     function parseConfigFileTextToJson(fileName, jsonText) {
@@ -309722,14 +309810,14 @@ ${lanes.join(`
         error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined
       };
     }
-    function readJsonConfigFile(fileName, readFile22) {
-      const textOrDiagnostic = tryReadFile(fileName, readFile22);
+    function readJsonConfigFile(fileName, readFile23) {
+      const textOrDiagnostic = tryReadFile(fileName, readFile23);
       return isString7(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
     }
-    function tryReadFile(fileName, readFile22) {
+    function tryReadFile(fileName, readFile23) {
       let text3;
       try {
-        text3 = readFile22(fileName);
+        text3 = readFile23(fileName);
       } catch (e2) {
         return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e2.message);
       }
@@ -377159,12 +377247,12 @@ ${lanes.join(`
     function createCompilerHost(options, setParentNodes) {
       return createCompilerHostWorker(options, setParentNodes);
     }
-    function createGetSourceFile(readFile22, setParentNodes) {
+    function createGetSourceFile(readFile23, setParentNodes) {
       return (fileName, languageVersionOrOptions, onError) => {
         let text3;
         try {
           mark2("beforeIORead");
-          text3 = readFile22(fileName);
+          text3 = readFile23(fileName);
           mark2("afterIORead");
           measure("I/O Read", "beforeIORead", "afterIORead");
         } catch (e2) {
@@ -377955,7 +378043,7 @@ ${lanes.join(`
         getRedirectFromOutput,
         forEachResolvedProjectReference: forEachResolvedProjectReference2
       });
-      const readFile22 = host.readFile.bind(host);
+      const readFile23 = 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();
@@ -378131,7 +378219,7 @@ ${lanes.join(`
         shouldTransformImportCall,
         emitBuildInfo,
         fileExists,
-        readFile: readFile22,
+        readFile: readFile23,
         directoryExists: directoryExists2,
         getSymlinkCache,
         realpath: (_o = host.realpath) == null ? undefined : _o.bind(host),
@@ -443068,7 +443156,7 @@ function handleTeleportRequest(params) {
   }
   pendingTeleports.set(key4, pending2);
   const conversationRuntime = getOrCreateScopedRuntime(listener, pending2.agentId, pending2.conversationId);
-  pending2.drainAcceptedInputs = hasAcceptedInputsWaiting(conversationRuntime, true);
+  pending2.drainAcceptedInputs = hasAcceptedInputsWaiting(conversationRuntime, !conversationRuntime.isProcessing);
   if (!conversationRuntime.isProcessing && !pending2.drainAcceptedInputs) {
     const connection = listener.connections.get(pending2.connectionId);
     if (!connection || !isListenerTransportOpen(connection.writer)) {
@@ -452818,7 +452906,7 @@ async function handleApprovalStop(params) {
     if (shouldInterrupt()) {
       return interruptTermination();
     }
-    executionResults = await executeApprovals(decisions, undefined, {
+    executionResults = await executeApprovals(decisions, params.onChunk, {
       toolContextId: turnToolContextId ?? undefined,
       abortSignal,
       onStreamingOutput: emitToolExecutionOutput,
@@ -456313,7 +456401,7 @@ var exports_reflection_memory_v2 = {};
 __export(exports_reflection_memory_v2, {
   buildMemfsV2ParentMemorySnapshot: () => buildMemfsV2ParentMemorySnapshot
 });
-import { readFile as readFile22 } from "node:fs/promises";
+import { readFile as readFile23 } from "node:fs/promises";
 function renderProjectedTree(files) {
   const root2 = { directories: new Map, files: [] };
   for (const file of files) {
@@ -456366,7 +456454,7 @@ async function buildMemfsV2ParentMemorySnapshot(memoryDir, requestedMaxChars) {
 `).length - prefix.length - suffix.length - 20;
     if (remaining <= 0)
       break;
-    const content = (await readFile22(file.fullPath, "utf-8")).slice(0, remaining);
+    const content = (await readFile23(file.fullPath, "utf-8")).slice(0, remaining);
     lines.push(`${prefix}${content}${suffix}`);
   }
   lines.push("</parent_memory>");
@@ -456384,7 +456472,7 @@ import {
   appendFile,
   mkdir as mkdir13,
   readdir as readdir9,
-  readFile as readFile23,
+  readFile as readFile24,
   stat as stat13,
   writeFile as writeFile16
 } from "node:fs/promises";
@@ -456432,7 +456520,7 @@ async function collectParentMemoryFiles(memoryDir) {
         continue;
       }
       try {
-        const content = await readFile23(entryPath, "utf-8");
+        const content = await readFile24(entryPath, "utf-8");
         const { frontmatter } = parseFrontmatter(content);
         const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
         files.push({
@@ -456735,7 +456823,7 @@ async function ensurePaths(paths) {
 }
 async function readTranscriptLines(paths) {
   try {
-    const raw2 = await readFile23(paths.transcriptPath, "utf-8");
+    const raw2 = await readFile24(paths.transcriptPath, "utf-8");
     return raw2.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
   } catch {
@@ -456808,7 +456896,7 @@ function buildUnreflectedStateFromTranscript(lines) {
 async function readState(paths) {
   let raw2 = null;
   try {
-    raw2 = await readFile23(paths.statePath, "utf-8");
+    raw2 = await readFile24(paths.statePath, "utf-8");
   } catch {
     raw2 = null;
   }
@@ -457140,7 +457228,7 @@ function isReflectionAutoPriority(value) {
   return value === "high" || value === "medium" || value === "low";
 }
 async function readReflectionAutoSelection(options) {
-  const raw2 = options.selectionReport ?? (options.selectionOutputPath ? await readFile23(options.selectionOutputPath, "utf-8") : "");
+  const raw2 = options.selectionReport ?? (options.selectionOutputPath ? await readFile24(options.selectionOutputPath, "utf-8") : "");
   const parsed = parseReflectionAutoSelectionJson(raw2);
   if (!parsed || typeof parsed !== "object") {
     throw new Error("Reflection selector did not return valid JSON.");
@@ -460376,6 +460464,7 @@ async function handleIncomingMessageInner(msg, socket, runtime, onStatusChange,
       }
       const approvalResult = await handleApprovalStop({
         approvals,
+        onChunk: (chunk2) => onChunk(buffers, chunk2),
         runtime,
         socket,
         agentId,
@@ -461089,7 +461178,7 @@ var init_write_file_command = __esm(() => {
 });
 
 // src/websocket/listener/file-commands.ts
-import { readdir as readdir10, readFile as readFile24 } from "node:fs/promises";
+import { readdir as readdir10, readFile as readFile25 } from "node:fs/promises";
 import { homedir as homedir31 } from "node:os";
 import path44 from "node:path";
 function trackListenerError3(errorType, error5, context3) {
@@ -461144,7 +461233,7 @@ async function getIgnoreConfig(root2) {
     return cached3;
   let patterns2 = [];
   try {
-    const content = await readFile24(path44.join(absRoot, ".letta", ".lettaignore"), "utf-8");
+    const content = await readFile25(path44.join(absRoot, ".letta", ".lettaignore"), "utf-8");
     patterns2 = parseLettaIgnore(content);
   } catch {
     patterns2 = [];
@@ -461509,7 +461598,7 @@ function createFileCommandSession(params) {
             if (stats.size > MAX_BASE64_READ_BYTES) {
               throw new Error(`File too large for base64 read (max ${Math.floor(MAX_BASE64_READ_BYTES / 1048576)}MB)`);
             }
-            const bytes = await readFile24(parsed.path);
+            const bytes = await readFile25(parsed.path);
             content = bytes.toString("base64");
           } else {
             content = await readUtf8TextStrict(parsed.path);
@@ -462240,7 +462329,7 @@ __export(exports_custom, {
   COMMANDS_DIR: () => COMMANDS_DIR
 });
 import { existsSync as existsSync63 } from "node:fs";
-import { readdir as readdir11, readFile as readFile25 } from "node:fs/promises";
+import { readdir as readdir11, readFile as readFile26 } from "node:fs/promises";
 import { basename as basename28, dirname as dirname37, join as join96 } from "node:path";
 function getGlobalCommandsDir() {
   return join96(resolveGlobalConfigDir(), "commands");
@@ -462302,7 +462391,7 @@ async function findCommandFiles(currentPath, rootPath, commands, source) {
   } catch (_error) {}
 }
 async function parseCommandFile(filePath, rootPath, source) {
-  const content = await readFile25(filePath, "utf-8");
+  const content = await readFile26(filePath, "utf-8");
   const { frontmatter, body: body3 } = parseFrontmatter(content);
   const id2 = basename28(filePath, ".md");
   const relativePath = dirname37(filePath).slice(rootPath.length);
@@ -468529,7 +468618,7 @@ var init_listen_client = __esm(async () => {
 
 // src/websocket/app-server-auth.ts
 import { createHash as createHash19, createHmac, timingSafeEqual } from "node:crypto";
-import { readFile as readFile26 } from "node:fs/promises";
+import { readFile as readFile27 } from "node:fs/promises";
 import { isIP as isIP2 } from "node:net";
 import { isAbsolute as isAbsolute26 } from "node:path";
 function parseAppServerWebsocketAuthSettings(args) {
@@ -468770,7 +468859,7 @@ function bearerTokenFromHeaders(headers) {
 async function readTrimmedSecret(path46) {
   let raw2;
   try {
-    raw2 = await readFile26(path46, "utf8");
+    raw2 = await readFile27(path46, "utf8");
   } catch (error5) {
     const message2 = error5 instanceof Error ? error5.message : String(error5);
     throw new Error(`failed to read websocket auth secret ${path46}: ${message2}`);
@@ -475437,7 +475526,7 @@ var init_sandbox_files = __esm(() => {
 });
 
 // src/cli/subcommands/sandbox.ts
-import { readFile as readFile27, stat as stat15, writeFile as writeFile19 } from "node:fs/promises";
+import { readFile as readFile28, stat as stat15, writeFile as writeFile19 } from "node:fs/promises";
 import { basename as basename29, resolve as resolve40 } from "node:path";
 import { parseArgs as parseArgs16 } from "node:util";
 function printUsage13() {
@@ -475587,7 +475676,7 @@ async function runSandboxSubcommand(argv, deps = {}) {
       const fileStat = await (deps.statLocalPath ?? stat15)(localPath2);
       if (!fileStat.isFile())
         throw new Error(`${localPath2} is not a file`);
-      const data2 = await (deps.readLocalFile ?? readFile27)(localPath2);
+      const data2 = await (deps.readLocalFile ?? readFile28)(localPath2);
       const sandbox2 = await ensureSandbox();
       const result3 = await (deps.uploadFile ?? uploadFileToSandbox)(sandbox2.sandboxId, { blob: new Blob([data2]), name: basename29(localPath2) });
       console.log(JSON.stringify({ ...result3, ...targetOutput }, null, 2));
@@ -475664,22 +475753,11 @@ function normalizeKey(key4) {
 function printError(error5) {
   console.error(error5 instanceof Error ? error5.message : String(error5));
 }
-async function readProcessStdin() {
-  return new Promise((resolve41, reject2) => {
-    let data = "";
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk2) => {
-      data += chunk2;
-    });
-    process.stdin.on("end", () => resolve41(data));
-    process.stdin.on("error", reject2);
-  });
-}
 async function runSecretSubcommand(argv, deps = {}) {
   const listSecrets = deps.listSecrets ?? refreshAndListSecrets;
   const setSecret = deps.setSecret ?? setSecretOnServer;
   const deleteSecret = deps.deleteSecret ?? deleteSecretOnServer;
-  const readStdin2 = deps.readStdin ?? readProcessStdin;
+  const readInput = deps.readStdin ?? readStdin;
   const initializeSettings = deps.initializeSettings ?? (async () => settingsManager.initialize());
   let parsed;
   try {
@@ -475753,7 +475831,7 @@ async function runSecretSubcommand(argv, deps = {}) {
           console.error("Pass either a positional value or --env/--stdin, not both.");
           return 1;
         }
-        const piped = (await readStdin2()).replace(/\r?\n$/, "");
+        const piped = (await readInput()).replace(/\r?\n$/, "");
         if (!piped) {
           console.error("No value received on stdin.");
           return 1;
@@ -479376,7 +479454,7 @@ var init_teleport2 = __esm(() => {
 });
 
 // src/cli/subcommands/trajectories/readers.ts
-import { readdir as readdir14, readFile as readFile28, stat as stat16 } from "node:fs/promises";
+import { readdir as readdir14, readFile as readFile29, stat as stat16 } from "node:fs/promises";
 import { join as join103 } from "node:path";
 async function loadSessionTranscript(item) {
   const stats = await stat16(item.path);
@@ -479386,7 +479464,7 @@ async function loadSessionTranscript(item) {
   if (item.path.endsWith(".db")) {
     return exportHermesSession(item.path, item.id);
   }
-  return readFile28(item.path, "utf-8");
+  return readFile29(item.path, "utf-8");
 }
 async function assembleEventDirectory(sessionDir) {
   const eventsSubdir = join103(sessionDir, "events");
@@ -479395,7 +479473,7 @@ async function assembleEventDirectory(sessionDir) {
   if (names2.length === 0) {
     throw new Error(`No event files found in ${eventsDir}`);
   }
-  const events = await Promise.all(names2.map(async (name) => JSON.parse(await readFile28(join103(eventsDir, name), "utf-8"))));
+  const events = await Promise.all(names2.map(async (name) => JSON.parse(await readFile29(join103(eventsDir, name), "utf-8"))));
   return JSON.stringify(events);
 }
 async function openReadOnlyDatabase(path48) {
@@ -479468,7 +479546,7 @@ import { createHash as createHash20 } from "node:crypto";
 import {
   mkdir as mkdir17,
   readdir as readdir15,
-  readFile as readFile29,
+  readFile as readFile30,
   rm as rm12,
   stat as stat17,
   writeFile as writeFile20
@@ -479641,7 +479719,7 @@ async function runTrajectoryExport(options) {
     if (!supported.includes(explicit.source)) {
       throw new Error(`Unknown source "${explicit.source}" in --transcript. The installed trajectory package supports: ${supported.join(", ")}.`);
     }
-    await exportTranscript(explicit.source, basename31(explicit.path).replace(/\.[^.]+$/, ""), explicit.path, () => readFile29(explicit.path, "utf-8"));
+    await exportTranscript(explicit.source, basename31(explicit.path).replace(/\.[^.]+$/, ""), explicit.path, () => readFile30(explicit.path, "utf-8"));
   }
   for (const checkpoint of options.deepagents ?? []) {
     await exportCheckpoint(checkpoint, `${basename31(checkpoint.path)}-${checkpoint.threadId}`);
@@ -479658,12 +479736,12 @@ var init_export = __esm(() => {
 });
 
 // src/cli/subcommands/trajectories/review.ts
-import { readFile as readFile30 } from "node:fs/promises";
+import { readFile as readFile31 } from "node:fs/promises";
 import { isAbsolute as isAbsolute27, join as join105 } from "node:path";
 async function readManifest(dir) {
   let raw2;
   try {
-    raw2 = await readFile30(join105(dir, "manifest.json"), "utf-8");
+    raw2 = await readFile31(join105(dir, "manifest.json"), "utf-8");
   } catch {
     throw new Error(`No manifest at ${join105(dir, "manifest.json")}. Run: letta trajectories export --out ${dir}`);
   }
@@ -479676,7 +479754,7 @@ async function resolveSessionFile(dir, target2) {
   if (target2.endsWith(".json")) {
     const direct = isAbsolute27(target2) ? target2 : join105(dir, target2);
     try {
-      await readFile30(direct, "utf-8");
+      await readFile31(direct, "utf-8");
       return direct;
     } catch {}
   }
@@ -479728,7 +479806,7 @@ async function searchSessions(dir, keyword, options = {}) {
   for (const session3 of filterSessions(manifest2.sessions, options)) {
     let records2;
     try {
-      records2 = JSON.parse(await readFile30(join105(dir, session3.file), "utf-8"));
+      records2 = JSON.parse(await readFile31(join105(dir, session3.file), "utf-8"));
     } catch {
       continue;
     }
@@ -479759,7 +479837,7 @@ var TOOL_RESULT_MAX_CHARS = 500, REASONING_MAX_CHARS = 300, TOOL_ARGS_MAX_CHARS
 var init_review = () => {};
 
 // src/cli/subcommands/trajectories.ts
-import { readFile as readFile31 } from "node:fs/promises";
+import { readFile as readFile32 } from "node:fs/promises";
 import { parseArgs as parseArgs23 } from "node:util";
 function printUsage19() {
   console.log(`
@@ -479866,7 +479944,7 @@ async function runView(flags, target2, options) {
     return 1;
   }
   const path48 = await resolveSessionFile(flags.dir, target2);
-  const records2 = JSON.parse(await readFile31(path48, "utf-8"));
+  const records2 = JSON.parse(await readFile32(path48, "utf-8"));
   console.log(renderSession(records2, options));
   return 0;
 }
@@ -490844,7 +490922,7 @@ var init_reflection_arena_hf_upload = __esm(() => {
 // src/cli/helpers/reflection-arena.ts
 import { execFile as execFileCb5 } from "node:child_process";
 import { randomInt as randomInt2, randomUUID as randomUUID64 } from "node:crypto";
-import { appendFile as appendFile4, mkdir as mkdir19, readFile as readFile32, writeFile as writeFile22 } from "node:fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir19, readFile as readFile33, writeFile as writeFile22 } from "node:fs/promises";
 import { join as join109 } from "node:path";
 import { promisify as promisify20 } from "node:util";
 function sampleReflectionArenaComparisonModel(excludedModels = []) {
@@ -490911,7 +490989,7 @@ async function saveReflectionArenaRun(run) {
 `, "utf-8");
 }
 async function loadReflectionArenaRun(runId) {
-  const raw2 = await readFile32(getReflectionArenaRunPath(runId), "utf-8");
+  const raw2 = await readFile33(getReflectionArenaRunPath(runId), "utf-8");
   return JSON.parse(raw2);
 }
 async function updateReflectionArenaRun(runId, update3) {
@@ -491103,7 +491181,7 @@ async function appendChoiceRecord(run) {
 }
 async function readTranscriptPayloadForTelemetry(payloadPath) {
   try {
-    const transcript2 = await readFile32(payloadPath, "utf-8");
+    const transcript2 = await readFile33(payloadPath, "utf-8");
     return {
       transcriptPayload: transcript2.slice(0, REFLECTION_ARENA_TELEMETRY_TRANSCRIPT_MAX_CHARS),
       transcriptPayloadChars: transcript2.length,
@@ -510842,7 +510920,7 @@ var init_use_chatgpt_rate_limit_state = __esm(() => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile33 } from "node:fs/promises";
+import { readFile as readFile34 } from "node:fs/promises";
 import { homedir as homedir35 } from "node:os";
 import { join as join115 } from "node:path";
 async function parseAwsCredentials() {
@@ -510850,11 +510928,11 @@ async function parseAwsCredentials() {
   const configPath = join115(homedir35(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile33(credentialsPath, "utf-8");
+    const content = await readFile34(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile33(configPath, "utf-8");
+    const content = await readFile34(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -525361,7 +525439,7 @@ The deployment target for this project is CITATION-DOGFOOD-OK.
 
 // src/mods/learning-harness.ts
 import { spawn as spawn15 } from "node:child_process";
-import { access as access2, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile34, writeFile as writeFile23 } from "node:fs/promises";
+import { access as access2, copyFile as copyFile2, mkdir as mkdir20, readFile as readFile35, writeFile as writeFile23 } from "node:fs/promises";
 import path49 from "node:path";
 function slugify2(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -526853,7 +526931,7 @@ async function runModLearning(options) {
   return report;
 }
 async function readModLearningEnv(envPath) {
-  return JSON.parse(await readFile34(envPath, "utf8"));
+  return JSON.parse(await readFile35(envPath, "utf8"));
 }
 var init_learning_harness = __esm(async () => {
   await init_mod_engine();
@@ -539182,4 +539260,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=9F448AA0C77E79A664756E2164756E21
+//# debugId=856A9C1BADE9BA4D64756E2164756E21