@moxt-ai/mobius 0.0.356 → 0.0.358

package/dist/engine.js

@@ -20720,6 +20720,7 @@ var lifecycleMetadataSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({
     ...lifecycleBase,
     kind: external_exports.literal("prompt.completed"),
+    execution: external_exports.literal("not-started").optional(),
     stopReason: shortString
   }).readonly(),
   external_exports.object({
@@ -69127,6 +69128,7 @@ var CodexBorrowedAcpAgent = class {
       content,
       clientId: randomUUID7(),
       completion: Promise.withResolvers(),
+      settled: Promise.withResolvers(),
       input: { kind: "awaiting" }
     };
     this.#pending = pending;
@@ -69164,7 +69166,6 @@ var CodexBorrowedAcpAgent = class {
       throw cause;
     } finally {
       signal.removeEventListener("abort", abort);
-      this.#pending = null;
       if (outcome === "cancelled") {
         try {
           await this.#removeQueuedInput(pending.clientId);
@@ -69172,6 +69173,8 @@ var CodexBorrowedAcpAgent = class {
           console.error("The cancelled Codex queued input could not be removed", cause);
         }
       }
+      this.#pending = null;
+      pending.settled.resolve();
     }
   };
   #removeQueuedInput = async (clientId) => {
@@ -69231,7 +69234,11 @@ var CodexBorrowedAcpAgent = class {
     );
   };
   cancel = async () => {
-    this.#pending?.completion.resolve({ stopReason: "cancelled" });
+    const pending = this.#pending;
+    if (pending !== null) {
+      pending.completion.resolve({ stopReason: "cancelled" });
+      await pending.settled.promise;
+    }
   };
   close = async () => {
     this.#lifecycle = { kind: "closed" };
@@ -70232,40 +70239,42 @@ async function replayCodexHistory(client2, threadId, emit, signal) {
           continue;
         }
         if (item.type === "userMessage") {
-          const text2 = item.content.flatMap((content) => {
+          const contents = item.content.flatMap((content) => {
             if (typeof content !== "object" || content === null) {
               return [];
             }
             const type = Reflect.get(content, "type");
-            const text3 = Reflect.get(content, "text");
+            const text2 = Reflect.get(content, "text");
             const url2 = Reflect.get(content, "url");
             if (type === "image" && typeof url2 === "string") {
               return [`[@image](${url2})`];
             }
-            return type === "text" && typeof text3 === "string" ? [text3] : [];
-          }).join("");
-          const history = await embedLocalHistoryImages(
-            { status: "available", truncated: false, messages: [{ role: "user", text: text2 }] },
-            deadline
-          );
-          if (history.status !== "available") {
-            continue;
-          }
-          const message = history.messages[0];
-          for (const image of message?.images ?? []) {
-            await emit({
-              content: { type: "image", data: image.data, mimeType: image.mimeType },
-              messageId: item.id,
-              sessionUpdate: "user_message_chunk"
-            });
-          }
-          const restoredText = message?.text ?? "";
-          if (restoredText.length > 0) {
-            await emit({
-              content: { text: restoredText, type: "text" },
-              messageId: item.id,
-              sessionUpdate: "user_message_chunk"
-            });
+            return type === "text" && typeof text2 === "string" ? [text2] : [];
+          });
+          for (const text2 of contents) {
+            const history = await embedLocalHistoryImages(
+              { status: "available", truncated: false, messages: [{ role: "user", text: text2 }] },
+              deadline
+            );
+            if (history.status !== "available") {
+              continue;
+            }
+            const message = history.messages[0];
+            for (const image of message?.images ?? []) {
+              await emit({
+                content: { type: "image", data: image.data, mimeType: image.mimeType },
+                messageId: item.id,
+                sessionUpdate: "user_message_chunk"
+              });
+            }
+            const restoredText = message?.text ?? "";
+            if (restoredText.length > 0) {
+              await emit({
+                content: { text: restoredText, type: "text" },
+                messageId: item.id,
+                sessionUpdate: "user_message_chunk"
+              });
+            }
           }
         } else if (item.type === "agentMessage") {
           await emit(agentMessageUpdate(item.id, item.text));
@@ -70930,16 +70939,19 @@ var CodexAcpAgent = class {
    */
   close = () => {
     if (this.#closePromise === null) {
-      this.#appServer.detach();
       this.#closePromise = (async () => {
-        await this.#sessionAgent.close();
-        const child = this.#appServer.child();
         try {
-          const captured = await captureProcessTree(child);
-          await stopProcessTree(child, captured);
+          await this.#sessionAgent.close();
         } finally {
-          this.#connection?.close();
-          this.#onBackgroundActivity?.("none");
+          this.#appServer.detach();
+          const child = this.#appServer.child();
+          try {
+            const captured = await captureProcessTree(child);
+            await stopProcessTree(child, captured);
+          } finally {
+            this.#connection?.close();
+            this.#onBackgroundActivity?.("none");
+          }
         }
       })();
     }
@@ -73327,14 +73339,21 @@ function toToolKind(toolName) {
 }
 
 // src/engine/acp/harness/pi/upstream/dist/acp/translate/pi-messages.js
-function normalizePiMessageText(content) {
+var userContentSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() }),
+  external_exports.object({ type: external_exports.literal("image"), data: external_exports.string(), mimeType: external_exports.string() })
+]);
+function piUserMessageContent(content) {
   if (typeof content === "string") {
-    return content;
+    return content.length === 0 ? [] : [{ type: "text", text: content }];
   }
   if (!Array.isArray(content)) {
-    return "";
+    return [];
   }
-  return content.map((c) => c?.type === "text" && typeof c.text === "string" ? c.text : "").filter(Boolean).join("");
+  return content.flatMap((value) => {
+    const parsed = userContentSchema.safeParse(value);
+    return parsed.success ? [parsed.data] : [];
+  });
 }
 function normalizePiAssistantText(content) {
   if (!Array.isArray(content)) {
@@ -74427,13 +74446,13 @@ ${JSON.stringify(stats, null, 2)}`;
       const m = entry.message;
       const role = String(m?.role ?? "");
       if (role === "user") {
-        const text2 = normalizePiMessageText(m?.content);
-        if (text2) {
+        this.conn.startUserMessage();
+        for (const content of piUserMessageContent(m.content)) {
           await this.conn.sessionUpdate({
             sessionId: session.sessionId,
             update: {
               sessionUpdate: "user_message_chunk",
-              content: { type: "text", text: text2 }
+              content
             }
           });
         }
@@ -75825,6 +75844,7 @@ var AdapterRegistry = class {
   resolve = (agent) => {
     const existing = this.#adapters.get(agent.id);
     if (existing !== void 0) {
+      existing.refreshAgent(agent);
       return existing;
     }
     const adapter = this.#resolve(agent, this.#dependencies);
@@ -76262,63 +76282,64 @@ var AdapterSessionConnection = class {
       const externalized = await externalizer.update(options.sessionId(), notification.update, signal);
       signal.throwIfAborted();
       const update = externalized.agent;
-      const eventUpdate = externalized.event;
-      const backgroundTask = update._meta?.["mobius.backgroundTask"];
-      const payload = decodeAcpSessionUpdate(
-        JSON.stringify(
-          normalizeEvent(
-            (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") && backgroundTask !== void 0 && typeof eventUpdate === "object" && eventUpdate !== null ? { ...eventUpdate, backgroundTask } : eventUpdate
+      for (const eventUpdate of externalized.events) {
+        const backgroundTask = update._meta?.["mobius.backgroundTask"];
+        const payload = decodeAcpSessionUpdate(
+          JSON.stringify(
+            normalizeEvent(
+              (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") && backgroundTask !== void 0 && typeof eventUpdate === "object" && eventUpdate !== null ? { ...eventUpdate, backgroundTask } : eventUpdate
+            )
           )
-        )
-      );
-      let event;
-      switch (update.sessionUpdate) {
-        case "available_commands_update":
-          event = {
-            kind: "commands",
-            payload,
-            commands: update.availableCommands.slice(0, 500).map((command) => ({
-              description: truncate(command.description, 500),
-              inputHint: truncate(command.input?.hint ?? "", 255),
-              name: truncate(command.name, 128)
-            })).filter((command) => command.name.length > 0)
-          };
-          break;
-        case "config_option_update":
-          event = {
-            kind: "configuration",
-            payload,
-            configOptions: protocol.normalizeUpdate(options.configOptions(), update.configOptions)
-          };
-          break;
-        case "current_mode_update":
-          event = { kind: "mode", payload, modeId: update.currentModeId };
-          break;
-        case "session_info_update": {
-          const changes = [];
-          if (Object.hasOwn(update, "title")) {
-            changes.push({ kind: "title", value: truncate(update.title ?? "", 500) });
-          }
-          if (Object.hasOwn(update, "updatedAt")) {
-            changes.push({ kind: "updated-at", value: truncate(update.updatedAt ?? "", 128) });
+        );
+        let event;
+        switch (update.sessionUpdate) {
+          case "available_commands_update":
+            event = {
+              kind: "commands",
+              payload,
+              commands: update.availableCommands.slice(0, 500).map((command) => ({
+                description: truncate(command.description, 500),
+                inputHint: truncate(command.input?.hint ?? "", 255),
+                name: truncate(command.name, 128)
+              })).filter((command) => command.name.length > 0)
+            };
+            break;
+          case "config_option_update":
+            event = {
+              kind: "configuration",
+              payload,
+              configOptions: protocol.normalizeUpdate(options.configOptions(), update.configOptions)
+            };
+            break;
+          case "current_mode_update":
+            event = { kind: "mode", payload, modeId: update.currentModeId };
+            break;
+          case "session_info_update": {
+            const changes = [];
+            if (Object.hasOwn(update, "title")) {
+              changes.push({ kind: "title", value: truncate(update.title ?? "", 500) });
+            }
+            if (Object.hasOwn(update, "updatedAt")) {
+              changes.push({ kind: "updated-at", value: truncate(update.updatedAt ?? "", 128) });
+            }
+            event = { kind: "info", payload, changes };
+            break;
           }
-          event = { kind: "info", payload, changes };
-          break;
+          case "user_message_chunk":
+          case "agent_message_chunk":
+          case "agent_thought_chunk":
+          case "tool_call":
+          case "tool_call_update":
+          case "plan":
+          case "plan_update":
+          case "plan_removed":
+            event = { kind: "content", payload };
+            break;
+          default:
+            event = { kind: "other", payload };
         }
-        case "user_message_chunk":
-        case "agent_message_chunk":
-        case "agent_thought_chunk":
-        case "tool_call":
-        case "tool_call_update":
-        case "plan":
-        case "plan_update":
-        case "plan_removed":
-          event = { kind: "content", payload };
-          break;
-        default:
-          event = { kind: "other", payload };
+        await options.onEvent(event);
       }
-      await options.onEvent(event);
     });
     this.events = this.#updates;
     const client2 = {
@@ -76359,6 +76380,9 @@ var AdapterSessionConnection = class {
   get connection() {
     return this.#connection.connection;
   }
+  get termination() {
+    return this.#connection.termination;
+  }
   initialize = (signal) => this.#connection.initialize(signal);
   agentSettingsModelEffort = () => this.#connection.agentSettingsModelEffort();
   race = (operation, exitMessage, signal) => this.#connection.race(operation, exitMessage, signal);
@@ -76472,6 +76496,7 @@ var AcpLiveSessions = class {
       "ACP agent exited while cancelling a prompt",
       bounded
     );
+    return "retained";
   };
   closeSession = async (target, signal) => {
     const session = this.#find(target);
@@ -76683,7 +76708,7 @@ var lookupSchema = external_exports.object({
     maximumEntries: external_exports.number().int().positive().nullable()
   })
 });
-async function findNativeSession(list, query, nativeSessionId, budget) {
+async function findNativeSession(list, cwd, nativeSessionId, budget, signal) {
   const decoded = lookupSchema.safeParse({ nativeSessionId, budget });
   if (!decoded.success) {
     throw new AcpExecutionError(
@@ -76697,9 +76722,9 @@ async function findNativeSession(list, query, nativeSessionId, budget) {
   let inspected = 0;
   const visited = /* @__PURE__ */ new Set();
   for (let pageNumber = 0; pageNumber < limits.maximumPages; pageNumber += 1) {
-    query.signal.throwIfAborted();
-    const page = await list(query, cursor);
-    query.signal.throwIfAborted();
+    signal.throwIfAborted();
+    const page = await list(cwd, cursor, signal);
+    signal.throwIfAborted();
     inspected += page.sessions.length;
     const found = page.sessions.find((session) => session.sessionId === decoded.data.nativeSessionId);
     if (found !== void 0) {
@@ -76721,6 +76746,9 @@ async function findNativeSession(list, query, nativeSessionId, budget) {
   throw new AcpExecutionError("The native session was not found", {}, "native_session_not_found");
 }
 
+// src/engine/acp/adapter/query-processes.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+
 // src/engine/session/history/session-event-store.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
 
@@ -77429,45 +77457,51 @@ async function initializeAgentConnection(connection, agentId, verifiedVersion, s
 
 // src/engine/acp/adapter/query-session.ts
 var AcpQuerySession = class _AcpQuerySession {
-  #options;
+  #cwd;
+  #sessionId;
   #events;
   #connection;
+  #lifecycle = { kind: "open" };
   #capabilities = unsupportedSessionCapabilities();
   #configOptions = [];
-  constructor(options, events, connector) {
-    this.#options = options;
+  constructor(agent, cwd, sessionId, events, connector) {
+    this.#cwd = cwd;
+    this.#sessionId = sessionId;
     this.#events = events;
     this.#connection = connector.connectQuerySession({
-      agent: options.agent,
-      cwd: options.cwd,
-      sessionId: () => options.sessionId,
+      agent,
+      cwd,
+      sessionId: () => sessionId,
       configOptions: () => this.#configOptions,
       onEvent: async (event) => {
-        this.#events.append(options.sessionId, { type: "acp", payload: event.payload });
+        this.#events.append(sessionId, { type: "acp", payload: event.payload });
         if (event.kind === "configuration") {
           this.#configOptions = event.configOptions;
         }
       }
     });
+    void this.#connection.termination.then(() => {
+      this.#lifecycle = { kind: "terminated" };
+    });
   }
-  static start = async (options, events, connector) => {
+  static start = async (agent, cwd, sessionId, events, connector, signal) => {
     for (let attempt = 1; attempt <= 2; attempt += 1) {
-      await validateAgentRuntime(options.agent, options.signal);
-      const runtime = new _AcpQuerySession(options, events, connector);
+      await validateAgentRuntime(agent, signal);
+      const runtime = new _AcpQuerySession(agent, cwd, sessionId, events, connector);
       try {
         const initialized = await initializeAgentConnection(
           runtime.#connection,
-          options.agent.id,
-          options.agent.agentVersion,
-          options.signal
+          agent.id,
+          agent.agentVersion,
+          signal
         );
         runtime.#capabilities = initialized.capabilities;
         return runtime;
       } catch (error62) {
         await runtime.closeProcess();
-        options.signal.throwIfAborted();
+        signal.throwIfAborted();
         if (error62 instanceof RetryableAcpInitializationError && attempt === 1) {
-          console.warn(`[${options.agent.id}-acp] ACP agent initialization failed; retrying once`);
+          console.warn(`[${agent.id}-acp] ACP agent initialization failed; retrying once`);
           continue;
         }
         if (error62 instanceof AcpExecutionError) {
@@ -77479,7 +77513,18 @@ var AcpQuerySession = class _AcpQuerySession {
     throw new AcpExecutionError("ACP agent initialization failed");
   };
   capabilities = () => this.#capabilities;
-  belongsTo = (agentId, cwd, directories) => this.#options.agent.id === agentId && this.#options.cwd === cwd && arraysEqual(this.#options.additionalDirectories, directories);
+  hasTerminated = () => {
+    switch (this.#lifecycle.kind) {
+      case "open":
+        return false;
+      case "terminated":
+        return true;
+      default: {
+        const unreachable3 = this.#lifecycle;
+        return unreachable3;
+      }
+    }
+  };
   listNativeSessions = async (cursor, signal) => {
     if (!this.#capabilities.listSessions) {
       throw new AcpExecutionError(
@@ -77505,7 +77550,7 @@ var AcpQuerySession = class _AcpQuerySession {
     }
     return decoded.data;
   };
-  previewEvents = async (nativeSessionId, eventLimit, signal) => {
+  previewEvents = async (nativeSessionId, eventLimit, additionalDirectories, signal) => {
     if (!this.#capabilities.loadSession) {
       throw new AcpExecutionError(
         "This Agent restores context but does not provide message history.",
@@ -77513,14 +77558,14 @@ var AcpQuerySession = class _AcpQuerySession {
         "native_history_unsupported"
       );
     }
-    this.#events.reset(this.#options.sessionId);
+    this.#events.reset(this.#sessionId);
     this.#connection.events.select(nativeSessionId);
     await this.#connection.race(
       this.#connection.connection.agent.request(
         methods12.agent.session.load,
         {
-          additionalDirectories: [...this.#options.additionalDirectories],
-          cwd: this.#options.cwd,
+          additionalDirectories: [...additionalDirectories],
+          cwd: this.#cwd,
           mcpServers: [],
           sessionId: nativeSessionId
         },
@@ -77531,125 +77576,105 @@ var AcpQuerySession = class _AcpQuerySession {
     );
     await this.#connection.events.drained();
     signal.throwIfAborted();
-    return this.#events.page(this.#options.sessionId, eventLimit, null);
+    return this.#events.page(this.#sessionId, eventLimit, null);
   };
   closeProcess = async () => await this.#connection.closeProcess();
+  discardEvents = () => this.#events.remove(this.#sessionId);
 };
 
 // src/engine/acp/adapter/query-processes.ts
 var AgentQueryProcesses = class {
   #eventPreviewsBySession = /* @__PURE__ */ new Map();
-  #processesByQuery;
+  #processesByAgent = /* @__PURE__ */ new Map();
+  #agent;
   #processes;
   #store = new MemorySessionEventStore();
   #connector;
-  constructor(processes, connector) {
+  constructor(agent, processes, connector) {
+    this.#agent = agent;
     this.#processes = processes;
     this.#connector = connector;
-    this.#processesByQuery = new RetainedAgentProcesses({
-      touch: processes.touch,
-      changed: processes.notifyChanged
-    });
   }
-  retire = async (sessionId, runtime) => {
-    const retained = this.#processesByQuery.detach(sessionId, runtime);
-    if (retained) {
-      this.#store.remove(sessionId);
+  refreshAgent = (agent) => {
+    this.#agent = agent;
+  };
+  retire = async (readers, cwd, runtime) => {
+    readers.detach(cwd, runtime);
+    try {
+      await this.#processes.retire(runtime, () => runtime.closeProcess());
+    } finally {
+      runtime.discardEvents();
     }
-    await this.#processes.retire(runtime, () => runtime.closeProcess());
   };
-  async #startRetained(options) {
-    const runtime = await this.#processes.startRetained(
-      options.signal,
-      () => AcpQuerySession.start(options, this.#store, this.#connector),
-      {
-        isBusy: () => this.#processesByQuery.isBusy(options.sessionId),
-        retire: (runtime2) => this.retire(options.sessionId, runtime2),
-        retireIdle: (runtime2) => this.retire(options.sessionId, runtime2)
-      }
-    );
-    this.#processesByQuery.retain(options.sessionId, runtime);
-    return runtime;
-  }
-  async #startPreparation(options) {
-    return await this.#processesByQuery.prepare(options.sessionId, async () => {
-      return await this.#startRetained(options);
-    });
-  }
-  async #replacePreparation(existing, options) {
-    return await this.#processesByQuery.prepare(options.sessionId, async () => {
-      await this.retire(options.sessionId, existing);
-      return await this.#startRetained(options);
-    });
-  }
-  #prepare = async (options) => {
-    const pending = this.#processesByQuery.pending(options.sessionId);
+  async #ensure(agent, readers, cwd, signal) {
+    signal.throwIfAborted();
+    const pending = readers.pending(cwd);
     if (pending !== void 0) {
-      const runtime2 = await waitForSharedOperation(pending, options.signal);
-      if (runtime2.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#processesByQuery.touch(options.sessionId, runtime2);
-        return runtime2.capabilities();
-      }
-      return await this.#prepare(options);
-    }
-    const existing = this.#processesByQuery.get(options.sessionId);
-    if (existing !== void 0) {
-      if (existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#processesByQuery.touch(options.sessionId, existing);
-        return existing.capabilities();
-      }
-      const runtime2 = await this.#replacePreparation(existing, options);
-      return runtime2.capabilities();
+      return await waitForSharedOperation(pending, signal);
     }
-    const runtime = await this.#startPreparation(options);
-    return runtime.capabilities();
-  };
-  async #ensure(options) {
-    const existing = this.#processesByQuery.get(options.sessionId);
-    if (existing !== void 0) {
-      if (!existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        throw new AcpExecutionError(
-          "The agent or workspace cannot change after a conversation has started",
-          {},
-          "session_identity_mismatch"
-        );
-      }
-      this.#processesByQuery.touch(options.sessionId, existing);
+    const existing = readers.get(cwd);
+    if (existing !== void 0 && !existing.hasTerminated()) {
+      readers.touch(cwd, existing);
       return existing;
     }
-    await this.#prepare(options);
-    const started = this.#processesByQuery.get(options.sessionId);
-    if (started === void 0) {
-      throw new AcpExecutionError("ACP native session browser did not start");
-    }
-    return started;
+    return await readers.prepare(cwd, async () => {
+      if (existing !== void 0) {
+        await this.retire(readers, cwd, existing);
+      }
+      const readerId = randomUUID14();
+      const runtime = await this.#processes.startRetained(
+        signal,
+        () => AcpQuerySession.start(agent, cwd, readerId, this.#store, this.#connector, signal),
+        {
+          isBusy: () => readers.isBusy(cwd),
+          retire: (runtime2) => this.retire(readers, cwd, runtime2),
+          retireIdle: (runtime2) => this.retire(readers, cwd, runtime2)
+        }
+      );
+      readers.retain(cwd, runtime);
+      return runtime;
+    });
   }
-  #use = async (options, operation) => await this.#processesByQuery.use(options.sessionId, async () => await operation(await this.#ensure(options)));
-  capabilities = async (query) => await this.#prepare(query);
-  listNativeSessions = async (query, cursor) => await this.#use(query, async (runtime) => await runtime.listNativeSessions(cursor, query.signal));
-  previewSessionEvents = async (options, request) => {
-    const { nativeSessionId, eventLimit, cursor } = request;
+  #use = async (cwd, signal, operation) => {
+    const agent = this.#agent;
+    let readers = this.#processesByAgent.get(agent);
+    if (readers === void 0) {
+      readers = new RetainedAgentProcesses({
+        touch: this.#processes.touch,
+        changed: this.#processes.notifyChanged
+      });
+      this.#processesByAgent.set(agent, readers);
+    }
+    const current = readers;
+    return await current.use(cwd, async () => await operation(await this.#ensure(agent, current, cwd, signal)));
+  };
+  capabilities = async (cwd, signal) => await this.#use(cwd, signal, async (runtime) => runtime.capabilities());
+  listNativeSessions = async (cwd, cursor, signal) => await this.#use(cwd, signal, async (runtime) => await runtime.listNativeSessions(cursor, signal));
+  previewSessionEvents = async (cwd, additionalDirectories, request, signal) => {
+    signal.throwIfAborted();
+    const agent = this.#agent;
+    const { nativeSessionId, eventLimit, cursor, sessionId } = request;
     if (cursor !== null) {
-      const preview = this.#eventPreviewsBySession.get(options.sessionId);
+      const preview = this.#eventPreviewsBySession.get(sessionId);
       if (preview === void 0 || preview.nativeSessionId !== nativeSessionId) {
         throw new Error("The native event cursor is invalid");
       }
-      return preview.store.page(options.sessionId, eventLimit, cursor);
+      return preview.store.page(sessionId, eventLimit, cursor);
     }
     const store = new MemorySessionEventStore();
-    const previous = this.#eventPreviewsBySession.get(options.sessionId);
+    const previous = this.#eventPreviewsBySession.get(sessionId);
     previous?.store.close();
-    this.#eventPreviewsBySession.set(options.sessionId, { nativeSessionId, store });
+    this.#eventPreviewsBySession.set(sessionId, { nativeSessionId, store });
     try {
       return await this.#processes.runTransient(
-        options.signal,
-        async () => await AcpQuerySession.start(options, store, this.#connector),
-        async (runtime) => await runtime.previewEvents(nativeSessionId, eventLimit, options.signal),
+        signal,
+        async () => await AcpQuerySession.start(agent, cwd, sessionId, store, this.#connector, signal),
+        async (runtime) => await runtime.previewEvents(nativeSessionId, eventLimit, additionalDirectories, signal),
         async (runtime) => await runtime.closeProcess()
       );
     } catch (error62) {
-      if (this.#eventPreviewsBySession.get(options.sessionId)?.store === store) {
-        this.#eventPreviewsBySession.delete(options.sessionId);
+      if (this.#eventPreviewsBySession.get(sessionId)?.store === store) {
+        this.#eventPreviewsBySession.delete(sessionId);
       }
       store.close();
       throw error62;
@@ -77657,8 +77682,11 @@ var AgentQueryProcesses = class {
   };
   close = async () => {
     await Promise.all(
-      this.#processesByQuery.entries().map(async ([id, runtime]) => await this.retire(id, runtime))
+      [...this.#processesByAgent.values()].flatMap(
+        (readers) => readers.entries().map(async ([cwd, runtime]) => await this.retire(readers, cwd, runtime))
+      )
     );
+    this.#processesByAgent.clear();
     for (const preview of this.#eventPreviewsBySession.values()) {
       preview.store.close();
     }
@@ -77672,12 +77700,13 @@ var ClaudeAdapter = class {
   #queryProcesses;
   #connector;
   #liveSessions;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
     this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
     this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
   cancel = (...args) => this.#liveSessions.cancel(...args);
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
@@ -77685,9 +77714,9 @@ var ClaudeAdapter = class {
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
-  readSessionHistory = async (query, request) => await this.#queryProcesses.previewSessionEvents(query, request);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
+  readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
   close = async () => await runCleanup(
     () => this.#queryProcesses.close(),
     () => this.#liveSessions.close()
@@ -82992,13 +83021,15 @@ function fitCodexToolEvent(event) {
 
 // src/engine/acp/adapter/codex/adapter.ts
 var CodexAdapter = class {
+  #agent;
   #queryProcesses;
   #connector;
   #liveSessions;
   #dependencies;
   #contentExternalizer;
   #previewCache = null;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
+    this.#agent = agent;
     this.#dependencies = dependencies;
     this.#contentExternalizer = {
       update: async (sessionId, update, signal) => {
@@ -83010,18 +83041,25 @@ var CodexAdapter = class {
     };
     this.#connector = new AcpSessionConnector(this.#contentExternalizer, fitCodexToolEvent);
     this.#liveSessions = new AcpLiveSessions(this.#contentExternalizer, fitCodexToolEvent);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => {
+    this.#agent = agent;
+    this.#queryProcesses.refreshAgent(agent);
+  };
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
-  cancel = (...args) => this.#liveSessions.cancel(...args);
+  cancel = async (target, signal) => {
+    await this.#liveSessions.closeSession(target, signal);
+    return "closed";
+  };
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
   prompt = (...args) => this.#liveSessions.prompt(...args);
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
   close = async () => {
     await runCleanup(
       () => this.#queryProcesses.close(),
@@ -83029,9 +83067,9 @@ var CodexAdapter = class {
       () => this.#previewCache?.close()
     );
   };
-  readSessionHistory = async (query, request) => {
-    const { agent, cwd } = query;
-    const signal = AbortSignal.any([query.signal, AbortSignal.timeout(6e4)]);
+  readSessionHistory = async (cwd, _additionalDirectories, request, cancellation) => {
+    const agent = this.#agent;
+    const signal = AbortSignal.any([cancellation, AbortSignal.timeout(6e4)]);
     const { sessionId } = request;
     signal.throwIfAborted();
     nativeSessionIdSchema.parse(request.nativeSessionId);
@@ -83084,10 +83122,12 @@ var CodexAdapter = class {
           request.nativeSessionId,
           async (update) => {
             const externalized = await this.#contentExternalizer.update(sessionId, update, signal);
-            events.push({
-              type: "acp",
-              payload: decodeAcpSessionUpdate(JSON.stringify(fitCodexToolEvent(externalized.event)))
-            });
+            for (const event of externalized.events) {
+              events.push({
+                type: "acp",
+                payload: decodeAcpSessionUpdate(JSON.stringify(fitCodexToolEvent(event)))
+              });
+            }
           },
           signal
         );
@@ -83105,12 +83145,13 @@ var PiAdapter = class {
   #queryProcesses;
   #connector;
   #liveSessions;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
     this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
     this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
   cancel = (...args) => this.#liveSessions.cancel(...args);
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
@@ -83118,9 +83159,9 @@ var PiAdapter = class {
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
-  readSessionHistory = async (query, request) => await this.#queryProcesses.previewSessionEvents(query, request);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
+  readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
   close = async () => await runCleanup(
     () => this.#queryProcesses.close(),
     () => this.#liveSessions.close()
@@ -83131,11 +83172,11 @@ var PiAdapter = class {
 var harnessAdapters = (agent, dependencies) => {
   switch (agent.id) {
     case "codex":
-      return new CodexAdapter(dependencies);
+      return new CodexAdapter(agent, dependencies);
     case "claude":
-      return new ClaudeAdapter(dependencies);
+      return new ClaudeAdapter(agent, dependencies);
     case "pi":
-      return new PiAdapter(dependencies);
+      return new PiAdapter(agent, dependencies);
     default:
       throw new AcpExecutionError(
         `Agent "${agent.id}" has no registered harness adapter.`,
@@ -83208,8 +83249,18 @@ function isRecord7(value) {
 }
 var AcpContentExternalizer = class {
   #store;
-  constructor(store) {
+  #linkedResources;
+  constructor(store, linkedResources = () => []) {
     this.#store = store;
+    this.#linkedResources = linkedResources;
+  }
+  #resourceLinks(text2) {
+    return this.#linkedResources(text2).map((resource) => ({
+      type: "resource_link",
+      uri: resource.uri,
+      name: resource.name,
+      mimeType: resource.mediaType
+    }));
   }
   async #content(sessionId, content, signal) {
     switch (content.type) {
@@ -83361,7 +83412,7 @@ var AcpContentExternalizer = class {
     const hasContent = update.content !== void 0 && update.content !== null || agentContent.length > 0;
     return {
       agent: { ...update, ...meta3, ...output2, ...hasContent ? { content: agentContent } : {} },
-      event: { ...update, ...meta3, ...output2, ...hasContent ? { content: eventContent } : {} }
+      events: [{ ...update, ...meta3, ...output2, ...hasContent ? { content: eventContent } : {} }]
     };
   }
   update = async (sessionId, update, signal) => {
@@ -83373,7 +83424,12 @@ var AcpContentExternalizer = class {
         const content = await this.#content(sessionId, update.content, signal);
         return {
           agent: { ...update, content: content.agent },
-          event: { ...update, content: content.event }
+          events: [
+            { ...update, content: content.event },
+            // Keep native text intact. Only add cards for exact file URLs whose
+            // original upload metadata is still known; arbitrary context stays text.
+            ...update.sessionUpdate === "user_message_chunk" && update.content.type === "text" ? this.#resourceLinks(update.content.text).map((content2) => ({ ...update, content: content2 })) : []
+          ]
         };
       }
       case "tool_call":
@@ -83381,14 +83437,14 @@ var AcpContentExternalizer = class {
         return await this.#toolUpdate(sessionId, update, signal);
       case "compaction_update": {
         if (update.summary === void 0 || update.summary === null) {
-          return { agent: update, event: update };
+          return { agent: update, events: [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) }
+          events: [{ ...update, summary: content.map((item) => item.event) }]
         };
       }
       case "plan":
@@ -83399,16 +83455,16 @@ var AcpContentExternalizer = class {
       case "config_option_update":
       case "session_info_update":
       case "usage_update":
-        return { agent: update, event: update };
+        return { agent: update, events: [update] };
     }
   };
 };
 
 // src/engine/agent/runtime-agents.ts
-function createRuntimeAdapterRegistry(adapters, processes, externalize) {
+function createRuntimeAdapterRegistry(adapters, processes, externalize, linkedResources) {
   return new AdapterRegistry(adapters, {
     processes,
-    contentExternalizer: new AcpContentExternalizer(externalize)
+    contentExternalizer: new AcpContentExternalizer(externalize, linkedResources)
   });
 }
 var RuntimeAgentDependencies = class {
@@ -86128,8 +86184,9 @@ var AgentSession = class _AgentSession {
     await this.#interactions.cancelPendingInteractions();
     signal.throwIfAborted();
     if (this.#turn.running) {
-      await this.#adapter.cancel(this.#target(), signal);
+      return await this.#adapter.cancel(this.#target(), signal);
     }
+    return "retained";
   };
   respondPermission = async (options) => {
     await this.#interactions.respondPermission(options);
@@ -86770,7 +86827,18 @@ var SessionManager2 = class {
     await this.#executions.cancel(sessionId, async () => {
       const runtime = this.#executionProcesses.get(sessionId);
       if (runtime !== void 0) {
-        await runtime.cancel(signal2);
+        const outcome = await runtime.cancel(signal2);
+        switch (outcome) {
+          case "retained":
+            break;
+          case "closed":
+            await this.#stopSessionProcess(sessionId, runtime);
+            break;
+          default: {
+            const unreachable3 = outcome;
+            throw new AcpExecutionError("Unexpected cancellation outcome", { cause: unreachable3 });
+          }
+        }
       }
     });
   });
@@ -87136,7 +87204,7 @@ var SessionManager2 = class {
 };
 
 // src/engine/session/native/native-session-browser.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 
 // src/engine/session/workspace/local-authorization-error.ts
 var LocalAuthorizationError = class extends OperationError {
@@ -87195,12 +87263,17 @@ var NativeSessionService = class {
     (scoped) => this.#sessions.withNativeSessionOperation(
       scoped,
       nativeSessionId,
-      (target) => target.adapter.readSessionHistory(target, {
-        nativeSessionId,
-        eventLimit,
-        cursor,
-        sessionId: target.sessionId
-      })
+      (target) => target.adapter.readSessionHistory(
+        target.cwd,
+        target.additionalDirectories,
+        {
+          nativeSessionId,
+          eventLimit,
+          cursor,
+          sessionId: target.sessionId
+        },
+        target.signal
+      )
     )
   );
   #execute = async (command, signal) => {
@@ -87231,7 +87304,7 @@ var NativeSessionService = class {
         queuedCancellation: "before-start"
       };
     }
-    const capabilities = await options.adapter.getCapabilities(options);
+    const capabilities = await options.adapter.getCapabilities(cwd, signal);
     if (!capabilities.listSessions) {
       throw new AcpExecutionError(
         "This Agent does not support native session listing",
@@ -87246,7 +87319,7 @@ var NativeSessionService = class {
       if (authorized === null) {
         return null;
       }
-      const entryId = decodeIdentifier(randomUUID14());
+      const entryId = decodeIdentifier(randomUUID15());
       if (this.#entries.size >= 5e3) {
         this.#entries.clear();
       }
@@ -87285,7 +87358,7 @@ var NativeSessionService = class {
         }
         cursor = known.cursor;
       }
-      const page = await options.adapter.listSessions(options, cursor);
+      const page = await options.adapter.listSessions(cwd, cursor, signal);
       const entries = [];
       for (const info of page.sessions) {
         const entry = await register(info);
@@ -87302,7 +87375,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID14());
+        nextCursor = decodeIdentifier(randomUUID15());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -87320,10 +87393,15 @@ var NativeSessionService = class {
       };
     }
     if (command.action === "find") {
-      const found = await options.adapter.findSession(options, command.nativeSessionId, {
-        maximumPages: 500,
-        maximumEntries: 500
-      });
+      const found = await options.adapter.findSession(
+        cwd,
+        command.nativeSessionId,
+        {
+          maximumPages: 500,
+          maximumEntries: 500
+        },
+        signal
+      );
       const entry = await register(found);
       if (entry !== null) {
         return { ...envelope2, action: "find", entry };
@@ -87461,10 +87539,15 @@ var NativeSessionService = class {
     }
   };
   resolveTarget = async (command, options, selected) => {
-    const info = await options.adapter.findSession(options, selected.nativeSessionId, {
-      maximumPages: 100,
-      maximumEntries: null
-    }).catch((cause) => {
+    const info = await options.adapter.findSession(
+      options.cwd,
+      selected.nativeSessionId,
+      {
+        maximumPages: 100,
+        maximumEntries: null
+      },
+      options.signal
+    ).catch((cause) => {
       options.signal.throwIfAborted();
       if (cause instanceof AcpExecutionError && cause.code === "native_session_not_found") {
         throw new AcpExecutionError(
@@ -87674,7 +87757,12 @@ var PromptLifecycle = class {
     }
     const recorded = await this.#recordLifecycle(sessionId, {
       type: "lifecycle-metadata",
-      payload: { kind: "prompt.completed", commandId, stopReason }
+      payload: {
+        kind: "prompt.completed",
+        commandId,
+        stopReason,
+        ...request.phase === "queued" ? { execution: "not-started" } : {}
+      }
     });
     if (!recorded) {
       this.#sink.publishOperationFailure(
@@ -87728,7 +87816,7 @@ async function settleAbandonedTurn(projection, operations, cancellation) {
 }
 
 // src/engine/session/turn/execution-receipts.ts
-import { createHash as createHash7, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID16 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 var ExecutionReceipts = class {
   #executions = /* @__PURE__ */ new Map();
@@ -87841,7 +87929,7 @@ var ExecutionReceipts = class {
   /** Started identities remain authoritative after their detailed receipt is evicted. */
   hasStarted = (commandId, sessionId) => {
     const receipt = this.#executions.get(commandId);
-    return receipt === void 0 ? this.#table.identity(commandId)?.sessionId === sessionId : receipt.sessionId === sessionId && receipt.started;
+    return receipt?.sessionId === sessionId && receipt.started || this.#table.identity(commandId)?.sessionId === sessionId;
   };
   /** Reserves an unseen command for cancellation before a delayed prompt can claim its identity. */
   recordCancellationBeforeAdmission = (commandId, sessionId) => {
@@ -87849,9 +87937,16 @@ var ExecutionReceipts = class {
     if (existing !== void 0) {
       return existing.sessionId === sessionId ? this.outcome(commandId) : void 0;
     }
+    const identity2 = this.#table.identity(commandId);
+    if (identity2 !== void 0) {
+      return identity2.sessionId === sessionId ? {
+        type: "lifecycle-metadata",
+        payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
+      } : void 0;
+    }
     const outcome = {
       type: "lifecycle-metadata",
-      payload: { kind: "prompt.completed", commandId, stopReason: "cancelled" }
+      payload: { kind: "prompt.completed", commandId, stopReason: "cancelled", execution: "not-started" }
     };
     const commandHash = createHash7("sha256").update(
       encodeSessionCancelBeforeStartCommand({
@@ -87862,7 +87957,7 @@ var ExecutionReceipts = class {
     ).digest("hex");
     this.#save(commandId, {
       admissionOrder: this.#nextAdmissionOrder(),
-      attemptId: randomUUID15(),
+      attemptId: randomUUID16(),
       commandHash,
       sessionId,
       started: false,
@@ -87944,7 +88039,7 @@ var ExecutionReceipts = class {
     if (identity2 !== void 0) {
       return identity2.sessionId === sessionId && identity2.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
     }
-    const attemptId = randomUUID15();
+    const attemptId = randomUUID16();
     this.#save(commandId, {
       admissionOrder: this.#nextAdmissionOrder(),
       attemptId,
@@ -88071,7 +88166,7 @@ var RuntimeTurnActivity = class {
 };
 
 // src/engine/session/turn/active-turn.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 var ActiveRuntimeTurn = class {
   attemptId;
   command;
@@ -88081,7 +88176,7 @@ var ActiveRuntimeTurn = class {
   #dispatch;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID16());
+  #epoch = decodeIdentifier(randomUUID17());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -88644,13 +88739,14 @@ function buildSessionLayer(options) {
 // src/engine/session/content/external-content-store.ts
 import { createHash as createHash8 } from "node:crypto";
 import { extname as extname2, join as join29 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/engine/storage/files/scratch-directory.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import { lstat as lstat4, mkdir as mkdir5, readdir as readdir6, readFile as readFile6, realpath as realpath7, rename as rename4, rm as rm3, stat as stat6, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join28 } from "node:path";
 async function atomicWrite(path7, bytes, signal) {
-  const temporary = `${path7}.${randomUUID17()}.tmp`;
+  const temporary = `${path7}.${randomUUID18()}.tmp`;
   try {
     await writeFile2(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -88662,7 +88758,7 @@ async function atomicWrite(path7, bytes, signal) {
 var ScratchDirectory = class {
   #root;
   constructor(parent) {
-    this.#root = join28(parent, randomUUID17());
+    this.#root = join28(parent, randomUUID18());
   }
   /** Refreshes this directory's lease and removes sibling directories whose lease is older than `leaseMilliseconds`. */
   refreshLease = async (leaseMilliseconds) => {
@@ -88789,8 +88885,12 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const path7 = await this.#scratch.write(kind, contentFileName(key, metadata.name), bytes, active);
+    const writtenPath = await this.#scratch.write(kind, contentFileName(key, metadata.name), bytes, active);
+    const path7 = await this.#scratch.resolveFile(writtenPath);
     active.throwIfAborted();
+    if (path7 === null) {
+      throw new OperationError("content_unavailable", "The cached content file is unavailable");
+    }
     const retained = this.#entries.get(request);
     this.#entries.set(request, {
       byteLength: bytes.byteLength,
@@ -88831,6 +88931,30 @@ var LocalExternalContentStore = class {
     const bytes = await this.#scratch.read(resolved.path, active);
     return bytes === null ? null : { ...resolved, bytes };
   });
+  /** Metadata for exact, still-cached file URLs. This does not grant content access. */
+  linkedResources = (text2) => {
+    if (!text2.includes("file:///")) {
+      return [];
+    }
+    const resources = [];
+    for (const [request, entry] of this.#entries) {
+      if (!request.startsWith("mobius-content:resource:") || entry.expiresAt <= Date.now()) {
+        continue;
+      }
+      const uri = pathToFileURL3(entry.path).href;
+      for (let index2 = text2.indexOf(uri); index2 >= 0; index2 = text2.indexOf(uri, index2 + uri.length)) {
+        const following = text2[index2 + uri.length];
+        if (following === void 0 || /[\s<>"')\]]/u.test(following)) {
+          resources.push({
+            index: index2,
+            resource: { uri, mediaType: entry.mediaType, name: entry.name, path: entry.path }
+          });
+          break;
+        }
+      }
+    }
+    return resources.sort((left, right) => left.index - right.index).map(({ resource }) => resource);
+  };
   [Symbol.asyncDispose] = async () => {
     clearInterval(this.#expirationTimer);
     this.#lifetime.abort();
@@ -90640,7 +90764,7 @@ function createNativeSessionCommands(context) {
 }
 
 // src/engine/session/prompt/apply-session-configuration.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function invalidSessionConfiguration(message) {
   return new AcpExecutionError(message, {}, "invalid_session_configuration");
 }
@@ -90778,7 +90902,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
     booleanValue: selection.booleanValue,
     configId: selection.configId,
     cwd,
-    requestId: `cfg_${randomUUID18()}`,
+    requestId: `cfg_${randomUUID19()}`,
     sessionId,
     signal,
     value: selection.value,
@@ -91068,7 +91192,7 @@ var sessionPromptCommand = {
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.356",
+  version: "0.0.358",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -91143,8 +91267,8 @@ var package_default = {
     ws: "^8.21.3"
   },
   keywords: [],
-  author: "",
-  license: "ISC",
+  author: "Moxt",
+  license: "Apache-2.0",
   bugs: {
     url: "https://github.com/moxt-ai/mobius/issues"
   },
@@ -92333,13 +92457,14 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
     const adapters = createRuntimeAdapterRegistry(
       config2.adapters,
       processes,
-      (sessionId, content, contentSignal) => externalContent.put({ ...content, sessionId, signal: contentSignal })
+      (sessionId, content, contentSignal) => externalContent.put({ ...content, sessionId, signal: contentSignal }),
+      externalContent.linkedResources
     );
     const resolveAgent = async (agentId, resolveSignal, sessionId) => {
       const catalogAgent = await resolveCatalogAgent(config2, agentId, resolveSignal);
       const environment = sessionId === void 0 ? void 0 : config2.sessionEnvironment?.({ sessionId, agentId });
       const agent = environment === void 0 ? catalogAgent : catalogAgent.withEnvironment({ ...catalogAgent.environment, ...environment });
-      return { agent, adapter: adapters.resolve(agent) };
+      return { agent, adapter: adapters.resolve(catalogAgent) };
     };
     const layer = buildSessionLayer({
       processes,