@moxt-ai/mobius 0.0.357 → 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.357",
+      version: "0.0.358",
       description: "Mobius CLI for pairing and running local AI agent services.",
       type: "module",
       bin: {
@@ -75795,6 +75795,7 @@ var init_borrowed_agent = __esm({
           content,
           clientId: randomUUID7(),
           completion: Promise.withResolvers(),
+          settled: Promise.withResolvers(),
           input: { kind: "awaiting" }
         };
         this.#pending = pending;
@@ -75832,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);
@@ -75840,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) => {
@@ -75899,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" };
@@ -77663,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");
+              }
             }
           })();
         }
@@ -82842,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);
@@ -83414,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);
@@ -83543,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);
@@ -83749,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(
@@ -83763,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) {
@@ -84546,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) {
@@ -84602,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(
@@ -84628,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.",
@@ -84636,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
             },
@@ -84654,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"() {
@@ -84669,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;
@@ -84791,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();
         }
@@ -84817,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);
@@ -84830,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()
@@ -90769,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) => {
@@ -90787,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(),
@@ -90806,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);
@@ -90895,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);
@@ -90908,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()
@@ -90931,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.`,
@@ -94309,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);
@@ -94980,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 });
+              }
+            }
           }
         });
       });
@@ -95363,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) {
@@ -95421,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) => {
@@ -95457,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",
@@ -95472,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();
           }
@@ -95511,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);
@@ -95528,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();
             }
@@ -95546,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 };
@@ -95687,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(
@@ -95977,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"() {
@@ -96124,7 +96175,7 @@ var init_execution_receipts = __esm({
         ).digest("hex");
         this.#save(commandId, {
           admissionOrder: this.#nextAdmissionOrder(),
-          attemptId: randomUUID15(),
+          attemptId: randomUUID16(),
           commandHash,
           sessionId,
           started: false,
@@ -96206,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,
@@ -96341,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"() {
@@ -96356,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;
@@ -96965,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();
@@ -96985,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) => {
@@ -99177,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");
 }
@@ -99315,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,
@@ -100899,7 +100950,7 @@ async function runRuntime(config2, parentSignal, timer = systemTimer, options =
       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,
@@ -101284,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) {
@@ -101375,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) {
@@ -101389,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 });
@@ -102993,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) {
@@ -103052,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)
   );