maka-agent 0.2.0-dev.67.20261002 → 0.2.0-dev.69.20261004

package/node_modules/@maka/acp-executor-plugin/dist/plugin.mjs

@@ -7,9 +7,199 @@ var __export = (target, all) => {
 // src/index.ts
 import { createHash } from "node:crypto";
 import { constants as constants2, createReadStream } from "node:fs";
-import { access, mkdtemp, rm, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { access, mkdir, mkdtemp, realpath as realpath2, rm, stat as stat2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+
+// ../runtime/dist/admission-limiter.js
+var AdmissionLimiter = class {
+  capacity;
+  active = 0;
+  waiters = [];
+  closedError;
+  constructor(capacity) {
+    this.capacity = capacity;
+    if (!Number.isSafeInteger(capacity) || capacity < 1) {
+      throw new Error("Admission capacity must be a positive safe integer");
+    }
+  }
+  get activeCount() {
+    return this.active;
+  }
+  get waitingCount() {
+    return this.waiters.length;
+  }
+  acquire(signal) {
+    if (this.closedError)
+      return Promise.reject(this.closedError);
+    if (signal.aborted)
+      return Promise.reject(abortReason(signal));
+    if (this.active < this.capacity && this.waiters.length === 0) {
+      this.active += 1;
+      return Promise.resolve(this.createPermit());
+    }
+    return new Promise((resolve3, reject) => {
+      const waiter = {
+        signal,
+        resolve: resolve3,
+        reject,
+        onAbort: () => {
+          const index = this.waiters.indexOf(waiter);
+          if (index < 0)
+            return;
+          this.waiters.splice(index, 1);
+          signal.removeEventListener("abort", waiter.onAbort);
+          reject(abortReason(signal));
+        }
+      };
+      this.waiters.push(waiter);
+      signal.addEventListener("abort", waiter.onAbort, { once: true });
+    });
+  }
+  close(error62) {
+    if (this.closedError)
+      return;
+    this.closedError = error62;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+      waiter.reject(error62);
+    }
+  }
+  createPermit() {
+    let released = false;
+    return {
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        this.active -= 1;
+        this.grantWaiting();
+      }
+    };
+  }
+  grantWaiting() {
+    if (this.closedError)
+      return;
+    while (this.active < this.capacity && this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+      if (waiter.signal.aborted) {
+        waiter.reject(abortReason(waiter.signal));
+        continue;
+      }
+      this.active += 1;
+      waiter.resolve(this.createPermit());
+    }
+  }
+};
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error("Child agent run cancelled while waiting for runtime capacity");
+}
+
+// src/acp-catalog.ts
+var CATALOG_TTL_MS = 6e4;
+var PROBE_TIMEOUT_MS = 3e4;
+var AcpCatalog = class {
+  constructor(admission, probe, unavailable) {
+    this.admission = admission;
+    this.probe = probe;
+    this.unavailable = unavailable;
+  }
+  admission;
+  probe;
+  unavailable;
+  #cached;
+  #pending;
+  #tail;
+  #operations = /* @__PURE__ */ new Set();
+  #revision = 0;
+  #disposed = false;
+  async get(signal, refresh = false) {
+    signal.throwIfAborted();
+    if (this.#disposed) return this.unavailable();
+    if (refresh) this.invalidate();
+    while (true) {
+      signal.throwIfAborted();
+      if (this.#disposed) return this.unavailable();
+      const cached2 = this.#cached;
+      if (cached2 && cached2.expires > Date.now()) return cached2.entry;
+      const pending = this.#ensureProbe();
+      const result = await waitForSignal(pending.promise, signal);
+      signal.throwIfAborted();
+      if (this.#disposed) return this.unavailable();
+      if (pending.revision !== this.#revision) continue;
+      return result;
+    }
+  }
+  #ensureProbe() {
+    if (!this.#pending) {
+      const revision = this.#revision;
+      const controller = new AbortController();
+      const startup = AbortSignal.any([controller.signal, AbortSignal.timeout(PROBE_TIMEOUT_MS)]);
+      const previous = this.#tail;
+      const run = async () => {
+        try {
+          await previous;
+          startup.throwIfAborted();
+          const permit = await this.admission.acquire(startup);
+          let entry;
+          try {
+            startup.throwIfAborted();
+            entry = await this.probe(startup);
+          } finally {
+            permit.release();
+          }
+          if (startup.aborted || revision !== this.#revision || this.#disposed)
+            return this.unavailable();
+          if (entry.readiness === "ready")
+            this.#cached = { entry, expires: Date.now() + CATALOG_TTL_MS };
+          return entry;
+        } catch {
+          return this.unavailable();
+        }
+      };
+      const promise2 = run().finally(() => {
+        this.#operations.delete(promise2);
+        if (this.#pending?.promise === promise2) this.#pending = void 0;
+        if (this.#tail === promise2) this.#tail = void 0;
+      });
+      this.#pending = { revision, controller, promise: promise2 };
+      this.#tail = promise2;
+      this.#operations.add(promise2);
+    }
+    return this.#pending;
+  }
+  invalidate() {
+    this.#revision++;
+    this.#cached = void 0;
+    this.#pending?.controller.abort(new Error("ACP catalog invalidated"));
+    this.#pending = void 0;
+  }
+  async dispose() {
+    this.#disposed = true;
+    this.invalidate();
+    await Promise.allSettled(this.#operations);
+  }
+};
+async function waitForSignal(promise2, signal) {
+  signal.throwIfAborted();
+  return await new Promise((resolve3, reject) => {
+    const aborted2 = () => reject(signal.reason);
+    signal.addEventListener("abort", aborted2, { once: true });
+    void promise2.then(
+      (value) => {
+        signal.removeEventListener("abort", aborted2);
+        resolve3(value);
+      },
+      (error62) => {
+        signal.removeEventListener("abort", aborted2);
+        reject(error62);
+      }
+    );
+  });
+}
+
+// src/index.ts
+import { dirname as dirname2, isAbsolute as isAbsolute2, join, resolve as resolve2 } from "node:path";
 
 // ../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 var AGENT_METHODS = {
@@ -23412,6 +23602,28 @@ var legacyClientNotificationMethods = /* @__PURE__ */ new Set([
   CLIENT_METHODS.elicitation_complete
 ]);
 
+// ../runtime/dist/plugin-runtime.js
+var MakaPluginRuntimeError = class extends Error {
+  code;
+  name = "MakaPluginRuntimeError";
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+  }
+};
+function pluginIdentity(ctx) {
+  const metadata = ctx.maka;
+  if (!metadata) {
+    throw new MakaPluginRuntimeError("activation_failed", "Contribution registration requires a composition entry Context");
+  }
+  return Object.freeze({
+    entryId: metadata.entryId,
+    scopeId: metadata.rootId,
+    extensionId: metadata.packageId,
+    generation: metadata.generation
+  });
+}
+
 // src/acp-errors.ts
 var AcpRuntimeError = class extends Error {
   constructor(message, code) {
@@ -23889,7 +24101,8 @@ var AcpExecutor = class {
   #sessions = /* @__PURE__ */ new Map();
   #disposed = false;
   #catalog;
-  #discovery;
+  #withCatalogDirectory;
+  #temporaryDirectory;
   constructor(adapter, config2, options = {}) {
     this.#adapter = validateAdapter(adapter);
     this.id = adapter.id;
@@ -23897,79 +24110,107 @@ var AcpExecutor = class {
     this.#configured = validateConfiguredAgent(adapter.configure(config2));
     this.#createConnection = options.createConnection ?? createAcpConnection;
     this.#state = options.state;
+    this.#withCatalogDirectory = options.withCatalogDirectory ?? (async (signal, use) => {
+      signal.throwIfAborted();
+      this.#temporaryDirectory ??= mkdtemp(join(tmpdir(), "maka-acp-catalog-"));
+      const directory = await this.#temporaryDirectory;
+      await mkdir(directory, { recursive: true, mode: 448 });
+      try {
+        return await use(await realpath2(directory));
+      } finally {
+        await rm(directory, { recursive: true, force: true });
+      }
+    });
+    this.#catalog = new AcpCatalog(
+      options.catalogAdmission ?? new AdmissionLimiter(1),
+      (signal) => this.#probeCatalog(signal),
+      () => this.#catalogEntry("unavailable")
+    );
   }
   async discover(input2) {
-    if (this.#disposed) return this.#catalogEntry("unavailable");
-    if (this.#catalog) return this.#catalog;
-    if (this.#discovery) return this.#discovery;
-    const probe = async () => {
-      const cwd = await mkdtemp(resolve2(tmpdir(), "maka-acp-catalog-"));
-      const session = {
+    return await this.#catalog.get(input2.signal, input2.refresh);
+  }
+  async #probeCatalog(signal) {
+    return await this.#withCatalogDirectory(
+      signal,
+      (directory) => this.#readCatalog(directory, signal)
+    );
+  }
+  async #readCatalog(directory, signal) {
+    let session;
+    try {
+      signal.throwIfAborted();
+      session = {
         conversationKey: "catalog-probe",
-        cwd,
+        cwd: await realpath2(directory),
         configOptions: [],
         lost: false
       };
-      try {
-        await this.#initialize(session, input2.signal, true);
-        const result = this.#catalogEntry("ready", session.configOptions);
-        this.#catalog = result;
-        return result;
-      } catch (error62) {
-        return this.#catalogEntry(
-          error62?.code === -32e3 ? "authentication_required" : "unavailable"
-        );
-      } finally {
-        await this.#disposeSession(session);
-        await rm(cwd, { recursive: true, force: true });
-      }
-    };
-    this.#discovery = probe().finally(() => {
-      this.#discovery = void 0;
-    });
-    return this.#discovery;
+      await this.#initialize(session, signal, true);
+      return this.#catalogEntry("ready", session.configOptions);
+    } catch (error62) {
+      return this.#catalogEntry(
+        isAuthenticationFailure(error62) ? "authentication_required" : "unavailable"
+      );
+    } finally {
+      if (session) await (session.loss ?? this.#disposeSession(session));
+    }
+  }
+  invalidateCatalog() {
+    this.#catalog.invalidate();
   }
   async inspectConversation(input2) {
     const session = this.#sessions.get(input2.conversationKey);
     if (this.#disposed) return this.#catalogEntry("unavailable");
     if (session && session.cwd !== resolve2(input2.cwd))
-      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+      return this.#catalogEntry("history_only", [], input2.configuration);
     if (session?.restoring)
-      return this.#catalogEntry("restoring", session.configOptions, input2.configuration?.model);
+      return this.#catalogEntry("restoring", session.configOptions, input2.configuration);
     if (session?.restoreFailed)
-      return this.#catalogEntry(
-        "restore_failed",
-        session.configOptions,
-        input2.configuration?.model
-      );
+      return this.#catalogEntry("restore_failed", session.configOptions, input2.configuration);
     if (session?.historyGap)
-      return this.#catalogEntry("history_gap", session.configOptions, input2.configuration?.model);
+      return this.#catalogEntry("history_gap", session.configOptions, input2.configuration);
     if (session && !session.lost)
-      return this.#catalogEntry("ready", session.configOptions, input2.configuration?.model);
+      return this.#catalogEntry("ready", session.configOptions, input2.configuration);
     if (session?.lost && !session.record)
-      return this.#catalogEntry("history_only", session.configOptions, input2.configuration?.model);
+      return this.#catalogEntry("history_only", session.configOptions, input2.configuration);
     const stored = this.#state?.read ? decodeContinuity(await this.#state.read(input2.conversationKey)) : await this.#state?.has(input2.conversationKey, input2.cwd) ? "legacy" : void 0;
-    if (!stored) return this.#catalogEntry("ready", [], input2.configuration?.model);
+    if (!stored) return this.#catalogEntry("ready", [], input2.configuration);
     if (stored === "invalid" || stored === "legacy" || stored.cwd !== resolve2(input2.cwd))
-      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+      return this.#catalogEntry("history_only", [], input2.configuration);
     if (stored.phase === "reserved")
-      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+      return this.#catalogEntry("history_only", [], input2.configuration);
     return this.#catalogEntry(
       stored.phase === "prompt_pending" || stored.phase === "history_gap" ? "history_gap" : "restorable",
       [],
-      input2.configuration?.model ?? stored.confirmedModel
+      {
+        model: input2.configuration?.model ?? stored.confirmedModel,
+        mode: input2.configuration?.mode ?? stored.confirmedMode
+      }
     );
   }
   async configureConversation(input2, signal) {
-    if (!input2.configuration?.model) throw new Error("ACP model change is unavailable");
+    if (!input2.configuration?.model && !input2.configuration?.mode)
+      throw new Error("ACP configuration change is unavailable");
     const session = await this.#session(input2);
-    if (session.active || session.configuring) throw new Error("ACP model change is unavailable");
+    if (session.active || session.configuring || session.restoring || session.awaitingAck)
+      throw new Error("ACP configuration change is unavailable while the Session is busy");
     session.configuring = true;
     const wasConnected = !!session.connection;
     try {
-      await this.#ensureInitialized(session, signal);
-      await this.#applyInitialConfig(session, { model: input2.configuration.model }, signal, true);
+      await this.#ensureInitialized(session, signal, true);
+      await this.#applyInitialConfig(
+        session,
+        !wasConnected && !session.restoredFromState ? { ...this.#configured.launch.initialConfig, ...input2.configuration } : input2.configuration,
+        signal,
+        true
+      );
+      return {
+        ...currentAcpModel(session.configOptions) ? { model: currentAcpModel(session.configOptions) } : {},
+        ...acpOption(session.configOptions, "mode")?.currentValue ? { mode: acpOption(session.configOptions, "mode").currentValue } : {}
+      };
     } catch (error62) {
+      if (isAuthenticationFailure(error62)) this.invalidateCatalog();
       if (!wasConnected || session.lost) {
         await this.#lose(session);
         if (session.record?.sessionId && !session.historyGap) session.restoreFailed = true;
@@ -23986,16 +24227,24 @@ var AcpExecutor = class {
     const model = options.find(
       (option) => option.type === "select" && (option.category === "model" || option.id === "model")
     );
-    const models = model?.type === "select" ? model.options.flatMap((entry) => "options" in entry ? entry.options : [entry]).map((entry) => ({ id: entry.value, name: entry.name })) : this.#catalog?.models ?? [];
+    const models = model?.type === "select" ? model.options.flatMap((entry) => "options" in entry ? entry.options : [entry]).map((entry) => ({ id: entry.value, name: entry.name })) : selected?.model ? [{ id: selected.model, name: selected.model }] : [];
+    const mode = options.find(
+      (option) => option.type === "select" && (option.category === "mode" || option.id === "mode")
+    );
+    const modes = mode?.type === "select" ? mode.options.flatMap((entry) => "options" in entry ? entry.options : [entry]).map((entry) => ({ id: entry.value, name: entry.name })) : selected?.mode ? [{ id: selected.mode, name: selected.mode }] : [];
     return {
       id: this.id,
       displayName: this.displayName,
       readiness,
       ...model?.type === "select" ? this.#adapter.describeModels?.(models) ?? { models } : {
-        models,
-        ...this.#catalog?.modelGroups ? { modelGroups: this.#catalog.modelGroups } : {}
+        models
+      },
+      ...model?.type === "select" ? { currentModel: model.currentValue } : selected?.model ? { currentModel: selected.model } : {},
+      ...mode?.type === "select" ? { modes, currentMode: mode.currentValue, supportsModeChange: true } : {
+        modes,
+        ...selected?.mode ? { currentMode: selected.mode } : {},
+        supportsModeChange: false
       },
-      ...model?.type === "select" ? { currentModel: model.currentValue } : selected ? { currentModel: selected } : {},
       supportsAttachments: false,
       supportsModelChange: model?.type === "select"
     };
@@ -24011,7 +24260,7 @@ var AcpExecutor = class {
     if (request.configuration?.model && request.model && request.model !== this.id && request.configuration.model !== request.model)
       return failure2("Conflicting executor models", "acp_config_invalid");
     const model = request.configuration?.model ?? (request.model === this.id ? void 0 : request.model);
-    if (model) request = { ...request, configuration: { model } };
+    if (model) request = { ...request, configuration: { ...request.configuration, model } };
     let session;
     try {
       session = await this.#session(request);
@@ -24025,12 +24274,8 @@ var AcpExecutor = class {
     try {
       await this.#ensureInitialized(session, context.signal);
       context.signal.throwIfAborted();
-      if (request.configuration?.model)
-        await this.#applyInitialConfig(
-          session,
-          { model: request.configuration.model },
-          context.signal
-        );
+      if (request.configuration?.model || request.configuration?.mode)
+        await this.#applyInitialConfig(session, request.configuration, context.signal);
       await this.#beginPrompt(session, request.turnId);
       const prompt = session.connection.agent.request(methods.agent.session.prompt, {
         sessionId: session.acpSessionId,
@@ -24053,6 +24298,7 @@ var AcpExecutor = class {
       }
       return { status: "completed", text: active.text };
     } catch (error62) {
+      if (isAuthenticationFailure(error62)) this.invalidateCatalog();
       if (errorCode(error62) === "acp_history_gap") session.historyGap = true;
       await this.#lose(session);
       if (session.record?.sessionId && !session.historyGap) session.restoreFailed = true;
@@ -24076,6 +24322,7 @@ var AcpExecutor = class {
   async dispose() {
     if (this.#disposed) return;
     this.#disposed = true;
+    await this.#catalog.dispose();
     const sessions = [...this.#sessions.values()];
     this.#sessions.clear();
     const settlements = await Promise.allSettled(
@@ -24114,9 +24361,9 @@ var AcpExecutor = class {
     this.#sessions.set(request.conversationKey, created);
     return created;
   }
-  async #ensureInitialized(session, signal) {
+  async #ensureInitialized(session, signal, deferSelectedConfig = false) {
     if (session.initialization) return await session.initialization;
-    const initialization = this.#initialize(session, signal);
+    const initialization = this.#initialize(session, signal, false, deferSelectedConfig);
     session.initialization = initialization;
     try {
       await initialization;
@@ -24127,7 +24374,7 @@ var AcpExecutor = class {
       throw error62;
     }
   }
-  async #initialize(session, signal, probe = false) {
+  async #initialize(session, signal, probe = false, deferSelectedConfig = false) {
     const timeout = AbortSignal.timeout(INITIALIZE_TIMEOUT_MS);
     const startupSignal = AbortSignal.any([signal, timeout]);
     startupSignal.throwIfAborted();
@@ -24148,6 +24395,7 @@ var AcpExecutor = class {
         "External Session history cannot be aligned with saved conversation events",
         "acp_history_gap"
       );
+    session.restoredFromState = !!stored;
     if (stored) {
       session.record = stored;
       session.acpSessionId = stored.sessionId;
@@ -24204,7 +24452,27 @@ var AcpExecutor = class {
       ]);
       session.configOptions = restored.configOptions ?? [];
       const restoredModel = currentAcpModel(session.configOptions);
-      if (restoredModel) await this.#persistConfirmedModel(session, restoredModel);
+      const restoredMode = acpOption(session.configOptions, "mode")?.currentValue;
+      if (stored.confirmedModel && restoredModel !== stored.confirmedModel || stored.confirmedMode && restoredMode !== stored.confirmedMode) {
+        const confirmed = await this.#applyInitialConfig(
+          session,
+          {
+            ...stored.confirmedModel ? { model: stored.confirmedModel } : {},
+            ...stored.confirmedMode ? { mode: stored.confirmedMode } : {}
+          },
+          startupSignal,
+          false,
+          // Only an explicit model-only configuration can recover a removed
+          // saved mode. Ordinary execution still requires the exact saved pair.
+          deferSelectedConfig && !!session.configuration?.model && !session.configuration.mode
+        );
+        if (confirmed.model && currentAcpModel(session.configOptions) !== confirmed.model || confirmed.mode && acpOption(session.configOptions, "mode")?.currentValue !== confirmed.mode)
+          throw new AcpRuntimeError(
+            "Restored Agent configuration differs from the saved task",
+            "acp_config_unconfirmed"
+          );
+      }
+      await this.#persistConfirmedConfig(session);
       session.restoring = false;
       if (pending) {
         session.historyGap = true;
@@ -24261,13 +24529,12 @@ var AcpExecutor = class {
       };
       await this.#state?.write?.(session.conversationKey, established);
       session.record = established;
-      const createdModel = currentAcpModel(session.configOptions);
-      if (createdModel) await this.#persistConfirmedModel(session, createdModel);
+      await this.#persistConfirmedConfig(session);
     }
-    if (!probe) {
+    if (!probe && !deferSelectedConfig) {
       await this.#applyInitialConfig(
         session,
-        session.configuration?.model ? { model: session.configuration.model } : launch.initialConfig ?? {},
+        session.configuration?.model || session.configuration?.mode ? { ...launch.initialConfig, ...session.configuration } : launch.initialConfig ?? {},
         startupSignal
       );
     }
@@ -24321,71 +24588,104 @@ var AcpExecutor = class {
       await this.#lose(session);
     }
   }
-  async #applyInitialConfig(session, values, signal, restoreOnFailure = false) {
-    for (const [key, value] of Object.entries(values)) {
-      const option = session.configOptions.find(
-        (candidate) => candidate.type === "select" && (candidate.id === key || candidate.category === key)
-      );
-      if (!option || option.type !== "select")
+  async #applyInitialConfig(session, values, signal, restoreOnFailure = false, omitUnavailableMode = false) {
+    let target = Object.entries(values).filter(
+      (entry) => entry[1] !== void 0
+    );
+    const before = session.configOptions;
+    const selectedModel = target.find(([key]) => key === "model")?.[1];
+    const changingModel = selectedModel !== void 0 && acpOption(before, "model")?.currentValue !== selectedModel;
+    const validate2 = (options, key, value) => {
+      const option = acpOption(options, key);
+      if (!option)
         throw new AcpRuntimeError(
           `ACP configuration is unavailable: ${key}`,
           "acp_config_unavailable"
         );
-      const options = option.options.flatMap(
+      const candidates = option.options.flatMap(
         (entry) => "options" in entry ? entry.options : [entry]
       );
-      if (!options.some((entry) => entry.value === value))
+      if (!candidates.some((entry) => entry.value === value))
         throw new AcpRuntimeError(
           `ACP configuration value is unavailable: ${key}`,
           "acp_config_invalid"
         );
-      if (option.currentValue === value) {
-        if (key === "model") await this.#persistConfirmedModel(session, value);
-        continue;
-      }
-      signal.throwIfAborted();
-      try {
+    };
+    for (const [key, value] of target) {
+      if (omitUnavailableMode && key === "mode") continue;
+      if (!changingModel || key === "model") validate2(before, key, value);
+    }
+    const ordered = [
+      ...target.filter(([key]) => key === "model"),
+      ...target.filter(([key]) => key !== "model")
+    ];
+    let mutationAttempted = false;
+    try {
+      for (const [key, value] of ordered) {
+        const option = acpOption(session.configOptions, key);
+        if (omitUnavailableMode && key === "mode" && !option?.options.flatMap((entry) => "options" in entry ? entry.options : [entry]).some((entry) => entry.value === value)) {
+          target = target.filter(([candidate]) => candidate !== "mode");
+          continue;
+        }
+        validate2(session.configOptions, key, value);
+        if (!option) throw new Error("Validated ACP option disappeared");
+        if (option.currentValue === value) continue;
+        signal.throwIfAborted();
+        mutationAttempted = true;
         const updated = await session.connection.agent.request(
           methods.agent.session.setConfigOption,
           { sessionId: session.acpSessionId, configId: option.id, value },
           { cancellationSignal: signal }
         );
-        const confirmed = updated.configOptions.find((candidate) => candidate.id === option.id);
-        if (confirmed?.type !== "select" || confirmed.currentValue !== value)
+        session.configOptions = updated.configOptions;
+        if (acpOption(updated.configOptions, key)?.currentValue !== value)
           throw new AcpRuntimeError(
             "Agent did not confirm the selected configuration",
             "acp_config_unconfirmed"
           );
-        session.configOptions = updated.configOptions;
-        if (key === "model") await this.#persistConfirmedModel(session, value);
-      } catch (error62) {
-        let restored = false;
-        if (restoreOnFailure && !session.lost && !signal.aborted) {
-          try {
+      }
+      if (target.some(([key, value]) => acpOption(session.configOptions, key)?.currentValue !== value))
+        throw new AcpRuntimeError(
+          "Agent changed another selected configuration",
+          "acp_config_unconfirmed"
+        );
+      await this.#persistConfirmedConfig(session);
+      return Object.fromEntries(target);
+    } catch (error62) {
+      let restored = false;
+      if (restoreOnFailure && !session.lost && !signal.aborted) {
+        try {
+          for (const key of ["model", "mode"]) {
+            const original = acpOption(before, key);
+            const current = acpOption(session.configOptions, key);
+            if (!original || !current || !mutationAttempted && current.currentValue === original.currentValue)
+              continue;
             const rollback = await session.connection.agent.request(
               methods.agent.session.setConfigOption,
-              { sessionId: session.acpSessionId, configId: option.id, value: option.currentValue },
+              {
+                sessionId: session.acpSessionId,
+                configId: current.id,
+                value: original.currentValue
+              },
               { cancellationSignal: AbortSignal.timeout(5e3) }
             );
-            const confirmed = rollback.configOptions.find(
-              (candidate) => candidate.id === option.id
-            );
-            if (confirmed?.type === "select" && confirmed.currentValue === option.currentValue && !session.lost) {
-              session.configOptions = rollback.configOptions;
-              if (key === "model") await this.#persistConfirmedModel(session, option.currentValue);
-              restored = true;
-            }
-          } catch {
+            session.configOptions = rollback.configOptions;
           }
+          restored = ["model", "mode"].every((key) => {
+            const original = acpOption(before, key);
+            return !original || acpOption(session.configOptions, key)?.currentValue === original.currentValue;
+          });
+        } catch {
         }
-        if (!restored) await this.#lose(session);
-        throw error62;
       }
+      if (!restored) await this.#lose(session);
+      throw error62;
     }
   }
-  async #persistConfirmedModel(session, model) {
-    if (!session.record || session.record.confirmedModel === model) return;
-    const record2 = { ...session.record, confirmedModel: model };
+  async #persistConfirmedConfig(session, configOptions = session.configOptions) {
+    if (!session.record) return;
+    const record2 = withConfirmedConfiguration(session.record, configOptions);
+    if (record2 === session.record) return;
     await this.#state?.write?.(session.conversationKey, record2);
     session.record = record2;
   }
@@ -24430,7 +24730,9 @@ var AcpExecutor = class {
     }
     if (session.historyGap || session.lost) return;
     if (update.sessionUpdate === "config_option_update") {
-      if (!session.configuring && !session.lost) session.configOptions = update.configOptions;
+      if (!session.configuring && !session.lost) {
+        session.configOptions = update.configOptions;
+      }
       return;
     }
     const active = session.active;
@@ -24555,10 +24857,26 @@ var AcpExecutor = class {
   }
 };
 function currentAcpModel(options) {
-  const option = options.find(
-    (candidate) => candidate.type === "select" && (candidate.id === "model" || candidate.category === "model")
+  return acpOption(options, "model")?.currentValue;
+}
+function withConfirmedConfiguration(record2, options) {
+  const model = currentAcpModel(options);
+  const mode = acpOption(options, "mode")?.currentValue;
+  const { confirmedModel, confirmedMode, ...base } = record2;
+  if (confirmedModel === model && confirmedMode === mode) return record2;
+  return {
+    ...base,
+    ...model ? { confirmedModel: model } : {},
+    ...mode ? { confirmedMode: mode } : {}
+  };
+}
+function isAuthenticationFailure(error62) {
+  return error62?.code === -32e3 || error62 instanceof Error && /authentication required|unauthorized/u.test(error62.message.toLowerCase());
+}
+function acpOption(options, key) {
+  return options.find(
+    (candidate) => candidate.type === "select" && (candidate.id === key || candidate.category === key)
   );
-  return option?.type === "select" ? option.currentValue : void 0;
 }
 function toolTextContent(content) {
   return content.flatMap(
@@ -24566,14 +24884,19 @@ function toolTextContent(content) {
   ).join("\n");
 }
 var AcpRuntimeService = class {
+  // Shared by every adapter below this ACP runtime Entry, including queued probes.
+  #catalogAdmission = new AdmissionLimiter(2);
   constructor(ctx) {
     ctx.provide("acp", this);
   }
   register(consumer, adapter, config2) {
     const storage = consumer.get("storage");
     if (!storage) throw new Error("ACP continuity storage is unavailable");
+    const directoryKey = `acp-catalog/${adapter.id}/${createHash("sha256").update(pluginIdentity(consumer).entryId).digest("hex")}`;
     const provider = new AcpExecutor(adapter, config2, {
-      state: pluginStateStore(storage, adapter.id)
+      state: pluginStateStore(storage, adapter.id),
+      catalogAdmission: this.#catalogAdmission,
+      withCatalogDirectory: (signal, use) => storage.withScratchDirectory(directoryKey, signal, use)
     });
     consumer.effect(() => () => provider.dispose(), `acp.dispose(${JSON.stringify(adapter.id)})`);
     return consumer.executors.register(provider);
@@ -24603,7 +24926,7 @@ function decodeContinuity(value) {
   if (record2.version === 1) return "legacy";
   if (record2.version !== 2 || typeof record2.cwd !== "string" || !isAbsolute2(record2.cwd) || typeof record2.binding !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(record2.binding) || !Number.isSafeInteger(record2.committedPrompts) || record2.committedPrompts < 0 || !["reserved", "established", "prompt_pending", "committed", "history_gap"].includes(
     String(record2.phase)
-  ) || record2.sessionId !== void 0 && (typeof record2.sessionId !== "string" || !record2.sessionId || record2.sessionId.length > 4096) || record2.pendingTurnId !== void 0 && (typeof record2.pendingTurnId !== "string" || !record2.pendingTurnId) || record2.confirmedModel !== void 0 && (typeof record2.confirmedModel !== "string" || !record2.confirmedModel) || record2.phase === "reserved" && record2.sessionId !== void 0 || record2.phase !== "reserved" && !record2.sessionId || record2.phase === "prompt_pending" && !record2.pendingTurnId || record2.phase !== "prompt_pending" && record2.pendingTurnId !== void 0 || record2.gapEvidence !== void 0 && (record2.phase !== "history_gap" || !record2.gapEvidence || typeof record2.gapEvidence !== "object" || !Number.isSafeInteger(record2.gapEvidence.replayedUpdates) || !Number.isSafeInteger(record2.gapEvidence.replayedUserChunks) || record2.gapEvidence.replayedUpdates < 0 || record2.gapEvidence.replayedUserChunks < 0))
+  ) || record2.sessionId !== void 0 && (typeof record2.sessionId !== "string" || !record2.sessionId || record2.sessionId.length > 4096) || record2.pendingTurnId !== void 0 && (typeof record2.pendingTurnId !== "string" || !record2.pendingTurnId) || record2.confirmedModel !== void 0 && (typeof record2.confirmedModel !== "string" || !record2.confirmedModel) || record2.confirmedMode !== void 0 && (typeof record2.confirmedMode !== "string" || !record2.confirmedMode) || record2.phase === "reserved" && record2.sessionId !== void 0 || record2.phase !== "reserved" && !record2.sessionId || record2.phase === "prompt_pending" && !record2.pendingTurnId || record2.phase !== "prompt_pending" && record2.pendingTurnId !== void 0 || record2.gapEvidence !== void 0 && (record2.phase !== "history_gap" || !record2.gapEvidence || typeof record2.gapEvidence !== "object" || !Number.isSafeInteger(record2.gapEvidence.replayedUpdates) || !Number.isSafeInteger(record2.gapEvidence.replayedUserChunks) || record2.gapEvidence.replayedUpdates < 0 || record2.gapEvidence.replayedUserChunks < 0))
     return "invalid";
   return record2;
 }