@moxt-ai/mobius 0.0.357 → 0.0.358

package/dist/engine.js

@@ -69128,6 +69128,7 @@ var CodexBorrowedAcpAgent = class {
       content,
       clientId: randomUUID7(),
       completion: Promise.withResolvers(),
+      settled: Promise.withResolvers(),
       input: { kind: "awaiting" }
     };
     this.#pending = pending;
@@ -69165,7 +69166,6 @@ var CodexBorrowedAcpAgent = class {
       throw cause;
     } finally {
       signal.removeEventListener("abort", abort);
-      this.#pending = null;
       if (outcome === "cancelled") {
         try {
           await this.#removeQueuedInput(pending.clientId);
@@ -69173,6 +69173,8 @@ var CodexBorrowedAcpAgent = class {
           console.error("The cancelled Codex queued input could not be removed", cause);
         }
       }
+      this.#pending = null;
+      pending.settled.resolve();
     }
   };
   #removeQueuedInput = async (clientId) => {
@@ -69232,7 +69234,11 @@ var CodexBorrowedAcpAgent = class {
     );
   };
   cancel = async () => {
-    this.#pending?.completion.resolve({ stopReason: "cancelled" });
+    const pending = this.#pending;
+    if (pending !== null) {
+      pending.completion.resolve({ stopReason: "cancelled" });
+      await pending.settled.promise;
+    }
   };
   close = async () => {
     this.#lifecycle = { kind: "closed" };
@@ -70933,16 +70939,19 @@ var CodexAcpAgent = class {
    */
   close = () => {
     if (this.#closePromise === null) {
-      this.#appServer.detach();
       this.#closePromise = (async () => {
-        await this.#sessionAgent.close();
-        const child = this.#appServer.child();
         try {
-          const captured = await captureProcessTree(child);
-          await stopProcessTree(child, captured);
+          await this.#sessionAgent.close();
         } finally {
-          this.#connection?.close();
-          this.#onBackgroundActivity?.("none");
+          this.#appServer.detach();
+          const child = this.#appServer.child();
+          try {
+            const captured = await captureProcessTree(child);
+            await stopProcessTree(child, captured);
+          } finally {
+            this.#connection?.close();
+            this.#onBackgroundActivity?.("none");
+          }
         }
       })();
     }
@@ -75835,6 +75844,7 @@ var AdapterRegistry = class {
   resolve = (agent) => {
     const existing = this.#adapters.get(agent.id);
     if (existing !== void 0) {
+      existing.refreshAgent(agent);
       return existing;
     }
     const adapter = this.#resolve(agent, this.#dependencies);
@@ -76370,6 +76380,9 @@ var AdapterSessionConnection = class {
   get connection() {
     return this.#connection.connection;
   }
+  get termination() {
+    return this.#connection.termination;
+  }
   initialize = (signal) => this.#connection.initialize(signal);
   agentSettingsModelEffort = () => this.#connection.agentSettingsModelEffort();
   race = (operation, exitMessage, signal) => this.#connection.race(operation, exitMessage, signal);
@@ -76483,6 +76496,7 @@ var AcpLiveSessions = class {
       "ACP agent exited while cancelling a prompt",
       bounded
     );
+    return "retained";
   };
   closeSession = async (target, signal) => {
     const session = this.#find(target);
@@ -76694,7 +76708,7 @@ var lookupSchema = external_exports.object({
     maximumEntries: external_exports.number().int().positive().nullable()
   })
 });
-async function findNativeSession(list, query, nativeSessionId, budget) {
+async function findNativeSession(list, cwd, nativeSessionId, budget, signal) {
   const decoded = lookupSchema.safeParse({ nativeSessionId, budget });
   if (!decoded.success) {
     throw new AcpExecutionError(
@@ -76708,9 +76722,9 @@ async function findNativeSession(list, query, nativeSessionId, budget) {
   let inspected = 0;
   const visited = /* @__PURE__ */ new Set();
   for (let pageNumber = 0; pageNumber < limits.maximumPages; pageNumber += 1) {
-    query.signal.throwIfAborted();
-    const page = await list(query, cursor);
-    query.signal.throwIfAborted();
+    signal.throwIfAborted();
+    const page = await list(cwd, cursor, signal);
+    signal.throwIfAborted();
     inspected += page.sessions.length;
     const found = page.sessions.find((session) => session.sessionId === decoded.data.nativeSessionId);
     if (found !== void 0) {
@@ -76732,6 +76746,9 @@ async function findNativeSession(list, query, nativeSessionId, budget) {
   throw new AcpExecutionError("The native session was not found", {}, "native_session_not_found");
 }
 
+// src/engine/acp/adapter/query-processes.ts
+import { randomUUID as randomUUID14 } from "node:crypto";
+
 // src/engine/session/history/session-event-store.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
 
@@ -77440,45 +77457,51 @@ async function initializeAgentConnection(connection, agentId, verifiedVersion, s
 
 // src/engine/acp/adapter/query-session.ts
 var AcpQuerySession = class _AcpQuerySession {
-  #options;
+  #cwd;
+  #sessionId;
   #events;
   #connection;
+  #lifecycle = { kind: "open" };
   #capabilities = unsupportedSessionCapabilities();
   #configOptions = [];
-  constructor(options, events, connector) {
-    this.#options = options;
+  constructor(agent, cwd, sessionId, events, connector) {
+    this.#cwd = cwd;
+    this.#sessionId = sessionId;
     this.#events = events;
     this.#connection = connector.connectQuerySession({
-      agent: options.agent,
-      cwd: options.cwd,
-      sessionId: () => options.sessionId,
+      agent,
+      cwd,
+      sessionId: () => sessionId,
       configOptions: () => this.#configOptions,
       onEvent: async (event) => {
-        this.#events.append(options.sessionId, { type: "acp", payload: event.payload });
+        this.#events.append(sessionId, { type: "acp", payload: event.payload });
         if (event.kind === "configuration") {
           this.#configOptions = event.configOptions;
         }
       }
     });
+    void this.#connection.termination.then(() => {
+      this.#lifecycle = { kind: "terminated" };
+    });
   }
-  static start = async (options, events, connector) => {
+  static start = async (agent, cwd, sessionId, events, connector, signal) => {
     for (let attempt = 1; attempt <= 2; attempt += 1) {
-      await validateAgentRuntime(options.agent, options.signal);
-      const runtime = new _AcpQuerySession(options, events, connector);
+      await validateAgentRuntime(agent, signal);
+      const runtime = new _AcpQuerySession(agent, cwd, sessionId, events, connector);
       try {
         const initialized = await initializeAgentConnection(
           runtime.#connection,
-          options.agent.id,
-          options.agent.agentVersion,
-          options.signal
+          agent.id,
+          agent.agentVersion,
+          signal
         );
         runtime.#capabilities = initialized.capabilities;
         return runtime;
       } catch (error62) {
         await runtime.closeProcess();
-        options.signal.throwIfAborted();
+        signal.throwIfAborted();
         if (error62 instanceof RetryableAcpInitializationError && attempt === 1) {
-          console.warn(`[${options.agent.id}-acp] ACP agent initialization failed; retrying once`);
+          console.warn(`[${agent.id}-acp] ACP agent initialization failed; retrying once`);
           continue;
         }
         if (error62 instanceof AcpExecutionError) {
@@ -77490,7 +77513,18 @@ var AcpQuerySession = class _AcpQuerySession {
     throw new AcpExecutionError("ACP agent initialization failed");
   };
   capabilities = () => this.#capabilities;
-  belongsTo = (agentId, cwd, directories) => this.#options.agent.id === agentId && this.#options.cwd === cwd && arraysEqual(this.#options.additionalDirectories, directories);
+  hasTerminated = () => {
+    switch (this.#lifecycle.kind) {
+      case "open":
+        return false;
+      case "terminated":
+        return true;
+      default: {
+        const unreachable3 = this.#lifecycle;
+        return unreachable3;
+      }
+    }
+  };
   listNativeSessions = async (cursor, signal) => {
     if (!this.#capabilities.listSessions) {
       throw new AcpExecutionError(
@@ -77516,7 +77550,7 @@ var AcpQuerySession = class _AcpQuerySession {
     }
     return decoded.data;
   };
-  previewEvents = async (nativeSessionId, eventLimit, signal) => {
+  previewEvents = async (nativeSessionId, eventLimit, additionalDirectories, signal) => {
     if (!this.#capabilities.loadSession) {
       throw new AcpExecutionError(
         "This Agent restores context but does not provide message history.",
@@ -77524,14 +77558,14 @@ var AcpQuerySession = class _AcpQuerySession {
         "native_history_unsupported"
       );
     }
-    this.#events.reset(this.#options.sessionId);
+    this.#events.reset(this.#sessionId);
     this.#connection.events.select(nativeSessionId);
     await this.#connection.race(
       this.#connection.connection.agent.request(
         methods12.agent.session.load,
         {
-          additionalDirectories: [...this.#options.additionalDirectories],
-          cwd: this.#options.cwd,
+          additionalDirectories: [...additionalDirectories],
+          cwd: this.#cwd,
           mcpServers: [],
           sessionId: nativeSessionId
         },
@@ -77542,125 +77576,105 @@ var AcpQuerySession = class _AcpQuerySession {
     );
     await this.#connection.events.drained();
     signal.throwIfAborted();
-    return this.#events.page(this.#options.sessionId, eventLimit, null);
+    return this.#events.page(this.#sessionId, eventLimit, null);
   };
   closeProcess = async () => await this.#connection.closeProcess();
+  discardEvents = () => this.#events.remove(this.#sessionId);
 };
 
 // src/engine/acp/adapter/query-processes.ts
 var AgentQueryProcesses = class {
   #eventPreviewsBySession = /* @__PURE__ */ new Map();
-  #processesByQuery;
+  #processesByAgent = /* @__PURE__ */ new Map();
+  #agent;
   #processes;
   #store = new MemorySessionEventStore();
   #connector;
-  constructor(processes, connector) {
+  constructor(agent, processes, connector) {
+    this.#agent = agent;
     this.#processes = processes;
     this.#connector = connector;
-    this.#processesByQuery = new RetainedAgentProcesses({
-      touch: processes.touch,
-      changed: processes.notifyChanged
-    });
   }
-  retire = async (sessionId, runtime) => {
-    const retained = this.#processesByQuery.detach(sessionId, runtime);
-    if (retained) {
-      this.#store.remove(sessionId);
+  refreshAgent = (agent) => {
+    this.#agent = agent;
+  };
+  retire = async (readers, cwd, runtime) => {
+    readers.detach(cwd, runtime);
+    try {
+      await this.#processes.retire(runtime, () => runtime.closeProcess());
+    } finally {
+      runtime.discardEvents();
     }
-    await this.#processes.retire(runtime, () => runtime.closeProcess());
   };
-  async #startRetained(options) {
-    const runtime = await this.#processes.startRetained(
-      options.signal,
-      () => AcpQuerySession.start(options, this.#store, this.#connector),
-      {
-        isBusy: () => this.#processesByQuery.isBusy(options.sessionId),
-        retire: (runtime2) => this.retire(options.sessionId, runtime2),
-        retireIdle: (runtime2) => this.retire(options.sessionId, runtime2)
-      }
-    );
-    this.#processesByQuery.retain(options.sessionId, runtime);
-    return runtime;
-  }
-  async #startPreparation(options) {
-    return await this.#processesByQuery.prepare(options.sessionId, async () => {
-      return await this.#startRetained(options);
-    });
-  }
-  async #replacePreparation(existing, options) {
-    return await this.#processesByQuery.prepare(options.sessionId, async () => {
-      await this.retire(options.sessionId, existing);
-      return await this.#startRetained(options);
-    });
-  }
-  #prepare = async (options) => {
-    const pending = this.#processesByQuery.pending(options.sessionId);
+  async #ensure(agent, readers, cwd, signal) {
+    signal.throwIfAborted();
+    const pending = readers.pending(cwd);
     if (pending !== void 0) {
-      const runtime2 = await waitForSharedOperation(pending, options.signal);
-      if (runtime2.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#processesByQuery.touch(options.sessionId, runtime2);
-        return runtime2.capabilities();
-      }
-      return await this.#prepare(options);
-    }
-    const existing = this.#processesByQuery.get(options.sessionId);
-    if (existing !== void 0) {
-      if (existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        this.#processesByQuery.touch(options.sessionId, existing);
-        return existing.capabilities();
-      }
-      const runtime2 = await this.#replacePreparation(existing, options);
-      return runtime2.capabilities();
+      return await waitForSharedOperation(pending, signal);
     }
-    const runtime = await this.#startPreparation(options);
-    return runtime.capabilities();
-  };
-  async #ensure(options) {
-    const existing = this.#processesByQuery.get(options.sessionId);
-    if (existing !== void 0) {
-      if (!existing.belongsTo(options.agent.id, options.cwd, options.additionalDirectories)) {
-        throw new AcpExecutionError(
-          "The agent or workspace cannot change after a conversation has started",
-          {},
-          "session_identity_mismatch"
-        );
-      }
-      this.#processesByQuery.touch(options.sessionId, existing);
+    const existing = readers.get(cwd);
+    if (existing !== void 0 && !existing.hasTerminated()) {
+      readers.touch(cwd, existing);
       return existing;
     }
-    await this.#prepare(options);
-    const started = this.#processesByQuery.get(options.sessionId);
-    if (started === void 0) {
-      throw new AcpExecutionError("ACP native session browser did not start");
-    }
-    return started;
+    return await readers.prepare(cwd, async () => {
+      if (existing !== void 0) {
+        await this.retire(readers, cwd, existing);
+      }
+      const readerId = randomUUID14();
+      const runtime = await this.#processes.startRetained(
+        signal,
+        () => AcpQuerySession.start(agent, cwd, readerId, this.#store, this.#connector, signal),
+        {
+          isBusy: () => readers.isBusy(cwd),
+          retire: (runtime2) => this.retire(readers, cwd, runtime2),
+          retireIdle: (runtime2) => this.retire(readers, cwd, runtime2)
+        }
+      );
+      readers.retain(cwd, runtime);
+      return runtime;
+    });
   }
-  #use = async (options, operation) => await this.#processesByQuery.use(options.sessionId, async () => await operation(await this.#ensure(options)));
-  capabilities = async (query) => await this.#prepare(query);
-  listNativeSessions = async (query, cursor) => await this.#use(query, async (runtime) => await runtime.listNativeSessions(cursor, query.signal));
-  previewSessionEvents = async (options, request) => {
-    const { nativeSessionId, eventLimit, cursor } = request;
+  #use = async (cwd, signal, operation) => {
+    const agent = this.#agent;
+    let readers = this.#processesByAgent.get(agent);
+    if (readers === void 0) {
+      readers = new RetainedAgentProcesses({
+        touch: this.#processes.touch,
+        changed: this.#processes.notifyChanged
+      });
+      this.#processesByAgent.set(agent, readers);
+    }
+    const current = readers;
+    return await current.use(cwd, async () => await operation(await this.#ensure(agent, current, cwd, signal)));
+  };
+  capabilities = async (cwd, signal) => await this.#use(cwd, signal, async (runtime) => runtime.capabilities());
+  listNativeSessions = async (cwd, cursor, signal) => await this.#use(cwd, signal, async (runtime) => await runtime.listNativeSessions(cursor, signal));
+  previewSessionEvents = async (cwd, additionalDirectories, request, signal) => {
+    signal.throwIfAborted();
+    const agent = this.#agent;
+    const { nativeSessionId, eventLimit, cursor, sessionId } = request;
     if (cursor !== null) {
-      const preview = this.#eventPreviewsBySession.get(options.sessionId);
+      const preview = this.#eventPreviewsBySession.get(sessionId);
       if (preview === void 0 || preview.nativeSessionId !== nativeSessionId) {
         throw new Error("The native event cursor is invalid");
       }
-      return preview.store.page(options.sessionId, eventLimit, cursor);
+      return preview.store.page(sessionId, eventLimit, cursor);
     }
     const store = new MemorySessionEventStore();
-    const previous = this.#eventPreviewsBySession.get(options.sessionId);
+    const previous = this.#eventPreviewsBySession.get(sessionId);
     previous?.store.close();
-    this.#eventPreviewsBySession.set(options.sessionId, { nativeSessionId, store });
+    this.#eventPreviewsBySession.set(sessionId, { nativeSessionId, store });
     try {
       return await this.#processes.runTransient(
-        options.signal,
-        async () => await AcpQuerySession.start(options, store, this.#connector),
-        async (runtime) => await runtime.previewEvents(nativeSessionId, eventLimit, options.signal),
+        signal,
+        async () => await AcpQuerySession.start(agent, cwd, sessionId, store, this.#connector, signal),
+        async (runtime) => await runtime.previewEvents(nativeSessionId, eventLimit, additionalDirectories, signal),
         async (runtime) => await runtime.closeProcess()
       );
     } catch (error62) {
-      if (this.#eventPreviewsBySession.get(options.sessionId)?.store === store) {
-        this.#eventPreviewsBySession.delete(options.sessionId);
+      if (this.#eventPreviewsBySession.get(sessionId)?.store === store) {
+        this.#eventPreviewsBySession.delete(sessionId);
       }
       store.close();
       throw error62;
@@ -77668,8 +77682,11 @@ var AgentQueryProcesses = class {
   };
   close = async () => {
     await Promise.all(
-      this.#processesByQuery.entries().map(async ([id, runtime]) => await this.retire(id, runtime))
+      [...this.#processesByAgent.values()].flatMap(
+        (readers) => readers.entries().map(async ([cwd, runtime]) => await this.retire(readers, cwd, runtime))
+      )
     );
+    this.#processesByAgent.clear();
     for (const preview of this.#eventPreviewsBySession.values()) {
       preview.store.close();
     }
@@ -77683,12 +77700,13 @@ var ClaudeAdapter = class {
   #queryProcesses;
   #connector;
   #liveSessions;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
     this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
     this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
   cancel = (...args) => this.#liveSessions.cancel(...args);
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
@@ -77696,9 +77714,9 @@ var ClaudeAdapter = class {
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
-  readSessionHistory = async (query, request) => await this.#queryProcesses.previewSessionEvents(query, request);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
+  readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
   close = async () => await runCleanup(
     () => this.#queryProcesses.close(),
     () => this.#liveSessions.close()
@@ -83003,13 +83021,15 @@ function fitCodexToolEvent(event) {
 
 // src/engine/acp/adapter/codex/adapter.ts
 var CodexAdapter = class {
+  #agent;
   #queryProcesses;
   #connector;
   #liveSessions;
   #dependencies;
   #contentExternalizer;
   #previewCache = null;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
+    this.#agent = agent;
     this.#dependencies = dependencies;
     this.#contentExternalizer = {
       update: async (sessionId, update, signal) => {
@@ -83021,18 +83041,25 @@ var CodexAdapter = class {
     };
     this.#connector = new AcpSessionConnector(this.#contentExternalizer, fitCodexToolEvent);
     this.#liveSessions = new AcpLiveSessions(this.#contentExternalizer, fitCodexToolEvent);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => {
+    this.#agent = agent;
+    this.#queryProcesses.refreshAgent(agent);
+  };
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
-  cancel = (...args) => this.#liveSessions.cancel(...args);
+  cancel = async (target, signal) => {
+    await this.#liveSessions.closeSession(target, signal);
+    return "closed";
+  };
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
   prompt = (...args) => this.#liveSessions.prompt(...args);
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
   close = async () => {
     await runCleanup(
       () => this.#queryProcesses.close(),
@@ -83040,9 +83067,9 @@ var CodexAdapter = class {
       () => this.#previewCache?.close()
     );
   };
-  readSessionHistory = async (query, request) => {
-    const { agent, cwd } = query;
-    const signal = AbortSignal.any([query.signal, AbortSignal.timeout(6e4)]);
+  readSessionHistory = async (cwd, _additionalDirectories, request, cancellation) => {
+    const agent = this.#agent;
+    const signal = AbortSignal.any([cancellation, AbortSignal.timeout(6e4)]);
     const { sessionId } = request;
     signal.throwIfAborted();
     nativeSessionIdSchema.parse(request.nativeSessionId);
@@ -83118,12 +83145,13 @@ var PiAdapter = class {
   #queryProcesses;
   #connector;
   #liveSessions;
-  constructor(dependencies) {
+  constructor(agent, dependencies) {
     this.#connector = new AcpSessionConnector(dependencies.contentExternalizer);
     this.#liveSessions = new AcpLiveSessions(dependencies.contentExternalizer);
-    this.#queryProcesses = new AgentQueryProcesses(dependencies.processes, this.#connector);
+    this.#queryProcesses = new AgentQueryProcesses(agent, dependencies.processes, this.#connector);
   }
-  getCapabilities = async (query) => await this.#queryProcesses.capabilities(query);
+  refreshAgent = (agent) => this.#queryProcesses.refreshAgent(agent);
+  getCapabilities = (cwd, signal) => this.#queryProcesses.capabilities(cwd, signal);
   connectSession = (options) => this.#liveSessions.connectSession(options);
   cancel = (...args) => this.#liveSessions.cancel(...args);
   closeSession = (...args) => this.#liveSessions.closeSession(...args);
@@ -83131,9 +83159,9 @@ var PiAdapter = class {
   steer = (...args) => this.#liveSessions.steer(...args);
   renameSession = (...args) => this.#liveSessions.renameSession(...args);
   configureSession = (...args) => this.#liveSessions.configureSession(...args);
-  listSessions = async (query, cursor) => await this.#queryProcesses.listNativeSessions(query, cursor);
-  findSession = (query, nativeSessionId, budget) => findNativeSession(this.listSessions, query, nativeSessionId, budget);
-  readSessionHistory = async (query, request) => await this.#queryProcesses.previewSessionEvents(query, request);
+  listSessions = (cwd, cursor, signal) => this.#queryProcesses.listNativeSessions(cwd, cursor, signal);
+  findSession = (cwd, nativeSessionId, budget, signal) => findNativeSession(this.listSessions, cwd, nativeSessionId, budget, signal);
+  readSessionHistory = (cwd, additionalDirectories, request, signal) => this.#queryProcesses.previewSessionEvents(cwd, additionalDirectories, request, signal);
   close = async () => await runCleanup(
     () => this.#queryProcesses.close(),
     () => this.#liveSessions.close()
@@ -83144,11 +83172,11 @@ var PiAdapter = class {
 var harnessAdapters = (agent, dependencies) => {
   switch (agent.id) {
     case "codex":
-      return new CodexAdapter(dependencies);
+      return new CodexAdapter(agent, dependencies);
     case "claude":
-      return new ClaudeAdapter(dependencies);
+      return new ClaudeAdapter(agent, dependencies);
     case "pi":
-      return new PiAdapter(dependencies);
+      return new PiAdapter(agent, dependencies);
     default:
       throw new AcpExecutionError(
         `Agent "${agent.id}" has no registered harness adapter.`,
@@ -86156,8 +86184,9 @@ var AgentSession = class _AgentSession {
     await this.#interactions.cancelPendingInteractions();
     signal.throwIfAborted();
     if (this.#turn.running) {
-      await this.#adapter.cancel(this.#target(), signal);
+      return await this.#adapter.cancel(this.#target(), signal);
     }
+    return "retained";
   };
   respondPermission = async (options) => {
     await this.#interactions.respondPermission(options);
@@ -86798,7 +86827,18 @@ var SessionManager2 = class {
     await this.#executions.cancel(sessionId, async () => {
       const runtime = this.#executionProcesses.get(sessionId);
       if (runtime !== void 0) {
-        await runtime.cancel(signal2);
+        const outcome = await runtime.cancel(signal2);
+        switch (outcome) {
+          case "retained":
+            break;
+          case "closed":
+            await this.#stopSessionProcess(sessionId, runtime);
+            break;
+          default: {
+            const unreachable3 = outcome;
+            throw new AcpExecutionError("Unexpected cancellation outcome", { cause: unreachable3 });
+          }
+        }
       }
     });
   });
@@ -87164,7 +87204,7 @@ var SessionManager2 = class {
 };
 
 // src/engine/session/native/native-session-browser.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 
 // src/engine/session/workspace/local-authorization-error.ts
 var LocalAuthorizationError = class extends OperationError {
@@ -87223,12 +87263,17 @@ var NativeSessionService = class {
     (scoped) => this.#sessions.withNativeSessionOperation(
       scoped,
       nativeSessionId,
-      (target) => target.adapter.readSessionHistory(target, {
-        nativeSessionId,
-        eventLimit,
-        cursor,
-        sessionId: target.sessionId
-      })
+      (target) => target.adapter.readSessionHistory(
+        target.cwd,
+        target.additionalDirectories,
+        {
+          nativeSessionId,
+          eventLimit,
+          cursor,
+          sessionId: target.sessionId
+        },
+        target.signal
+      )
     )
   );
   #execute = async (command, signal) => {
@@ -87259,7 +87304,7 @@ var NativeSessionService = class {
         queuedCancellation: "before-start"
       };
     }
-    const capabilities = await options.adapter.getCapabilities(options);
+    const capabilities = await options.adapter.getCapabilities(cwd, signal);
     if (!capabilities.listSessions) {
       throw new AcpExecutionError(
         "This Agent does not support native session listing",
@@ -87274,7 +87319,7 @@ var NativeSessionService = class {
       if (authorized === null) {
         return null;
       }
-      const entryId = decodeIdentifier(randomUUID14());
+      const entryId = decodeIdentifier(randomUUID15());
       if (this.#entries.size >= 5e3) {
         this.#entries.clear();
       }
@@ -87313,7 +87358,7 @@ var NativeSessionService = class {
         }
         cursor = known.cursor;
       }
-      const page = await options.adapter.listSessions(options, cursor);
+      const page = await options.adapter.listSessions(cwd, cursor, signal);
       const entries = [];
       for (const info of page.sessions) {
         const entry = await register(info);
@@ -87330,7 +87375,7 @@ var NativeSessionService = class {
             "invalid_native_session_response"
           );
         }
-        nextCursor = decodeIdentifier(randomUUID14());
+        nextCursor = decodeIdentifier(randomUUID15());
         if (this.#cursors.size >= 500) {
           this.#cursors.clear();
         }
@@ -87348,10 +87393,15 @@ var NativeSessionService = class {
       };
     }
     if (command.action === "find") {
-      const found = await options.adapter.findSession(options, command.nativeSessionId, {
-        maximumPages: 500,
-        maximumEntries: 500
-      });
+      const found = await options.adapter.findSession(
+        cwd,
+        command.nativeSessionId,
+        {
+          maximumPages: 500,
+          maximumEntries: 500
+        },
+        signal
+      );
       const entry = await register(found);
       if (entry !== null) {
         return { ...envelope2, action: "find", entry };
@@ -87489,10 +87539,15 @@ var NativeSessionService = class {
     }
   };
   resolveTarget = async (command, options, selected) => {
-    const info = await options.adapter.findSession(options, selected.nativeSessionId, {
-      maximumPages: 100,
-      maximumEntries: null
-    }).catch((cause) => {
+    const info = await options.adapter.findSession(
+      options.cwd,
+      selected.nativeSessionId,
+      {
+        maximumPages: 100,
+        maximumEntries: null
+      },
+      options.signal
+    ).catch((cause) => {
       options.signal.throwIfAborted();
       if (cause instanceof AcpExecutionError && cause.code === "native_session_not_found") {
         throw new AcpExecutionError(
@@ -87761,7 +87816,7 @@ async function settleAbandonedTurn(projection, operations, cancellation) {
 }
 
 // src/engine/session/turn/execution-receipts.ts
-import { createHash as createHash7, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID16 } from "node:crypto";
 var MAX_TERMINAL_RECEIPTS = 1024;
 var ExecutionReceipts = class {
   #executions = /* @__PURE__ */ new Map();
@@ -87902,7 +87957,7 @@ var ExecutionReceipts = class {
     ).digest("hex");
     this.#save(commandId, {
       admissionOrder: this.#nextAdmissionOrder(),
-      attemptId: randomUUID15(),
+      attemptId: randomUUID16(),
       commandHash,
       sessionId,
       started: false,
@@ -87984,7 +88039,7 @@ var ExecutionReceipts = class {
     if (identity2 !== void 0) {
       return identity2.sessionId === sessionId && identity2.commandHash === commandHash ? { kind: "expired" } : { kind: "conflict" };
     }
-    const attemptId = randomUUID15();
+    const attemptId = randomUUID16();
     this.#save(commandId, {
       admissionOrder: this.#nextAdmissionOrder(),
       attemptId,
@@ -88111,7 +88166,7 @@ var RuntimeTurnActivity = class {
 };
 
 // src/engine/session/turn/active-turn.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 var ActiveRuntimeTurn = class {
   attemptId;
   command;
@@ -88121,7 +88176,7 @@ var ActiveRuntimeTurn = class {
   #dispatch;
   #sequence = 0;
   #interaction = null;
-  #epoch = decodeIdentifier(randomUUID16());
+  #epoch = decodeIdentifier(randomUUID17());
   constructor(command, attemptId) {
     this.attemptId = attemptId;
     this.command = command;
@@ -88687,11 +88742,11 @@ import { extname as extname2, join as join29 } from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/engine/storage/files/scratch-directory.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import { lstat as lstat4, mkdir as mkdir5, readdir as readdir6, readFile as readFile6, realpath as realpath7, rename as rename4, rm as rm3, stat as stat6, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join28 } from "node:path";
 async function atomicWrite(path7, bytes, signal) {
-  const temporary = `${path7}.${randomUUID17()}.tmp`;
+  const temporary = `${path7}.${randomUUID18()}.tmp`;
   try {
     await writeFile2(temporary, bytes, { mode: 384, signal });
     signal.throwIfAborted();
@@ -88703,7 +88758,7 @@ async function atomicWrite(path7, bytes, signal) {
 var ScratchDirectory = class {
   #root;
   constructor(parent) {
-    this.#root = join28(parent, randomUUID17());
+    this.#root = join28(parent, randomUUID18());
   }
   /** Refreshes this directory's lease and removes sibling directories whose lease is older than `leaseMilliseconds`. */
   refreshLease = async (leaseMilliseconds) => {
@@ -90709,7 +90764,7 @@ function createNativeSessionCommands(context) {
 }
 
 // src/engine/session/prompt/apply-session-configuration.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function invalidSessionConfiguration(message) {
   return new AcpExecutionError(message, {}, "invalid_session_configuration");
 }
@@ -90847,7 +90902,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
     booleanValue: selection.booleanValue,
     configId: selection.configId,
     cwd,
-    requestId: `cfg_${randomUUID18()}`,
+    requestId: `cfg_${randomUUID19()}`,
     sessionId,
     signal,
     value: selection.value,
@@ -91137,7 +91192,7 @@ var sessionPromptCommand = {
 // package.json
 var 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: {
@@ -92409,7 +92464,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,