@openacp/cli 2026.330.2 → 2026.331.1

package/dist/{chunk-7RKPIM3E.js → chunk-LRV56K2M.js}

@@ -1,9 +1,6 @@
 import {
   AgentCatalog
-} from "./chunk-V2YZWYXT.js";
-import {
-  getAgentCapabilities
-} from "./chunk-ZSLHHQPQ.js";
+} from "./chunk-MDJHCCFS.js";
 import {
   readTextFileWithRange
 } from "./chunk-OYSAN7UX.js";
@@ -12,6 +9,9 @@ import {
   createChildLogger,
   createSessionLogger
 } from "./chunk-R6KZYF7D.js";
+import {
+  getAgentCapabilities
+} from "./chunk-ZSLHHQPQ.js";
 
 // src/core/utils/streams.ts
 function nodeToWebWritable(nodeStream) {
@@ -1084,6 +1084,8 @@ var Session = class extends TypedEmitter {
   agentCapabilities;
   archiving = false;
   promptCount = 0;
+  firstAgent;
+  agentSwitchHistory = [];
   log;
   middlewareChain;
   permissionGate = new PermissionGate();
@@ -1095,6 +1097,7 @@ var Session = class extends TypedEmitter {
     this.id = opts.id || nanoid(12);
     this.channelId = opts.channelId;
     this.agentName = opts.agentName;
+    this.firstAgent = opts.agentName;
     this.workingDirectory = opts.workingDirectory;
     this.agentInstance = opts.agentInstance;
     this.speechService = opts.speechService;
@@ -1176,6 +1179,7 @@ var Session = class extends TypedEmitter {
     }
     if (this._status === "finished") return;
     this.promptCount++;
+    this.emit("prompt_count_changed", this.promptCount);
     if (this._status === "initializing" || this._status === "cancelled" || this._status === "error") {
       this.activate();
     }
@@ -1422,6 +1426,44 @@ ${result.text}` : result.text;
     this.log.info("Prompt aborted");
     await this.agentInstance.cancel();
   }
+  /** Search backward through agentSwitchHistory for the last entry matching agentName */
+  findLastSwitchEntry(agentName) {
+    for (let i = this.agentSwitchHistory.length - 1; i >= 0; i--) {
+      if (this.agentSwitchHistory[i].agentName === agentName) {
+        return this.agentSwitchHistory[i];
+      }
+    }
+    return void 0;
+  }
+  /** Switch the agent instance in-place, preserving session identity */
+  async switchAgent(agentName, createAgent) {
+    if (agentName === this.agentName) {
+      throw new Error(`Already using ${agentName}`);
+    }
+    this.agentSwitchHistory.push({
+      agentName: this.agentName,
+      agentSessionId: this.agentSessionId,
+      switchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      promptCount: this.promptCount
+    });
+    this.queue.clear();
+    if (this.permissionGate.isPending) {
+      this.permissionGate.reject("Agent switched");
+    }
+    await this.agentInstance.destroy();
+    const newAgent = await createAgent();
+    this.agentInstance = newAgent;
+    this.agentName = agentName;
+    this.agentSessionId = newAgent.sessionId;
+    this.promptCount = 0;
+    this.agentCapabilities = void 0;
+    this.currentMode = void 0;
+    this.availableModes = [];
+    this.currentModel = void 0;
+    this.availableModels = [];
+    this.configOptions = [];
+    this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
+  }
   async destroy() {
     this.log.info("Session destroyed");
     if (this.permissionGate.isPending) {
@@ -1609,6 +1651,7 @@ var SessionBridge = class {
   sessionEventHandler;
   statusChangeHandler;
   namedHandler;
+  promptCountHandler;
   get tracer() {
     return this.session.agentInstance.debugTracer ?? null;
   }
@@ -1657,6 +1700,9 @@ var SessionBridge = class {
     if (this.namedHandler) {
       this.session.off("named", this.namedHandler);
     }
+    if (this.promptCountHandler) {
+      this.session.off("prompt_count_changed", this.promptCountHandler);
+    }
     this.session.agentInstance.onPermissionRequest = async () => "";
   }
   wireAgentToSession() {
@@ -1941,6 +1987,10 @@ var SessionBridge = class {
       this.adapter.renameSessionThread(this.session.id, name);
     };
     this.session.on("named", this.namedHandler);
+    this.promptCountHandler = (count) => {
+      this.deps.sessionManager.patchRecord(this.session.id, { currentPromptCount: count });
+    };
+    this.session.on("prompt_count_changed", this.promptCountHandler);
   }
 };
 
@@ -2422,8 +2472,8 @@ var EventBus = class extends TypedEmitter {
 };
 
 // src/core/core.ts
-import path5 from "path";
-import os from "os";
+import path6 from "path";
+import os2 from "os";
 
 // src/core/sessions/session-store.ts
 import fs4 from "fs";
@@ -2467,9 +2517,15 @@ var JsonFileSessionStore = class {
     return void 0;
   }
   findByAgentSessionId(agentSessionId) {
-    return [...this.records.values()].find(
-      (r) => r.agentSessionId === agentSessionId || r.originalAgentSessionId === agentSessionId
-    );
+    for (const record of this.records.values()) {
+      if (record.agentSessionId === agentSessionId || record.originalAgentSessionId === agentSessionId) {
+        return record;
+      }
+      if (record.agentSwitchHistory?.some((e) => e.agentSessionId === agentSessionId)) {
+        return record;
+      }
+    }
+    return void 0;
   }
   list(channelId) {
     const all = [...this.records.values()];
@@ -2796,6 +2852,10 @@ var ErrorTracker = class {
   }
 };
 
+// src/core/plugin/plugin-context.ts
+import path5 from "path";
+import os from "os";
+
 // src/core/plugin/plugin-storage.ts
 import fs5 from "fs";
 import path4 from "path";
@@ -2867,6 +2927,7 @@ function createPluginContext(opts) {
     config,
     core
   } = opts;
+  const instanceRoot = opts.instanceRoot ?? path5.join(os.homedir(), ".openacp");
   const registeredListeners = [];
   const registeredCommands = [];
   const noopLog = {
@@ -2975,6 +3036,7 @@ function createPluginContext(opts) {
       requirePermission(permissions, "kernel:access", "core");
       return core;
     },
+    instanceRoot,
     cleanup() {
       for (const { event, handler } of registeredListeners) {
         eventBus.off(event, handler);
@@ -3049,6 +3111,7 @@ var LifecycleManager = class {
   log;
   settingsManager;
   pluginRegistry;
+  instanceRoot;
   contexts = /* @__PURE__ */ new Map();
   loadOrder = [];
   _loaded = /* @__PURE__ */ new Set();
@@ -3081,6 +3144,7 @@ var LifecycleManager = class {
     this.log = opts?.log;
     this.settingsManager = opts?.settingsManager;
     this.pluginRegistry = opts?.pluginRegistry;
+    this.instanceRoot = opts?.instanceRoot;
   }
   getPluginLogger(pluginName) {
     if (this.log && typeof this.log.child === "function") {
@@ -3190,7 +3254,8 @@ var LifecycleManager = class {
         sessions: this.sessions,
         config: this.config,
         core: this.core,
-        log: this.log
+        log: this.log,
+        instanceRoot: this.instanceRoot
       });
       try {
         await withTimeout(plugin.setup(ctx), SETUP_TIMEOUT_MS, `${plugin.name}.setup()`);
@@ -3255,14 +3320,18 @@ var OpenACPCore = class {
   sessionManager;
   messageTransformer;
   adapters = /* @__PURE__ */ new Map();
+  /** sessionId → SessionBridge — tracks active bridges for disconnect/reconnect during agent switch */
+  bridges = /* @__PURE__ */ new Map();
   /** Set by main.ts — triggers graceful shutdown with restart exit code */
   requestRestart = null;
   _tunnelService;
   sessionStore = null;
   resumeLocks = /* @__PURE__ */ new Map();
+  switchingLocks = /* @__PURE__ */ new Set();
   eventBus;
   sessionFactory;
   lifecycleManager;
+  instanceContext;
   // --- Lazy getters: resolve from ServiceRegistry (populated by plugins during boot) ---
   getService(name) {
     const svc = this.lifecycleManager.serviceRegistry.get(name);
@@ -3284,13 +3353,14 @@ var OpenACPCore = class {
   get contextManager() {
     return this.getService("context");
   }
-  constructor(configManager) {
+  constructor(configManager, ctx) {
     this.configManager = configManager;
+    this.instanceContext = ctx;
     const config = configManager.get();
     this.agentCatalog = new AgentCatalog();
     this.agentCatalog.load();
     this.agentManager = new AgentManager(this.agentCatalog);
-    const storePath = path5.join(os.homedir(), ".openacp", "sessions.json");
+    const storePath = ctx?.paths.sessions ?? path6.join(os2.homedir(), ".openacp", "sessions.json");
     this.sessionStore = new JsonFileSessionStore(
       storePath,
       config.sessionStore.ttlDays
@@ -3313,7 +3383,7 @@ var OpenACPCore = class {
       sessions: this.sessionManager,
       config: this.configManager,
       core: this,
-      storagePath: path5.join(os.homedir(), ".openacp", "plugins", "data"),
+      storagePath: ctx?.paths.pluginsData ?? path6.join(os2.homedir(), ".openacp", "plugins", "data"),
       log: createChildLogger({ module: "plugin" })
     });
     this.sessionFactory.middlewareChain = this.lifecycleManager.middlewareChain;
@@ -3502,7 +3572,10 @@ var OpenACPCore = class {
       createdAt: session.createdAt.toISOString(),
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
       name: session.name,
-      platform
+      platform,
+      firstAgent: session.firstAgent,
+      currentPromptCount: session.promptCount,
+      agentSwitchHistory: session.agentSwitchHistory
     });
     log6.info(
       { sessionId: session.id, agentName: params.agentName },
@@ -3675,6 +3748,117 @@ var OpenACPCore = class {
     }
     return { session, contextResult };
   }
+  // --- Agent Switch ---
+  async switchSessionAgent(sessionId, toAgent) {
+    if (this.switchingLocks.has(sessionId)) {
+      throw new Error("Switch already in progress");
+    }
+    this.switchingLocks.add(sessionId);
+    try {
+      return await this._doSwitchSessionAgent(sessionId, toAgent);
+    } finally {
+      this.switchingLocks.delete(sessionId);
+    }
+  }
+  async _doSwitchSessionAgent(sessionId, toAgent) {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    const agentDef = this.agentManager.getAgent(toAgent);
+    if (!agentDef) throw new Error(`Agent "${toAgent}" is not installed`);
+    const fromAgent = session.agentName;
+    const middlewareChain = this.lifecycleManager.middlewareChain;
+    const result = await middlewareChain.execute("agent:beforeSwitch", {
+      sessionId,
+      fromAgent,
+      toAgent
+    }, async (payload) => payload);
+    if (!result) throw new Error("Agent switch blocked by middleware");
+    const lastEntry = session.findLastSwitchEntry(toAgent);
+    const caps = getAgentCapabilities(toAgent);
+    const canResume = !!(lastEntry && caps.supportsResume && lastEntry.promptCount === 0);
+    const resumed = canResume;
+    const bridge = this.bridges.get(sessionId);
+    if (bridge) bridge.disconnect();
+    const switchAdapter = this.adapters.get(session.channelId);
+    if (switchAdapter?.sendSkillCommands) {
+      await switchAdapter.sendSkillCommands(session.id, []);
+    }
+    if (switchAdapter?.cleanupSessionState) {
+      await switchAdapter.cleanupSessionState(session.id);
+    }
+    const fromAgentSessionId = session.agentSessionId;
+    try {
+      await session.switchAgent(toAgent, async () => {
+        if (canResume) {
+          return this.agentManager.resume(toAgent, session.workingDirectory, lastEntry.agentSessionId);
+        } else {
+          const instance = await this.agentManager.spawn(toAgent, session.workingDirectory);
+          try {
+            const contextService = this.lifecycleManager.serviceRegistry.get("context");
+            if (contextService) {
+              const config = this.configManager.get();
+              const labelAgent = config.agentSwitch?.labelHistory ?? true;
+              const contextResult = await contextService.buildContext(
+                { type: "session", value: sessionId, repoPath: session.workingDirectory },
+                { labelAgent }
+              );
+              if (contextResult?.markdown) {
+                session.setContext(contextResult.markdown);
+              }
+            }
+          } catch {
+          }
+          return instance;
+        }
+      });
+    } catch (err) {
+      try {
+        let rollbackInstance;
+        try {
+          rollbackInstance = await this.agentManager.resume(fromAgent, session.workingDirectory, fromAgentSessionId);
+        } catch {
+          rollbackInstance = await this.agentManager.spawn(fromAgent, session.workingDirectory);
+        }
+        const oldInstance = rollbackInstance;
+        session.agentSwitchHistory.pop();
+        session.agentInstance = oldInstance;
+        session.agentName = fromAgent;
+        session.agentSessionId = oldInstance.sessionId;
+        const adapter = this.adapters.get(session.channelId);
+        if (adapter) {
+          const rollbackBridge = this.createBridge(session, adapter);
+          rollbackBridge.connect();
+        }
+        log6.warn({ sessionId, fromAgent, toAgent, err }, "Agent switch failed, rolled back to previous agent");
+      } catch (rollbackErr) {
+        session.fail(`Switch failed and rollback failed: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`);
+        log6.error({ sessionId, fromAgent, toAgent, err, rollbackErr }, "Agent switch failed and rollback also failed");
+      }
+      throw err;
+    }
+    if (bridge) {
+      const adapter = this.adapters.get(session.channelId);
+      if (adapter) {
+        const newBridge = this.createBridge(session, adapter);
+        newBridge.connect();
+      }
+    }
+    await this.sessionManager.patchRecord(sessionId, {
+      agentName: toAgent,
+      agentSessionId: session.agentSessionId,
+      firstAgent: session.firstAgent,
+      currentPromptCount: 0,
+      agentSwitchHistory: session.agentSwitchHistory
+    });
+    middlewareChain.execute("agent:afterSwitch", {
+      sessionId,
+      fromAgent,
+      toAgent,
+      resumed
+    }, async (p) => p).catch(() => {
+    });
+    return { resumed };
+  }
   // --- Lazy Resume ---
   /**
    * Get active session by thread, or attempt lazy resume from store.
@@ -3734,6 +3918,9 @@ var OpenACPCore = class {
         });
         session.activate();
         session.dangerousMode = record.dangerousMode ?? false;
+        if (record.firstAgent) session.firstAgent = record.firstAgent;
+        if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
+        if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
         log6.info(
           { sessionId: session.id, threadId: message.threadId },
           "Lazy resume successful"
@@ -3762,7 +3949,7 @@ var OpenACPCore = class {
   // --- Event Wiring ---
   /** Create a SessionBridge for the given session and adapter */
   createBridge(session, adapter) {
-    return new SessionBridge(session, adapter, {
+    const bridge = new SessionBridge(session, adapter, {
       messageTransformer: this.messageTransformer,
       notificationManager: this.notificationManager,
       sessionManager: this.sessionManager,
@@ -3770,6 +3957,8 @@ var OpenACPCore = class {
       fileService: this.fileService,
       middlewareChain: this.lifecycleManager?.middlewareChain
     });
+    this.bridges.set(session.id, bridge);
+    return bridge;
   }
 };
 
@@ -3914,4 +4103,4 @@ export {
   OpenACPCore,
   CommandRegistry
 };
-//# sourceMappingURL=chunk-7RKPIM3E.js.map
+//# sourceMappingURL=chunk-LRV56K2M.js.map