@moxt-ai/mobius 0.0.356 → 0.0.358

package/dist/cli.js

@@ -2086,7 +2086,7 @@ var init_package = __esm({
   "package.json"() {
     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: {
@@ -2161,8 +2161,8 @@ var init_package = __esm({
         ws: "^8.21.3"
       },
       keywords: [],
-      author: "",
-      license: "ISC",
+      author: "Moxt",
+      license: "Apache-2.0",
       bugs: {
         url: "https://github.com/moxt-ai/mobius/issues"
       },
@@ -27237,6 +27237,7 @@ var init_events = __esm({
       external_exports.object({
         ...lifecycleBase,
         kind: external_exports.literal("prompt.completed"),
+        execution: external_exports.literal("not-started").optional(),
         stopReason: shortString
       }).readonly(),
       external_exports.object({
@@ -75794,6 +75795,7 @@ var init_borrowed_agent = __esm({
           content,
           clientId: randomUUID7(),
           completion: Promise.withResolvers(),
+          settled: Promise.withResolvers(),
           input: { kind: "awaiting" }
         };
         this.#pending = pending;
@@ -75831,7 +75833,6 @@ var init_borrowed_agent = __esm({
           throw cause;
         } finally {
           signal.removeEventListener("abort", abort);
-          this.#pending = null;
           if (outcome === "cancelled") {
             try {
               await this.#removeQueuedInput(pending.clientId);
@@ -75839,6 +75840,8 @@ var init_borrowed_agent = __esm({
               console.error("The cancelled Codex queued input could not be removed", cause);
             }
           }
+          this.#pending = null;
+          pending.settled.resolve();
         }
       };
       #removeQueuedInput = async (clientId) => {
@@ -75898,7 +75901,11 @@ var init_borrowed_agent = __esm({
         );
       };
       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" };
@@ -76925,40 +76932,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));
@@ -77660,16 +77669,19 @@ var init_agent = __esm({
        */
       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");
+              }
             }
           })();
         }
@@ -80153,14 +80165,17 @@ var init_session = __esm({
 });
 
 // src/engine/acp/harness/pi/upstream/dist/acp/translate/pi-messages.js
-function normalizePiMessageText(content) {
+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)) {
@@ -80168,9 +80183,15 @@ function normalizePiAssistantText(content) {
   }
   return content.map((c) => c?.type === "text" && typeof c.text === "string" ? c.text : "").filter(Boolean).join("");
 }
+var userContentSchema;
 var init_pi_messages = __esm({
   "src/engine/acp/harness/pi/upstream/dist/acp/translate/pi-messages.js"() {
     "use strict";
+    init_zod();
+    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() })
+    ]);
   }
 });
 
@@ -81612,13 +81633,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
                 }
               });
             }
@@ -82830,6 +82851,7 @@ var init_adapter_registry = __esm({
       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);
@@ -83304,63 +83326,64 @@ var init_session_events = __esm({
           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 = {
@@ -83401,6 +83424,9 @@ var init_session_events = __esm({
       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);
@@ -83530,6 +83556,7 @@ var init_live_sessions = __esm({
           "ACP agent exited while cancelling a prompt",
           bounded
         );
+        return "retained";
       };
       closeSession = async (target, signal) => {
         const session = this.#find(target);
@@ -83736,7 +83763,7 @@ var init_live_sessions = __esm({
 });
 
 // src/engine/acp/adapter/native-session-lookup.ts
-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(
@@ -83750,9 +83777,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) {
@@ -84533,51 +84560,56 @@ var AcpQuerySession;
 var init_query_session = __esm({
   "src/engine/acp/adapter/query-session.ts"() {
     "use strict";
-    init_value_utils();
     init_acp_error();
     init_native_session();
     init_session_capabilities();
     init_agent_initialization();
     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) {
@@ -84589,7 +84621,18 @@ var init_query_session = __esm({
         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(
@@ -84615,7 +84658,7 @@ var init_query_session = __esm({
         }
         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.",
@@ -84623,14 +84666,14 @@ var init_query_session = __esm({
             "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
             },
@@ -84641,14 +84684,16 @@ var init_query_session = __esm({
         );
         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
+import { randomUUID as randomUUID14 } from "node:crypto";
 var AgentQueryProcesses;
 var init_query_processes = __esm({
   "src/engine/acp/adapter/query-processes.ts"() {
@@ -84656,121 +84701,99 @@ var init_query_processes = __esm({
     init_session_event_store();
     init_operation_drain();
     init_retained_agent_processes();
-    init_acp_error();
     init_query_session();
     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;
@@ -84778,8 +84801,11 @@ var init_query_processes = __esm({
       };
       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();
         }
@@ -84804,12 +84830,13 @@ var init_adapter = __esm({
       #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);
@@ -84817,9 +84844,9 @@ var init_adapter = __esm({
       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()
@@ -90756,13 +90783,15 @@ var init_adapter2 = __esm({
     init_session_events();
     init_tool_event();
     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) => {
@@ -90774,18 +90803,25 @@ var init_adapter2 = __esm({
         };
         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(),
@@ -90793,9 +90829,9 @@ var init_adapter2 = __esm({
           () => 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);
@@ -90848,10 +90884,12 @@ var init_adapter2 = __esm({
               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
             );
@@ -90880,12 +90918,13 @@ var init_adapter3 = __esm({
       #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);
@@ -90893,9 +90932,9 @@ var init_adapter3 = __esm({
       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()
@@ -90916,11 +90955,11 @@ var init_registry = __esm({
     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.`,
@@ -91001,8 +91040,18 @@ var init_content_externalizer = __esm({
     ]);
     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) {
@@ -91154,7 +91203,7 @@ var init_content_externalizer = __esm({
         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) => {
@@ -91166,7 +91215,12 @@ var init_content_externalizer = __esm({
             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":
@@ -91174,14 +91228,14 @@ var init_content_externalizer = __esm({
             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":
@@ -91192,7 +91246,7 @@ var init_content_externalizer = __esm({
           case "config_option_update":
           case "session_info_update":
           case "usage_update":
-            return { agent: update, event: update };
+            return { agent: update, events: [update] };
         }
       };
     };
@@ -91200,10 +91254,10 @@ var init_content_externalizer = __esm({
 });
 
 // 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;
@@ -94279,8 +94333,9 @@ var init_agent_session = __esm({
         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);
@@ -94950,7 +95005,18 @@ var init_session_manager = __esm({
         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 });
+              }
+            }
           }
         });
       });
@@ -95333,7 +95399,7 @@ var init_local_authorization_error = __esm({
 });
 
 // src/engine/session/native/native-session-browser.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 function nextForkTitle(sourceTitle, sessions) {
   let highest = 0;
   for (const session of sessions) {
@@ -95391,12 +95457,17 @@ var init_native_session_browser = __esm({
         (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) => {
@@ -95427,7 +95498,7 @@ var init_native_session_browser = __esm({
             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",
@@ -95442,7 +95513,7 @@ var init_native_session_browser = __esm({
           if (authorized === null) {
             return null;
           }
-          const entryId = decodeIdentifier(randomUUID14());
+          const entryId = decodeIdentifier(randomUUID15());
           if (this.#entries.size >= 5e3) {
             this.#entries.clear();
           }
@@ -95481,7 +95552,7 @@ var init_native_session_browser = __esm({
             }
             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);
@@ -95498,7 +95569,7 @@ var init_native_session_browser = __esm({
                 "invalid_native_session_response"
               );
             }
-            nextCursor = decodeIdentifier(randomUUID14());
+            nextCursor = decodeIdentifier(randomUUID15());
             if (this.#cursors.size >= 500) {
               this.#cursors.clear();
             }
@@ -95516,10 +95587,15 @@ var init_native_session_browser = __esm({
           };
         }
         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 };
@@ -95657,10 +95733,15 @@ var init_native_session_browser = __esm({
         }
       };
       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(
@@ -95905,7 +95986,12 @@ var init_prompt_lifecycle = __esm({
         }
         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(
@@ -95942,7 +96028,7 @@ var init_prompt_lifecycle = __esm({
 });
 
 // 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, ExecutionReceipts;
 var init_execution_receipts = __esm({
   "src/engine/session/turn/execution-receipts.ts"() {
@@ -96061,7 +96147,7 @@ var init_execution_receipts = __esm({
       /** 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) => {
@@ -96069,9 +96155,16 @@ var init_execution_receipts = __esm({
         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({
@@ -96082,7 +96175,7 @@ var init_execution_receipts = __esm({
         ).digest("hex");
         this.#save(commandId, {
           admissionOrder: this.#nextAdmissionOrder(),
-          attemptId: randomUUID15(),
+          attemptId: randomUUID16(),
           commandHash,
           sessionId,
           started: false,
@@ -96164,7 +96257,7 @@ var init_execution_receipts = __esm({
         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,
@@ -96299,7 +96392,7 @@ var init_runtime_turn_activity = __esm({
 });
 
 // src/engine/session/turn/active-turn.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 var ActiveRuntimeTurn;
 var init_active_turn = __esm({
   "src/engine/session/turn/active-turn.ts"() {
@@ -96314,7 +96407,7 @@ var init_active_turn = __esm({
       #dispatch;
       #sequence = 0;
       #interaction = null;
-      #epoch = decodeIdentifier(randomUUID16());
+      #epoch = decodeIdentifier(randomUUID17());
       constructor(command, attemptId) {
         this.attemptId = attemptId;
         this.command = command;
@@ -96923,11 +97016,11 @@ var init_session_layer = __esm({
 });
 
 // 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 readFile7, realpath as realpath8, rename as rename4, rm as rm3, stat as stat8, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname12, join as join30 } from "node:path";
 async function atomicWrite(path8, bytes, signal) {
-  const temporary = `${path8}.${randomUUID17()}.tmp`;
+  const temporary = `${path8}.${randomUUID18()}.tmp`;
   try {
     await writeFile2(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -96943,7 +97036,7 @@ var init_scratch_directory = __esm({
     ScratchDirectory = class {
       #root;
       constructor(parent) {
-        this.#root = join30(parent, randomUUID17());
+        this.#root = join30(parent, randomUUID18());
       }
       /** Refreshes this directory's lease and removes sibling directories whose lease is older than `leaseMilliseconds`. */
       refreshLease = async (leaseMilliseconds) => {
@@ -97008,6 +97101,7 @@ var init_scratch_directory = __esm({
 // src/engine/session/content/external-content-store.ts
 import { createHash as createHash8 } from "node:crypto";
 import { extname as extname2, join as join31 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 function contentFileName(key, name2) {
   const extension = extname2(name2).toLowerCase();
   return /^\.[a-z0-9]{1,16}$/u.test(extension) ? `${key}${extension}` : key;
@@ -97017,6 +97111,7 @@ var init_external_content_store = __esm({
   "src/engine/session/content/external-content-store.ts"() {
     "use strict";
     init_zod();
+    init_operation_error();
     init_scratch_directory();
     contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
     CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
@@ -97080,8 +97175,12 @@ var init_external_content_store = __esm({
         }
         await this.#expire();
         active.throwIfAborted();
-        const path8 = 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 path8 = await this.#scratch.resolveFile(writtenPath);
         active.throwIfAborted();
+        if (path8 === 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,
@@ -97122,6 +97221,30 @@ var init_external_content_store = __esm({
         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();
@@ -99105,7 +99228,7 @@ var init_native_sessions = __esm({
 });
 
 // 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");
 }
@@ -99243,7 +99366,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,
@@ -100820,13 +100943,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,
@@ -101211,7 +101335,7 @@ var init_engine = __esm({
 });
 
 // src/storage/daemon/version-data.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { cp as cp2, lstat as lstat5, mkdtemp, readFile as readFile8, rename as rename5, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join33, relative as relative3, sep as sep5 } from "node:path";
 async function prepareVersionDataDirectory(root, version2, signal) {
@@ -101302,7 +101426,7 @@ async function discardVersionData(root, version2, signal) {
     return;
   }
   const versions = join33(root, STATE_ROOT_LAYOUT.versions);
-  const discarded = join33(versions, `.${version2}-discarded-${randomUUID19()}`);
+  const discarded = join33(versions, `.${version2}-discarded-${randomUUID20()}`);
   try {
     await rename5(join33(versions, version2), discarded);
   } catch (cause) {
@@ -101316,7 +101440,7 @@ async function discardVersionData(root, version2, signal) {
 async function writeCurrentDataVersion(root, version2, signal) {
   await validateLocalPath(root, true, true, signal);
   await validateLocalPath(join33(root, STATE_ROOT_LAYOUT.versions, version2), true, true, signal);
-  const temporary = join33(root, `.current-data-${randomUUID19()}.txt`);
+  const temporary = join33(root, `.current-data-${randomUUID20()}.txt`);
   try {
     await writeFile3(temporary, `versions/${version2}
 `, { mode: 384, flag: "wx", signal });
@@ -102920,7 +103044,7 @@ var init_quit = __esm({
 });
 
 // src/daemon/upgrades/upgrade.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 import { setInterval as setInterval2, setTimeout as setTimeout4 } from "node:timers/promises";
 async function reportDaemonUpgradeAvailability(send2, signal) {
   if (!process.connected) {
@@ -102979,7 +103103,7 @@ async function requestDaemonReleaseUpgrade(stateDirectory, currentVersion, signa
   return await requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal);
 }
 async function requestInstalledDaemonReleaseSwitch(stateDirectory, launch, signal) {
-  const id = randomUUID20();
+  const id = randomUUID21();
   const response = decodeKnownLifecycleResponse(
     await sendLocalRequest(stateDirectory, "manager", { kind: "switch", id, context: "npm", launch }, signal)
   );