@moxt-ai/mobius 0.0.166 → 0.0.168

package/dist/index.js

@@ -21215,6 +21215,7 @@ var MAX_JSON_KEYS = 1e3;
 var SESSION_EVENT_V2_KIND = "session.event.v2";
 var boundedString = external_exports.string().max(MAX_CONTENT_LENGTH);
 var shortString = external_exports.string().max(2048);
+var externalContentKeySchema = external_exports.string().regex(/^[a-f0-9]{64}$/u);
 function boundedJsonIssue(value, depth = 0) {
   if (depth > MAX_JSON_DEPTH) {
     return "JSON nesting exceeds the maximum depth";
@@ -21282,6 +21283,30 @@ var imageContentSchema = external_exports.object({
   uri: boundedString.nullable().optional()
 }).readonly();
 var audioContentSchema = external_exports.object({ ...contentFields, data: boundedString, mimeType: shortString, type: external_exports.literal("audio") }).readonly();
+var externalImageContentSchema = external_exports.strictObject({
+  ...contentFields,
+  byteLength: external_exports.number().int().positive().safe(),
+  imageKey: externalContentKeySchema,
+  mimeType: shortString,
+  type: external_exports.literal("external_image"),
+  uri: boundedString.nullable().optional()
+}).readonly();
+var externalAudioContentSchema = external_exports.strictObject({
+  ...contentFields,
+  audioKey: externalContentKeySchema,
+  byteLength: external_exports.number().int().positive().safe(),
+  mimeType: shortString,
+  type: external_exports.literal("external_audio")
+}).readonly();
+var externalResourceContentSchema = external_exports.strictObject({
+  ...contentFields,
+  byteLength: external_exports.number().int().positive().safe(),
+  encoding: external_exports.enum(["binary", "text"]),
+  mimeType: shortString.nullable().optional(),
+  resourceKey: externalContentKeySchema,
+  type: external_exports.literal("external_resource"),
+  uri: boundedString
+}).readonly();
 var resourceLinkSchema = external_exports.object({
   ...contentFields,
   description: boundedString.nullable().optional(),
@@ -21314,7 +21339,10 @@ var contentBlockV2Schema = external_exports.discriminatedUnion("type", [
   imageContentSchema,
   audioContentSchema,
   resourceLinkSchema,
-  embeddedResourceSchema
+  embeddedResourceSchema,
+  externalImageContentSchema,
+  externalAudioContentSchema,
+  externalResourceContentSchema
 ]);
 var toolCallContentSchema = external_exports.discriminatedUnion("type", [
   external_exports.object({ _meta: optionalMetadata, content: contentBlockV2Schema, type: external_exports.literal("content") }).readonly(),
@@ -26365,7 +26393,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join19(chunks, separator) {
+  function join20(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -26375,7 +26403,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join19;
+  sql2.join = join20;
   function identifier(value) {
     return new Name(value);
   }
@@ -28919,7 +28947,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join19) => join19.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join20) => join20.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -29778,7 +29806,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join19) => join19.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join20) => join20.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -31101,6 +31129,7 @@ function recordsEqual(left, right) {
 }
 var AgentSession = class _AgentSession {
   #connection;
+  #contentExternalizer;
   #interactions;
   #additionalDirectories;
   #agentId;
@@ -31128,7 +31157,7 @@ var AgentSession = class _AgentSession {
   #sessionTitle = null;
   #sessionUpdatedAt = "";
   #turn = new IdleAcpTurn();
-  constructor(agent, cwd, additionalDirectories, mobiusSessionId, getObserver, store, metrics) {
+  constructor(agent, cwd, additionalDirectories, mobiusSessionId, getObserver, store, metrics, contentExternalizer) {
     this.#updates = new AgentUpdateStream((notification) => this.#processUpdate(notification));
     this.#additionalDirectories = [...additionalDirectories];
     this.#agentId = agent.id;
@@ -31148,8 +31177,9 @@ var AgentSession = class _AgentSession {
       observer: getObserver
     });
     this.#connection = new AgentConnection(agent, cwd, this);
+    this.#contentExternalizer = contentExternalizer;
   }
-  static async #start(options, getObserver, store, initialize, metrics) {
+  static async #start(options, getObserver, store, initialize, metrics, contentExternalizer) {
     for (let attempt = 1; attempt <= 2; attempt += 1) {
       options.signal.throwIfAborted();
       const unchanged = await metrics.measure(
@@ -31177,7 +31207,8 @@ var AgentSession = class _AgentSession {
           options.sessionId,
           getObserver,
           store,
-          metrics
+          metrics,
+          contentExternalizer
         )
       );
       try {
@@ -31200,19 +31231,21 @@ var AgentSession = class _AgentSession {
     }
     throw new AcpExecutionError("ACP agent initialization failed");
   }
-  static start = async (options, getObserver, store, metrics = unmeasuredOperationMetrics) => await _AgentSession.#start(
+  static start = async (options, getObserver, store, metrics, contentExternalizer) => await _AgentSession.#start(
     options,
     getObserver,
     store,
     async (runtime) => await runtime.initialize(options.signal, options.origin),
-    metrics
+    metrics,
+    contentExternalizer
   );
-  static startNativeSessionBrowser = async (options, getObserver, store) => await _AgentSession.#start(
+  static startNativeSessionBrowser = async (options, getObserver, store, contentExternalizer) => await _AgentSession.#start(
     options,
     getObserver,
     store,
     async (runtime) => await runtime.#initializeAgent(options.signal),
-    unmeasuredOperationMetrics
+    unmeasuredOperationMetrics,
+    contentExternalizer
   );
   belongsTo = (agentId, cwd, additionalDirectories) => this.#agentId === agentId && this.#cwd === cwd && arraysEqual(this.#additionalDirectories, additionalDirectories);
   usesEnvironment = (environment) => recordsEqual(this.#environment, environment);
@@ -31916,8 +31949,13 @@ var AgentSession = class _AgentSession {
   };
   #processUpdate = async (notification) => {
     this.assertNativeSession(notification.sessionId);
-    const update = notification.update;
-    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(update));
+    const externalized = await this.#contentExternalizer.update(
+      this.#mobiusSessionId,
+      notification.update,
+      AbortSignal.timeout(3e4)
+    );
+    const update = externalized.agent;
+    const rawUpdate = decodeAcpSessionUpdateV2(JSON.stringify(externalized.event));
     if (this.#sessionLoad.kind === "capturing") {
       await this.#sessionLoad.history.record(update, rawUpdate);
     } else {
@@ -32204,8 +32242,10 @@ var AgentQueryProcesses = class {
   #processes;
   #observer = new NullAcpSessionObserver();
   #store = new MemoryAcpSessionStore();
-  constructor(processes) {
+  #contentExternalizer;
+  constructor(processes, contentExternalizer) {
     this.#processes = processes;
+    this.#contentExternalizer = contentExternalizer;
     this.#processesByQuery = new RetainedAgentProcesses({
       touch: processes.touch,
       changed: processes.notifyChanged
@@ -32221,7 +32261,12 @@ var AgentQueryProcesses = class {
   async #startRetained(options) {
     const runtime = await this.#processes.startRetained(
       options.signal,
-      () => AgentSession.startNativeSessionBrowser(options, () => this.#observer, this.#store),
+      () => AgentSession.startNativeSessionBrowser(
+        options,
+        () => this.#observer,
+        this.#store,
+        this.#contentExternalizer
+      ),
       {
         isBusy: () => this.#processesByQuery.isBusy(options.sessionId),
         retire: (runtime2) => this.retire(options.sessionId, runtime2)
@@ -32297,7 +32342,8 @@ var AgentQueryProcesses = class {
       async () => await AgentSession.startNativeSessionBrowser(
         options,
         () => this.#observer,
-        new MemoryAcpSessionStore()
+        new MemoryAcpSessionStore(),
+        this.#contentExternalizer
       ),
       async (runtime) => {
         runtime.selectNativeSession(nativeSessionId);
@@ -32312,7 +32358,8 @@ var AgentQueryProcesses = class {
       async () => await AgentSession.startNativeSessionBrowser(
         options,
         () => this.#observer,
-        new MemoryAcpSessionStore()
+        new MemoryAcpSessionStore(),
+        this.#contentExternalizer
       ),
       async (runtime) => {
         runtime.selectNativeSession(nativeSessionId);
@@ -32328,6 +32375,393 @@ var AgentQueryProcesses = class {
   };
 };
 
+// src/external-content/acp-content-externalizer.ts
+var MAXIMUM_ENCODED_CONTENT_CHARACTERS = 4e6;
+function decodeBase64(data) {
+  if (data.length > MAXIMUM_ENCODED_CONTENT_CHARACTERS || data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(data)) {
+    throw new Error("The ACP embedded content is not valid bounded base64");
+  }
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.toString("base64") !== data) {
+    throw new Error("The ACP embedded content is not canonical base64");
+  }
+  return bytes;
+}
+var embeddedImageSchema = external_exports.looseObject({
+  type: external_exports.literal("image"),
+  data: external_exports.string(),
+  mimeType: external_exports.string()
+});
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var AcpContentExternalizer = class {
+  #store;
+  constructor(store) {
+    this.#store = store;
+  }
+  async #content(sessionId, content, signal) {
+    switch (content.type) {
+      case "text":
+      case "resource_link":
+        return { agent: content, event: content };
+      case "image": {
+        if (content.data.length === 0) {
+          return { agent: content, event: content };
+        }
+        try {
+          const bytes = decodeBase64(content.data);
+          if (sniffRasterMime(bytes) !== content.mimeType) {
+            throw new Error("Embedded image bytes do not match a supported image MIME type");
+          }
+          const stored = await this.#store.put({
+            bytes,
+            kind: "image",
+            mediaType: content.mimeType,
+            name: "image",
+            sessionId,
+            signal
+          });
+          return {
+            agent: { ...content, data: "", uri: `mobius-content:image:${stored.key}` },
+            event: {
+              _meta: content._meta,
+              annotations: content.annotations,
+              byteLength: stored.byteLength,
+              imageKey: stored.key,
+              mimeType: content.mimeType,
+              type: "external_image",
+              uri: content.uri
+            }
+          };
+        } catch {
+          signal.throwIfAborted();
+          const unavailable = { type: "text", text: "[Image unavailable]" };
+          return { agent: unavailable, event: unavailable };
+        }
+      }
+      case "audio": {
+        if (content.data.length === 0) {
+          return { agent: content, event: content };
+        }
+        const stored = await this.#store.put({
+          bytes: decodeBase64(content.data),
+          kind: "audio",
+          mediaType: content.mimeType,
+          name: "audio",
+          sessionId,
+          signal
+        });
+        return {
+          agent: content,
+          event: {
+            _meta: content._meta,
+            annotations: content.annotations,
+            audioKey: stored.key,
+            byteLength: stored.byteLength,
+            mimeType: content.mimeType,
+            type: "external_audio"
+          }
+        };
+      }
+      case "resource": {
+        const embedded = content.resource;
+        const encoding = "text" in embedded ? "text" : "binary";
+        const bytes = "text" in embedded ? Buffer.from(embedded.text, "utf8") : decodeBase64(embedded.blob);
+        if (bytes.byteLength === 0) {
+          return { agent: content, event: content };
+        }
+        const mediaType = embedded.mimeType ?? "application/octet-stream";
+        const stored = await this.#store.put({
+          bytes,
+          kind: "resource",
+          mediaType,
+          name: "resource",
+          sessionId,
+          signal
+        });
+        return {
+          agent: content,
+          event: {
+            _meta: content._meta,
+            annotations: content.annotations,
+            byteLength: stored.byteLength,
+            encoding,
+            mimeType: embedded.mimeType,
+            resourceKey: stored.key,
+            type: "external_resource",
+            uri: embedded.uri
+          }
+        };
+      }
+    }
+  }
+  async #rawOutput(sessionId, value, images, signal, depth = 0) {
+    signal.throwIfAborted();
+    if (depth > 16) {
+      throw new Error("ACP tool output exceeds the maximum nesting depth");
+    }
+    if (Array.isArray(value)) {
+      const result2 = [];
+      for (const item of value) {
+        result2.push(await this.#rawOutput(sessionId, item, images, signal, depth + 1));
+      }
+      return result2;
+    }
+    if (!isRecord6(value)) {
+      return value;
+    }
+    const image = embeddedImageSchema.safeParse(value);
+    if (image.success && image.data.data.length > 0) {
+      const prepared = await this.#content(sessionId, image.data, signal);
+      if (isRecord6(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+        images.set(prepared.event["imageKey"], prepared);
+      } else {
+        images.set(`unavailable:${images.size}`, prepared);
+      }
+      return prepared.event;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      result[key] = await this.#rawOutput(sessionId, item, images, signal, depth + 1);
+    }
+    return result;
+  }
+  async #toolUpdate(sessionId, update, signal) {
+    const images = /* @__PURE__ */ new Map();
+    const rawOutput = update.rawOutput === void 0 ? void 0 : await this.#rawOutput(sessionId, update.rawOutput, images, signal);
+    const originalJson = images.size === 0 ? void 0 : JSON.stringify(update.rawOutput);
+    const rewrittenJson = images.size === 0 ? void 0 : JSON.stringify(rawOutput);
+    const agentContent = [];
+    const eventContent = [];
+    for (const item of update.content ?? []) {
+      if (item.type !== "content") {
+        agentContent.push(item);
+        eventContent.push(item);
+        continue;
+      }
+      const content = item.content.type === "text" && item.content.text === originalJson && rewrittenJson !== void 0 ? { ...item.content, text: rewrittenJson } : item.content;
+      const prepared = await this.#content(sessionId, content, signal);
+      agentContent.push({ ...item, content: prepared.agent });
+      eventContent.push({ ...item, content: prepared.event });
+      if (isRecord6(prepared.event) && typeof prepared.event["imageKey"] === "string") {
+        images.delete(prepared.event["imageKey"]);
+      }
+    }
+    for (const prepared of images.values()) {
+      agentContent.push({ type: "content", content: prepared.agent });
+      eventContent.push({ type: "content", content: prepared.event });
+    }
+    const output2 = update.rawOutput === void 0 ? {} : { rawOutput };
+    const hasContent = update.content !== void 0 && update.content !== null || agentContent.length > 0;
+    return {
+      agent: { ...update, ...output2, ...hasContent ? { content: agentContent } : {} },
+      event: { ...update, ...output2, ...hasContent ? { content: eventContent } : {} }
+    };
+  }
+  update = async (sessionId, update, signal) => {
+    switch (update.sessionUpdate) {
+      case "user_message_chunk":
+      case "agent_message_chunk":
+      case "agent_thought_chunk":
+      case "compaction_summary_chunk": {
+        const content = await this.#content(sessionId, update.content, signal);
+        return {
+          agent: { ...update, content: content.agent },
+          event: { ...update, content: content.event }
+        };
+      }
+      case "tool_call":
+      case "tool_call_update":
+        return await this.#toolUpdate(sessionId, update, signal);
+      case "compaction_update": {
+        if (update.summary === void 0 || update.summary === null) {
+          return { agent: update, event: update };
+        }
+        const content = await Promise.all(
+          update.summary.map(async (item) => await this.#content(sessionId, item, signal))
+        );
+        return {
+          agent: { ...update, summary: content.map((item) => item.agent) },
+          event: { ...update, summary: content.map((item) => item.event) }
+        };
+      }
+      case "plan":
+      case "plan_update":
+      case "plan_removed":
+      case "available_commands_update":
+      case "current_mode_update":
+      case "config_option_update":
+      case "session_info_update":
+      case "usage_update":
+        return { agent: update, event: update };
+    }
+  };
+};
+
+// src/external-content/local-external-content-store.ts
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir as readdir2, realpath as realpath3, rename, rm, stat as stat3, utimes, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join4 } from "node:path";
+var contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
+var CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
+var metadataSchema2 = external_exports.strictObject({
+  kind: external_exports.enum(["image", "audio", "resource"]),
+  mediaType: external_exports.string().min(1).max(2048).regex(/^[\u0020-\u007e]+$/u),
+  name: external_exports.string().min(1).max(500)
+});
+var UnretainedExternalContentStore = class {
+  put = async ({ bytes, signal }) => {
+    signal.throwIfAborted();
+    return { byteLength: bytes.byteLength, key: createHash("sha256").update(bytes).digest("hex") };
+  };
+  resolve = (_sessionId, _request, signal) => {
+    signal.throwIfAborted();
+    return Promise.resolve(null);
+  };
+};
+async function atomicWrite(path2, bytes, signal) {
+  const temporary = `${path2}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { mode: 384, signal });
+    signal.throwIfAborted();
+    await rename(temporary, path2);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+var LocalExternalContentStore = class {
+  #root;
+  #entries = /* @__PURE__ */ new Map();
+  #operations = /* @__PURE__ */ new Set();
+  #lifetime = new AbortController();
+  #expirationTimer;
+  #cleanup = Promise.resolve();
+  constructor(stateDirectory) {
+    this.#root = join4(stateDirectory, "tmp", "session-content", randomUUID());
+    this.#expirationTimer = setInterval(() => {
+      void this.#expire().catch(() => void 0);
+    }, 6e4);
+    this.#expirationTimer.unref();
+  }
+  #expire = () => {
+    this.#cleanup = this.#cleanup.catch(() => void 0).then(async () => {
+      await mkdir(this.#root, { mode: 448, recursive: true });
+      const now = /* @__PURE__ */ new Date();
+      await utimes(this.#root, now, now);
+      for (const directory of await readdir2(dirname2(this.#root), { withFileTypes: true })) {
+        if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
+          continue;
+        }
+        const path2 = join4(dirname2(this.#root), directory.name);
+        if (path2 === this.#root) {
+          continue;
+        }
+        const modified = await stat3(path2).then(
+          (entry) => entry.mtimeMs,
+          () => Date.now()
+        );
+        if (modified + CONTENT_LIFETIME_MILLISECONDS <= Date.now()) {
+          await rm(path2, { force: true, recursive: true });
+        }
+      }
+      for (const [request, entry] of this.#entries) {
+        if (entry.expiresAt > Date.now()) {
+          continue;
+        }
+        await rm(entry.path, { force: true });
+        this.#entries.delete(request);
+      }
+    });
+    return this.#cleanup;
+  };
+  #track = async (operation) => {
+    this.#lifetime.signal.throwIfAborted();
+    const pending = operation();
+    this.#operations.add(pending);
+    try {
+      return await pending;
+    } finally {
+      this.#operations.delete(pending);
+    }
+  };
+  put = (input2) => this.#track(() => this.#put(input2));
+  #put = async ({ bytes, kind, mediaType, name, sessionId, signal }) => {
+    const active = AbortSignal.any([signal, this.#lifetime.signal]);
+    active.throwIfAborted();
+    const metadata = metadataSchema2.parse({ kind, mediaType, name });
+    const key = createHash("sha256").update(bytes).digest("hex");
+    const request = `mobius-content:${kind}:${key}`;
+    const existing = this.#entries.get(request);
+    if (existing !== void 0 && existing.expiresAt > Date.now()) {
+      this.#entries.set(request, {
+        ...existing,
+        expiresAt: Date.now() + CONTENT_LIFETIME_MILLISECONDS,
+        sessions: /* @__PURE__ */ new Set([...existing.sessions, sessionId])
+      });
+      return { byteLength: existing.byteLength, key };
+    }
+    await this.#expire();
+    active.throwIfAborted();
+    const directory = join4(this.#root, kind);
+    await mkdir(directory, { mode: 448, recursive: true });
+    active.throwIfAborted();
+    const path2 = join4(directory, key);
+    const write = atomicWrite(path2, bytes, active);
+    await write;
+    active.throwIfAborted();
+    const retained = this.#entries.get(request);
+    this.#entries.set(request, {
+      byteLength: bytes.byteLength,
+      expiresAt: Date.now() + CONTENT_LIFETIME_MILLISECONDS,
+      mediaType: metadata.mediaType,
+      name: metadata.name,
+      path: path2,
+      sessions: /* @__PURE__ */ new Set([...retained?.sessions ?? [], sessionId])
+    });
+    return { byteLength: bytes.byteLength, key };
+  };
+  resolve = (sessionId, request, signal) => this.#track(() => this.#resolve(sessionId, request, AbortSignal.any([signal, this.#lifetime.signal])));
+  #resolve = async (sessionId, request, signal) => {
+    signal.throwIfAborted();
+    this.#lifetime.signal.throwIfAborted();
+    if (!contentRequest.test(request)) {
+      return null;
+    }
+    const entry = this.#entries.get(request);
+    if (entry === void 0 || !entry.sessions.has(sessionId)) {
+      return null;
+    }
+    if (entry.expiresAt <= Date.now()) {
+      await this.#expire();
+      signal.throwIfAborted();
+      return null;
+    }
+    try {
+      const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
+        realpath3(dirname2(entry.path)),
+        realpath3(entry.path),
+        lstat(entry.path)
+      ]);
+      signal.throwIfAborted();
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname2(resolvedPath) !== resolvedDirectory) {
+        return null;
+      }
+      return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
+    } catch {
+      signal.throwIfAborted();
+      return null;
+    }
+  };
+  [Symbol.asyncDispose] = async () => {
+    clearInterval(this.#expirationTimer);
+    this.#lifetime.abort();
+    await Promise.allSettled([...this.#operations, this.#cleanup]);
+    this.#entries.clear();
+    await rm(this.#root, { force: true, recursive: true });
+  };
+};
+
 // src/native-sessions/chat-agent.ts
 function supportsNativeChat(agentId) {
   return agentId === "codex" || agentId === "claude" || agentId === "opencode" || agentId === "pi";
@@ -32544,7 +32978,7 @@ var AgentRuntimeManager = class {
     touch: this.#processes.touch,
     changed: this.#processes.notifyChanged
   });
-  #queryProcesses = new AgentQueryProcesses(this.#processes);
+  #queryProcesses;
   #executions = new ActiveExecutions();
   #agentSettingsObserver = new NullAcpSessionObserver();
   #nativeOperations = /* @__PURE__ */ new Set();
@@ -32552,13 +32986,16 @@ var AgentRuntimeManager = class {
   #nativeHistoryReader;
   #sessionIdentity;
   #onSessionStatusChanged;
+  #contentExternalizer;
   #observer;
-  constructor(observer = new NullAcpSessionObserver(), store = new MemoryAcpSessionStore(), nativeHistoryReader = null, sessionIdentity = "assigned", onSessionStatusChanged = () => void 0) {
+  constructor(observer = new NullAcpSessionObserver(), store = new MemoryAcpSessionStore(), nativeHistoryReader = null, sessionIdentity = "assigned", onSessionStatusChanged = () => void 0, contentExternalizer = new AcpContentExternalizer(new UnretainedExternalContentStore())) {
     this.#observer = observer;
     this.#store = store;
     this.#nativeHistoryReader = nativeHistoryReader;
     this.#sessionIdentity = sessionIdentity;
     this.#onSessionStatusChanged = onSessionStatusChanged;
+    this.#contentExternalizer = contentExternalizer;
+    this.#queryProcesses = new AgentQueryProcesses(this.#processes, contentExternalizer);
   }
   setObserver = (observer) => {
     this.#observer = observer;
@@ -32599,7 +33036,8 @@ var AgentRuntimeManager = class {
           options.origin === void 0 && this.#sessionIdentity === "native" && isNativeChatSessionId(options.agent.id, options.sessionId) && this.#store.read(options.sessionId) instanceof MissingAcpStoredSession ? { ...options, origin: { kind: "import", nativeSessionId: options.sessionId } } : options,
           () => this.#observer,
           this.#store,
-          metrics
+          metrics,
+          this.#contentExternalizer
         )
       );
     });
@@ -32614,7 +33052,13 @@ var AgentRuntimeManager = class {
       this.#store.remove(options.sessionId);
       return await this.#startRetainedSessionProcess(
         options,
-        async () => await AgentSession.start(options, () => this.#observer, this.#store, metrics)
+        async () => await AgentSession.start(
+          options,
+          () => this.#observer,
+          this.#store,
+          metrics,
+          this.#contentExternalizer
+        )
       );
     });
   }
@@ -32624,7 +33068,13 @@ var AgentRuntimeManager = class {
       await this.#retireSessionProcess(options.sessionId, existing, async () => await existing.close());
       const runtime = await this.#startRetainedSessionProcess(
         options,
-        async () => await AgentSession.start(options, () => this.#observer, this.#store)
+        async () => await AgentSession.start(
+          options,
+          () => this.#observer,
+          this.#store,
+          unmeasuredOperationMetrics,
+          this.#contentExternalizer
+        )
       );
       try {
         for (const desired of desiredConfigOptions) {
@@ -32720,7 +33170,9 @@ var AgentRuntimeManager = class {
           sessionId: `agent-settings-${crypto.randomUUID()}`
         },
         () => this.#agentSettingsObserver,
-        new MemoryAcpSessionStore()
+        new MemoryAcpSessionStore(),
+        unmeasuredOperationMetrics,
+        this.#contentExternalizer
       ),
       async (runtime) => {
         const prepared = runtime.prepared();
@@ -33250,7 +33702,7 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir5, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { mkdir as mkdir6, realpath as realpath8, stat as stat7 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
 import { basename as basename3, resolve as resolve5 } from "node:path";
 import { fetch as fetch2 } from "undici";
@@ -33395,8 +33847,8 @@ var LocalAgentInventory = class {
 };
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir, mkdtemp, open as open3, realpath as realpath3, rename, rm, stat as stat3 } from "node:fs/promises";
-import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative, sep } from "node:path";
+import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath4, rename as rename2, rm as rm2, stat as stat4 } from "node:fs/promises";
+import { delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative, sep } from "node:path";
 var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
 var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -33443,11 +33895,11 @@ var ManagedNpmPackageError = class extends Error {
     this.name = "ManagedNpmPackageError";
   }
 };
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join4(root, "node_modules", ...packageName.split("/"));
+  return join5(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
@@ -33465,7 +33917,7 @@ async function readJsonRecord(path2, maximumBytes) {
         );
       }
       const value = JSON.parse(await handle.readFile({ encoding: "utf8" }));
-      if (!isRecord6(value)) {
+      if (!isRecord7(value)) {
         throw new ManagedNpmPackageError(
           "managed_package_verification_failed",
           "The managed npm package metadata is invalid"
@@ -33491,7 +33943,7 @@ function readBinPath(packageMetadata, executableName) {
   if (typeof bin === "string") {
     return bin;
   }
-  if (isRecord6(bin) && typeof bin[executableName] === "string") {
+  if (isRecord7(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
   throw new ManagedNpmPackageError(
@@ -33507,7 +33959,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
     );
   }
   const packages = lock["packages"];
-  if (!isRecord6(packages)) {
+  if (!isRecord7(packages)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile is invalid"
@@ -33521,7 +33973,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
     if (verifyDependencyClosure && normalizedKey.length > 0) {
       let resolved;
       try {
-        if (!normalizedKey.split("/").includes("node_modules") || !isRecord6(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
+        if (!normalizedKey.split("/").includes("node_modules") || !isRecord7(candidate) || typeof candidate["version"] !== "string" || candidate["version"].length === 0 || typeof candidate["integrity"] !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(candidate["integrity"]) || typeof candidate["resolved"] !== "string") {
           throw new Error("Invalid locked dependency");
         }
         resolved = new URL(candidate["resolved"]);
@@ -33544,7 +33996,7 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
       matches += 1;
     }
   }
-  if (matches !== 1 || !isRecord6(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+  if (matches !== 1 || !isRecord7(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package lockfile does not match the pinned artifact"
@@ -33552,14 +34004,14 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   }
 }
 async function verifyRequiredDependency(rootPath, lock, definition) {
-  const dependencyRoot = await realpath3(packagePath(rootPath, definition.packageName));
+  const dependencyRoot = await realpath4(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, dependencyRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The required managed npm dependency escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join4(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join5(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33581,15 +34033,15 @@ async function validateManagedNpmPackage(root, definition) {
   }
 }
 async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath3(root);
-  const packageRoot = await realpath3(packagePath(rootPath, definition.packageName));
+  const rootPath = await realpath4(root);
+  const packageRoot = await realpath4(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, packageRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join4(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join5(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33597,14 +34049,14 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    const lock = await readJsonRecord(join4(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
+    const lock = await readJsonRecord(join5(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
     verifyPackageLockEntry(lock, definition, definition.verifyDependencyClosure);
     for (const dependency of definition.requiredDependencies) {
       await verifyRequiredDependency(rootPath, lock, dependency);
     }
   }
   const declaredBin = readBinPath(metadata, definition.executableName);
-  const executable = await resolveExecutablePath(join4(packageRoot, declaredBin));
+  const executable = await resolveExecutablePath(join5(packageRoot, declaredBin));
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33617,7 +34069,7 @@ var ManagedNpmPackageInstaller = class {
   install = async (root, definition, environment, signal) => {
     signal.throwIfAborted();
     try {
-      const metadata = await stat3(root);
+      const metadata = await stat4(root);
       if (metadata.isDirectory()) {
         return await validateManagedNpmPackage(root, definition);
       }
@@ -33626,9 +34078,9 @@ var ManagedNpmPackageInstaller = class {
         throw error62;
       }
     }
-    const parent = dirname2(root);
-    await mkdir(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(join4(parent, `.${definition.version}.staging-`));
+    const parent = dirname3(root);
+    await mkdir2(parent, { mode: 448, recursive: true });
+    const staging = await mkdtemp(join5(parent, `.${definition.version}.staging-`));
     try {
       const npm = await findExecutableOnPath(process.platform === "win32" ? "npm.cmd" : "npm", environment);
       if (npm === null) {
@@ -33654,14 +34106,14 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join4(staging, "home"),
+        HOME: join5(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join5(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
         NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
-        PATH: `${dirname2(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+        PATH: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
       };
       if (definition.includeOptionalDependencies) {
         installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
@@ -33678,12 +34130,12 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm(join4(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join4(staging, "home"), { force: true, recursive: true })
+        rm2(join5(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm2(join5(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
-        await rename(staging, root);
+        await rename2(staging, root);
       } catch (error62) {
         try {
           return await validateManagedNpmPackage(root, definition);
@@ -33709,13 +34161,13 @@ var ManagedNpmPackageInstaller = class {
         { cause: error62 }
       );
     } finally {
-      await rm(staging, { force: true, recursive: true });
+      await rm2(staging, { force: true, recursive: true });
     }
   };
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/agent-catalog/version-output.ts
 function normalizeVersionOutput(output2) {
@@ -33738,7 +34190,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join5(stateDirectory, ...this.managedAgentExecutablePath),
+      join6(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -35664,7 +36116,7 @@ var AgentProbeError = class extends Error {
 };
 
 // src/agent-catalog/agents/resolve-user-local-executable.ts
-import { isAbsolute as isAbsolute3, join as join6 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join7 } from "node:path";
 async function resolveUserLocalExecutable(executableName, context) {
   context.signal.throwIfAborted();
   const platform = context.platform ?? process.platform;
@@ -35672,7 +36124,7 @@ async function resolveUserLocalExecutable(executableName, context) {
   if (platform === "win32" || homeDirectory === void 0 || !isAbsolute3(homeDirectory)) {
     return [];
   }
-  const executable = await resolveExecutablePath(join6(homeDirectory, ".local", "bin", executableName), platform);
+  const executable = await resolveExecutablePath(join7(homeDirectory, ".local", "bin", executableName), platform);
   context.signal.throwIfAborted();
   return executable === null ? [] : [executable];
 }
@@ -35761,8 +36213,8 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
-import { mkdir as mkdir2, realpath as realpath4, stat as stat4, writeFile } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join7, normalize as normalize2 } from "node:path";
+import { mkdir as mkdir3, realpath as realpath5, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute4, join as join8, normalize as normalize2 } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -35791,15 +36243,15 @@ async function prepareAgentHome(path2, imagePrompts) {
   }
   try {
     if (imagePrompts) {
-      await mkdir2(path2, { mode: 448, recursive: true });
+      await mkdir3(path2, { mode: 448, recursive: true });
     }
-    const resolved = await realpath4(path2);
-    const metadata = await stat4(resolved);
+    const resolved = await realpath5(path2);
+    const metadata = await stat5(resolved);
     if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
       throw new Error("Agent home is not a user-owned directory");
     }
     if (imagePrompts) {
-      await writeFile(join7(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
+      await writeFile2(join8(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
         mode: 384
       });
     }
@@ -35847,7 +36299,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join7(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join8(readStateDirectory(context.environment), "agents", this.id, "home");
         managedHome = true;
       }
     } catch {
@@ -35863,7 +36315,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join7(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join8(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -35917,8 +36369,8 @@ var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/grok-build-agent.ts
-import { realpath as realpath5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join8, relative as relative2, sep as sep2 } from "node:path";
+import { realpath as realpath6 } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, join as join9, relative as relative2, sep as sep2 } from "node:path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -36013,8 +36465,8 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       );
       if (managed.path === agent.path) {
         return Object.freeze({
-          GROK_HOME: await realpath5(
-            join8(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+          GROK_HOME: await realpath6(
+            join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -36025,9 +36477,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath5(join8(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
-    await validateManagedNpmPackage(join8(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
-    const executable = await resolveExecutablePath(join8(versionRoot, "home", "bin", "grok"), platform);
+    const versionRoot = await realpath6(join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
+    await validateManagedNpmPackage(join9(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
+    const executable = await resolveExecutablePath(join9(versionRoot, "home", "bin", "grok"), platform);
     signal.throwIfAborted();
     if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
       throw new AgentProbeError("managed_agent_invalid", "The managed Grok Build executable is invalid");
@@ -36127,13 +36579,13 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { chmod, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open4, realpath as realpath6, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute6, join as join9, relative as relative3, sep as sep3 } from "node:path";
+import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath7, rename as rename3, rm as rm3, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute6, join as join10, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -36234,7 +36686,7 @@ var ManagedAgentArchiveError = class extends Error {
     this.name = "ManagedAgentArchiveError";
   }
 };
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isContainedPath3(root, candidate) {
@@ -36243,7 +36695,7 @@ function isContainedPath3(root, candidate) {
 }
 async function hashFile(path2, signal) {
   signal.throwIfAborted();
-  const digest = createHash("sha256");
+  const digest = createHash2("sha256");
   const stream = createReadStream(path2, { signal });
   try {
     for await (const chunk of stream) {
@@ -36291,7 +36743,7 @@ async function readManifest(path2) {
       );
     }
     const parsed = JSON.parse(await handle.readFile({ encoding: "utf8" }));
-    if (!isRecord7(parsed)) {
+    if (!isRecord8(parsed)) {
       throw new ManagedAgentArchiveError(
         "managed_archive_verification_failed",
         "The managed Agent archive manifest is invalid"
@@ -36313,16 +36765,16 @@ async function readManifest(path2) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath6(root);
-    const rootMetadata = await stat5(rootPath);
+    const rootPath = await realpath7(root);
+    const rootMetadata = await stat6(rootPath);
     if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
       throw new Error("Managed Agent root is not user-owned");
     }
-    const manifest = await readManifest(join9(rootPath, "archive.json"));
+    const manifest = await readManifest(join10(rootPath, "archive.json"));
     if (manifest["archiveSha256"] !== definition.archiveSha256 || manifest["archiveUrl"] !== definition.archiveUrl.toString() || manifest["version"] !== definition.version || typeof manifest["executableSha256"] !== "string") {
       throw new Error("Managed Agent archive identity is invalid");
     }
-    const executable = await resolveExecutablePath(join9(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join10(rootPath, "bin", definition.executableName));
     if (executable === null || !isContainedPath3(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
       throw new Error("Managed Agent executable is invalid");
     }
@@ -36514,7 +36966,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
     return Object.freeze(environment);
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join10(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join11(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -36532,7 +36984,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import {
   methods as methods7
 } from "@agentclientprotocol/sdk";
@@ -36591,7 +37043,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join11(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join12(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -36629,7 +37081,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { isAbsolute as isAbsolute7, join as join12 } from "node:path";
+import { isAbsolute as isAbsolute7, join as join13 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -36684,7 +37136,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join12(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join13(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -36695,10 +37147,10 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
     if ((context.platform ?? process.platform) !== "darwin") {
       return [];
     }
-    const requestedPaths = [join12("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
+    const requestedPaths = [join13("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
     const homeDirectory = context.environment["HOME"];
     if (homeDirectory !== void 0 && isAbsolute7(homeDirectory)) {
-      requestedPaths.unshift(join12(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
+      requestedPaths.unshift(join13(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
     }
     const executables = [];
     for (const requestedPath2 of requestedPaths) {
@@ -37033,10 +37485,10 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute8, join as join14 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join15 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -37093,7 +37545,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join13(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join14(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -37127,7 +37579,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join14(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join15(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -37441,9 +37893,9 @@ async function discoverLocalAgentInventory(options) {
 }
 
 // src/storage/runtime-installation-store.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
-import { mkdir as mkdir4, open as open5, readdir as readdir2, rename as rename3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname4, join as join15, resolve as resolve4 } from "node:path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5, join as join16, resolve as resolve4 } from "node:path";
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
 var CONNECTION_ID_PATTERN = /^mcn_[a-f0-9]{32}$/;
 var INSTALLATION_ID_PATTERN = /^min_[a-f0-9]{32}$/;
@@ -37507,7 +37959,7 @@ var VerifiedRuntimeConnection = class {
     this.runtimeId = runtimeId;
   }
 };
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expectedKeys) {
@@ -37571,16 +38023,16 @@ function parseRelayOrigin(value) {
   return origin;
 }
 function connectionId() {
-  return `mcn_${randomUUID().replaceAll("-", "")}`;
+  return `mcn_${randomUUID2().replaceAll("-", "")}`;
 }
 function installationId() {
-  return `min_${randomUUID().replaceAll("-", "")}`;
+  return `min_${randomUUID2().replaceAll("-", "")}`;
 }
 function channelIndexFileName(channelId) {
-  return `mci_${createHash2("sha256").update(channelId).digest("hex")}.json`;
+  return `mci_${createHash3("sha256").update(channelId).digest("hex")}.json`;
 }
 function decodeInstallationPointer(value) {
-  if (!isRecord8(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
+  if (!isRecord9(value) || !hasExactKeys(value, INSTALLATION_POINTER_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_installation", "The local installation record is invalid");
   }
   const storedInstallationId = value["installationId"];
@@ -37590,7 +38042,7 @@ function decodeInstallationPointer(value) {
   return { installationId: validateInstallationId(storedInstallationId) };
 }
 function decodeChannelIndex(value) {
-  if (!isRecord8(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
+  if (!isRecord9(value) || !hasExactKeys(value, CHANNEL_INDEX_KEYS) || value["version"] !== 1) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   const applicationId = value["applicationId"];
@@ -37640,7 +38092,7 @@ function decodeVerifiedConnection(value) {
   );
 }
 function decodeConnection(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     throw new RuntimeInstallationStoreError("invalid_connection", "The saved Runtime connection is invalid");
   }
   return decodeVerifiedConnection(value);
@@ -37685,15 +38137,15 @@ async function readJsonFile(path2, signal, missingCode) {
 }
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname4(path2);
-  const temporaryPath = join15(directory, `.${randomUUID()}.tmp`);
+  const directory = dirname5(path2);
+  const temporaryPath = join16(directory, `.${randomUUID2()}.tmp`);
   try {
-    await mkdir4(directory, { mode: 448, recursive: true });
+    await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
-    await writeFile3(temporaryPath, `${JSON.stringify(value, null, 2)}
+    await writeFile4(temporaryPath, `${JSON.stringify(value, null, 2)}
 `, { flag: "wx", mode: 384 });
     signal.throwIfAborted();
-    await rename3(temporaryPath, path2);
+    await rename4(temporaryPath, path2);
   } catch (cause) {
     await unlink(temporaryPath).catch(() => void 0);
     signal.throwIfAborted();
@@ -37712,16 +38164,16 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join15(stateDirectory, "channels");
-    this.#connectionDirectory = join15(stateDirectory, "connections");
+    this.#channelDirectory = join16(stateDirectory, "channels");
+    this.#connectionDirectory = join16(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
     const rootDirectory = resolve4(options.stateDirectory);
-    const applicationDirectory = join15(rootDirectory, "installations", applicationId);
+    const applicationDirectory = join16(rootDirectory, "installations", applicationId);
     try {
-      await mkdir4(applicationDirectory, { mode: 448, recursive: true });
+      await mkdir5(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
       throw new RuntimeInstallationStoreError(
         "installation_unavailable",
@@ -37732,9 +38184,9 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join15(applicationDirectory, storedInstallationId);
+    const stateDirectory = join16(applicationDirectory, storedInstallationId);
     try {
-      await mkdir4(stateDirectory, { mode: 448, recursive: true });
+      await mkdir5(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
       throw new RuntimeInstallationStoreError(
         "installation_unavailable",
@@ -37747,8 +38199,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join15(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join15(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join16(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join16(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -37821,7 +38273,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     let entries;
     try {
-      entries = await readdir2(this.#connectionDirectory);
+      entries = await readdir3(this.#connectionDirectory);
     } catch (cause) {
       if (isNodeError(cause, "ENOENT")) {
         return [];
@@ -37910,7 +38362,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join15(applicationDirectory, "current.json");
+  const pointerPath = join16(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -37920,7 +38372,7 @@ async function readOrCreateInstallationId(applicationDirectory, signal) {
   }
   const candidate = installationId();
   try {
-    await writeFile3(pointerPath, `${JSON.stringify({ installationId: candidate, version: 1 })}
+    await writeFile4(pointerPath, `${JSON.stringify({ installationId: candidate, version: 1 })}
 `, {
       flag: "wx",
       mode: 384
@@ -37958,7 +38410,7 @@ var PairingClientError = class extends Error {
     this.name = "PairingClientError";
   }
 };
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys2(value, expectedKeys) {
@@ -38050,9 +38502,9 @@ function parseResumeConnectionId(arguments_) {
 async function resolveDefaultWorkspace(path2) {
   const requestedWorkspace = resolve5(path2);
   try {
-    await mkdir5(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath7(requestedWorkspace);
-    const metadata = await stat6(defaultWorkspace);
+    await mkdir6(requestedWorkspace, { recursive: true, mode: 448 });
+    const defaultWorkspace = await realpath8(requestedWorkspace);
+    const metadata = await stat7(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
     }
@@ -38081,9 +38533,9 @@ async function readJsonResponse(response) {
   }
 }
 function readRelayError(value) {
-  if (isRecord9(value)) {
+  if (isRecord10(value)) {
     const error62 = value["error"];
-    if (isRecord9(error62)) {
+    if (isRecord10(error62)) {
       const code = error62["code"];
       const message = error62["message"];
       if (typeof code === "string" && typeof message === "string") {
@@ -38094,7 +38546,7 @@ function readRelayError(value) {
   return new PairingClientError("pairing_failed", "The relay could not pair this machine");
 }
 function decodePairingResponse(value, credentialField, expectedKeys) {
-  if (!isRecord9(value) || !hasExactKeys2(value, expectedKeys)) {
+  if (!isRecord10(value) || !hasExactKeys2(value, expectedKeys)) {
     throw new PairingClientError("invalid_relay_response", "The relay returned an invalid pairing response");
   }
   const appId = value["appId"];
@@ -38276,8 +38728,8 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 }
 
 // src/run-daemon.ts
-import { createHash as createHash7, randomUUID as randomUUID7 } from "node:crypto";
-import { join as join18 } from "node:path";
+import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
+import { join as join19 } from "node:path";
 import { styleText } from "node:util";
 
 // src/agent-catalog/publish-agent-catalog.ts
@@ -38309,7 +38761,7 @@ var AgentCatalogPublishError = class extends Error {
     this.name = "AgentCatalogPublishError";
   }
 };
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSafeRelayErrorMessage(value) {
@@ -38322,7 +38774,7 @@ async function rejectedCatalogError(response) {
   } catch {
     return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
   }
-  if (!isRecord10(value) || !isRecord10(value["error"])) {
+  if (!isRecord11(value) || !isRecord11(value["error"])) {
     return new AgentCatalogPublishError("The Relay rejected the Agent catalog update");
   }
   const code = value["error"]["code"];
@@ -38853,9 +39305,9 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir3, realpath as realpath8, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir4, realpath as realpath9, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute9, join as join16, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute9, join as join17, normalize as normalize3, relative as relative4 } from "node:path";
 var WorkspaceDirectoryListing = class {
   directoryId;
   directoryLabel;
@@ -38923,9 +39375,9 @@ var WorkspaceDirectoryService = class {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
-      const target = await realpath8(requested);
+      const target = await realpath9(requested);
       signal.throwIfAborted();
-      const metadata = await stat7(target);
+      const metadata = await stat8(target);
       signal.throwIfAborted();
       if (!isAbsolute9(target) || normalize3(target) !== target || !metadata.isDirectory()) {
         throw new LocalAuthorizationError("The selected location is not a directory");
@@ -38962,7 +39414,7 @@ var WorkspaceDirectoryService = class {
   list = async (bindingId, id, signal) => {
     const target = await this.resolve(bindingId, id, signal);
     try {
-      const children = await readdir3(target, { withFileTypes: true });
+      const children = await readdir4(target, { withFileTypes: true });
       signal.throwIfAborted();
       const entries = [];
       for (const child2 of children) {
@@ -38973,7 +39425,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join16(target, child2.name), signal);
+          const path2 = await this.resolvePath(join17(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -38983,7 +39435,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname5(target);
+      const parent = dirname6(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -39009,15 +39461,15 @@ var WorkspaceDirectoryService = class {
 
 // src/daemon-diagnostic-log.ts
 import { appendFileSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var MAXIMUM_DAEMON_LOG_BYTES = 1 * 1024 * 1024;
 var DaemonDiagnosticLog = class {
   #directory;
   #path;
   #maximumBytes;
   constructor(stateDirectory, maximumBytes = MAXIMUM_DAEMON_LOG_BYTES) {
-    this.#directory = join17(stateDirectory, "logs");
-    this.#path = join17(this.#directory, "daemon.log");
+    this.#directory = join18(stateDirectory, "logs");
+    this.#path = join18(this.#directory, "daemon.log");
     this.#maximumBytes = maximumBytes;
   }
   record = (diagnostic) => {
@@ -39062,7 +39514,7 @@ import { WebSocket as WebSocket2 } from "undici";
 import { WebSocket } from "undici";
 
 // src/prompt-artifact-resolver.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { fetch as fetch4 } from "undici";
 var ARTIFACT_SCHEME = "mobius-artifact:";
 var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
@@ -39200,7 +39652,7 @@ async function download(config2, command, reference, signal) {
       );
     }
     const bytes = await responseBytes(response, reference.byteLength, requestSignal);
-    if (createHash3("sha256").update(bytes).digest("hex") !== reference.sha256) {
+    if (createHash4("sha256").update(bytes).digest("hex") !== reference.sha256) {
       throw new PromptArtifactError(
         "artifact_integrity_failed",
         "The prompt artifact failed integrity validation"
@@ -39505,7 +39957,7 @@ var DaemonInstallationObserver = class {
 };
 
 // src/daemon-active-turn.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 function activeMessageCharacters(message) {
   return message.text.length + (message.role === "assistant" ? JSON.stringify(message.activities).length + JSON.stringify(message.content).length : 0);
 }
@@ -39539,7 +39991,7 @@ var ActiveDaemonTurn = class {
   #timeline;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID2());
+  #epoch = decodeIdentifier(randomUUID3());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -39601,7 +40053,7 @@ var ActiveDaemonTurn = class {
       if (!this.#activities.has(event.activityId)) {
         this.#timeline = [
           ...this.#timeline,
-          { activityId: event.activityId, id: decodeIdentifier(randomUUID2()), kind: "activity" }
+          { activityId: event.activityId, id: decodeIdentifier(randomUUID3()), kind: "activity" }
         ];
       }
       this.#activities.set(event.activityId, {
@@ -39622,7 +40074,7 @@ var ActiveDaemonTurn = class {
       if (previous === void 0) {
         this.#timeline = [
           ...this.#timeline,
-          { activityId: event.activityId, id: decodeIdentifier(randomUUID2()), kind: "activity" }
+          { activityId: event.activityId, id: decodeIdentifier(randomUUID3()), kind: "activity" }
         ];
       }
       this.#activities.set(event.activityId, {
@@ -39647,7 +40099,7 @@ var ActiveDaemonTurn = class {
           ...this.#timeline,
           {
             content: /* @__PURE__ */ new Map([[event.contentId, event.content]]),
-            id: decodeIdentifier(randomUUID2()),
+            id: decodeIdentifier(randomUUID3()),
             kind: "message",
             sourceMessageId: event.messageId,
             text: ""
@@ -39687,7 +40139,7 @@ var ActiveDaemonTurn = class {
         ...this.#timeline,
         {
           content: /* @__PURE__ */ new Map(),
-          id: decodeIdentifier(randomUUID2()),
+          id: decodeIdentifier(randomUUID3()),
           kind: "message",
           sourceMessageId: messageId,
           text: remaining.slice(0, ACTIVE_TURN_TEXT_CHUNK_LIMIT)
@@ -40663,7 +41115,7 @@ var readCodexFullHistory = async (agent, cwd, nativeSessionId, signal, nativeTur
 });
 
 // src/native-sessions/service.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { basename as basename5 } from "node:path";
 
 // src/native-sessions/acp-history.ts
@@ -40878,7 +41330,7 @@ var NativeSessionService = class {
       if (authorized === null) {
         return null;
       }
-      const entryId = decodeIdentifier(randomUUID3());
+      const entryId = decodeIdentifier(randomUUID4());
       if (this.#entries.size >= 5e3) {
         this.#entries.clear();
       }
@@ -40934,7 +41386,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID3());
+        nextCursor = decodeIdentifier(randomUUID4());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -41216,7 +41668,7 @@ var NativeSessionService = class {
 };
 
 // src/relay-connection/daemon-operation-state.ts
-import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 function isTerminal(state) {
   return state === "succeeded" || state === "failed" || state === "cancelled";
@@ -41225,7 +41677,7 @@ var DaemonOperationState = class {
   #executions = /* @__PURE__ */ new Map();
   #terminalCount = 0;
   claimExecution = (commandId, sessionId, commandJson) => {
-    const commandHash = createHash4("sha256").update(commandJson).digest("hex");
+    const commandHash = createHash5("sha256").update(commandJson).digest("hex");
     const existing = this.#executions.get(commandId);
     if (existing !== void 0) {
       if (existing.sessionId !== sessionId || existing.commandHash !== commandHash) {
@@ -41233,7 +41685,7 @@ var DaemonOperationState = class {
       }
       return { attemptId: existing.attemptId, commandId, kind: "duplicate", state: existing.state };
     }
-    const attemptId = randomUUID4();
+    const attemptId = randomUUID5();
     this.#executions.set(commandId, { attemptId, commandHash, sessionId, state: "dispatching" });
     return { attemptId, commandId, kind: "accepted", state: "dispatching" };
   };
@@ -41569,7 +42021,7 @@ function createAgentCatalogRefreshHandler(dependencies) {
 import { WebSocket as WebSocket4 } from "undici";
 
 // src/agent-catalog/discover-agent-settings.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // src/agent-catalog/agent-settings-base.ts
 var AgentSettingsConfigurationError = class extends Error {
@@ -42033,7 +42485,7 @@ function settingsRevision(agent, reportedAgentVersion, settings, modelEffort) {
     unsupportedModelIds: modelEffort.unsupportedModelIds,
     valuesByModel: {}
   };
-  return createHash5("sha256").update(
+  return createHash6("sha256").update(
     JSON.stringify({
       adapterVersion: agent.kind === "acp-adapter-process" ? agent.adapterVersion : agent.agentVersion,
       agentId: agent.id,
@@ -42184,7 +42636,7 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { realpath as realpath10, stat as stat9 } from "node:fs/promises";
 import { basename as basename6, isAbsolute as isAbsolute10, normalize as normalize4, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
@@ -42212,7 +42664,7 @@ async function resolveFile(value, workingDirectory, signal) {
     return null;
   }
   try {
-    const target = await realpath9(requested);
+    const target = await realpath10(requested);
     signal.throwIfAborted();
     return isAbsolute10(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -42220,23 +42672,24 @@ async function resolveFile(value, workingDirectory, signal) {
     return null;
   }
 }
-async function streamLocalFile(command, send2, signal, workingDirectory) {
-  const target = await resolveFile(command.path, workingDirectory, signal);
+async function streamLocalFile(command, send2, signal, workingDirectory, externalContent) {
+  const external = await externalContent.resolve(command.sessionId, command.path, signal);
+  const target = external?.path ?? await resolveFile(command.path, workingDirectory, signal);
   if (target === null) {
     throw new Error("The local file is unavailable");
   }
-  const before = await stat8(target);
+  const before = await stat9(target);
   signal.throwIfAborted();
   if (!before.isFile() || before.size < 1 || before.size > command.maxBytes) {
     throw new Error("The local file is too large to read");
   }
-  const raster = await readLocalRaster(target, signal);
+  const raster = external === null ? await readLocalRaster(target, signal) : null;
   send2({
     byteLength: before.size,
     kind: FILE_BEGIN_KIND,
-    mediaType: raster?.mimeType ?? "application/octet-stream",
+    mediaType: external?.mediaType ?? raster?.mimeType ?? "application/octet-stream",
     modifiedAt: before.mtime.toISOString(),
-    name: basename6(target) || "file",
+    name: external?.name ?? (basename6(target) || "file"),
     requestId: command.requestId,
     sessionId: command.sessionId
   });
@@ -42253,7 +42706,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
     });
     sequence += 1;
   }
-  const after = await stat8(target);
+  const after = await stat9(target);
   signal.throwIfAborted();
   if (after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
     throw new Error("The local file changed during transfer");
@@ -42266,7 +42719,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory) {
 }
 
 // src/daemon-history-commands.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 
 // src/authorization/resolve-session-directories.ts
 import { basename as basename7 } from "node:path";
@@ -42660,7 +43113,7 @@ async function executeSessionLiveHistoryPageLoad(socket, command, config2, direc
 }
 function replayEvent(sessionId, position, update) {
   const encoded = JSON.stringify(update);
-  const eventId = `native-${createHash6("sha256").update(sessionId).update(":").update(position.toString()).update(":").update(encoded).digest("hex")}`;
+  const eventId = `native-${createHash7("sha256").update(sessionId).update(":").update(position.toString()).update(":").update(encoded).digest("hex")}`;
   return {
     eventId,
     payload: update,
@@ -42743,7 +43196,7 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
 }
 
 // src/acp/session-config/apply-session-configuration.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function invalidSessionConfiguration(message) {
   return new AcpExecutionError(message, {}, "invalid_session_configuration");
 }
@@ -42884,7 +43337,7 @@ async function applySessionConfigurationSelection(sessions, audit, options, sele
     booleanValue: selection.booleanValue,
     configId: selection.configId,
     cwd,
-    requestId: `cfg_${randomUUID5()}`,
+    requestId: `cfg_${randomUUID6()}`,
     sessionId,
     signal,
     value: selection.value,
@@ -43558,6 +44011,7 @@ function createDaemonCommandHandler({
   operations,
   publisher,
   eventLogV2,
+  externalContent,
   activeTurns,
   diagnostics,
   socket,
@@ -43666,7 +44120,8 @@ function createDaemonCommandHandler({
           command2,
           (message2) => send(socket, message2),
           signal,
-          sessions.findSessions([command2.sessionId])[0]?.cwd ?? null
+          sessions.findSessions([command2.sessionId])[0]?.cwd ?? null,
+          externalContent
         ).catch((error62) => {
           if (socket.readyState !== WebSocket6.OPEN || signal.aborted) {
             return;
@@ -43985,7 +44440,7 @@ function connectRelay(url2, signal) {
 }
 
 // src/relay-connection/liveness.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 var HEARTBEAT_ACK_TIMEOUT_MILLISECONDS = 1e4;
 var HEARTBEAT_INTERVAL_MILLISECONDS = 2e4;
 var RelayLivenessState = class {
@@ -44074,7 +44529,7 @@ var RelayConnectionLiveness = class {
       }
       throw new Error("Heartbeat was scheduled in an invalid state");
     }
-    const heartbeatId = randomUUID6();
+    const heartbeatId = randomUUID7();
     this.#state = new AwaitingHeartbeatAckState(
       heartbeatId,
       this.#timer.schedule(this.#handleTimeout, HEARTBEAT_ACK_TIMEOUT_MILLISECONDS)
@@ -44114,6 +44569,7 @@ async function runRelayConnection({
   operations,
   publisher,
   eventLogV2,
+  externalContent,
   activeTurns,
   connectionEpoch,
   diagnostics,
@@ -44137,6 +44593,7 @@ async function runRelayConnection({
     operations,
     publisher,
     eventLogV2,
+    externalContent,
     activeTurns,
     diagnostics,
     socket,
@@ -44615,7 +45072,7 @@ async function installDetectedAgentIntegrations(config2, installations, signal)
       {
         agentId: agent.id,
         kind: AGENT_INSTALL_REQUEST_KIND,
-        requestId: `automatic-integration-${randomUUID7()}`
+        requestId: `automatic-integration-${randomUUID8()}`
       },
       signal
     );
@@ -44634,8 +45091,9 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const sessionStore = new SqliteAcpSessionStore(
-    join18(stateDirectory, "sessions", `${createHash7("sha256").update(config2.channelId).digest("hex")}.sqlite`)
+    join19(stateDirectory, "sessions", `${createHash8("sha256").update(config2.channelId).digest("hex")}.sqlite`)
   );
+  await using externalContent = new LocalExternalContentStore(stateDirectory);
   const operations = new DaemonOperationState();
   const publisher = new DaemonSessionEventPublisher(sessionStore);
   const eventLogV2 = new DaemonSessionEventLogV2(publisher, sessionStore);
@@ -44656,7 +45114,8 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
       )).history : null
     },
     "native",
-    publisher.publishStatus
+    publisher.publishStatus,
+    new AcpContentExternalizer(externalContent)
   );
   const directories = new WorkspaceDirectoryService(config2.bindingId, config2.defaultWorkspace);
   const installationObserver = new DaemonInstallationObserver();
@@ -44770,6 +45229,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
           operations,
           publisher,
           eventLogV2,
+          externalContent,
           activeTurns,
           connectionEpoch,
           diagnostics,
@@ -44826,7 +45286,7 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 }
 
 // src/runtime.ts
-import { mkdir as mkdir6, realpath as realpath10, stat as stat9 } from "node:fs/promises";
+import { mkdir as mkdir7, realpath as realpath11, stat as stat10 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 var RUNTIME_CREDENTIAL_PATTERN2 = /^[a-zA-Z0-9_-]{32,256}$/;
 var MobiusRuntimeConfigurationError = class extends Error {
@@ -44892,9 +45352,9 @@ function loadMobiusRuntimeConnection(environment = process.env) {
 async function resolveWorkspace(path2) {
   const requested = resolve8(path2);
   try {
-    await mkdir6(requested, { recursive: true, mode: 448 });
-    const resolved = await realpath10(requested);
-    const metadata = await stat9(resolved);
+    await mkdir7(requested, { recursive: true, mode: 448 });
+    const resolved = await realpath11(requested);
+    const metadata = await stat10(resolved);
     if (!metadata.isDirectory()) {
       throw new MobiusRuntimeConfigurationError("The Runtime workspace is not a directory");
     }