maka-agent 0.2.0-dev.53.20260927 → 0.2.0-dev.62.20260928

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

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 
 // src/index.ts
 import { createHash } from "node:crypto";
-import { constants as constants2 } from "node:fs";
+import { constants as constants2, createReadStream } from "node:fs";
 import { access, mkdtemp, rm, realpath as realpath2, 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";
@@ -23915,17 +23915,52 @@ var AcpExecutor = class {
   async inspectConversation(input2) {
     const session = this.#sessions.get(input2.conversationKey);
     if (this.#disposed) return this.#catalogEntry("unavailable");
-    if (session?.lost || !session && await this.#state?.has(input2.conversationKey, input2.cwd))
-      return this.#catalogEntry("history_only");
-    return this.#catalogEntry("ready", session?.configOptions ?? [], input2.configuration?.model);
+    if (session && session.cwd !== resolve2(input2.cwd))
+      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+    if (session?.restoring)
+      return this.#catalogEntry("restoring", session.configOptions, input2.configuration?.model);
+    if (session?.restoreFailed)
+      return this.#catalogEntry(
+        "restore_failed",
+        session.configOptions,
+        input2.configuration?.model
+      );
+    if (session?.historyGap)
+      return this.#catalogEntry("history_gap", session.configOptions, input2.configuration?.model);
+    if (session && !session.lost)
+      return this.#catalogEntry("ready", session.configOptions, input2.configuration?.model);
+    if (session?.lost && !session.record)
+      return this.#catalogEntry("history_only", session.configOptions, input2.configuration?.model);
+    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 === "invalid" || stored === "legacy" || stored.cwd !== resolve2(input2.cwd))
+      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+    if (stored.phase === "reserved")
+      return this.#catalogEntry("history_only", [], input2.configuration?.model);
+    return this.#catalogEntry(
+      stored.phase === "prompt_pending" || stored.phase === "history_gap" ? "history_gap" : "restorable",
+      [],
+      input2.configuration?.model ?? stored.confirmedModel
+    );
   }
   async configureConversation(input2, signal) {
-    const session = this.#sessions.get(input2.conversationKey);
-    if (!session?.connection || session.lost || session.active || session.configuring || !input2.configuration?.model)
-      throw new Error("ACP model change is unavailable");
+    if (!input2.configuration?.model) throw new Error("ACP model change is unavailable");
+    const session = await this.#session(input2);
+    if (session.active || session.configuring) throw new Error("ACP model change is unavailable");
     session.configuring = true;
+    const wasConnected = !!session.connection;
     try {
+      await this.#ensureInitialized(session, signal);
       await this.#applyInitialConfig(session, { model: input2.configuration.model }, signal, true);
+    } catch (error62) {
+      if (!wasConnected || session.lost) {
+        await this.#lose(session);
+        if (session.record?.sessionId && !session.historyGap) session.restoreFailed = true;
+        const retryable = !session.acpSessionId && !session.continuityReserved && !session.record;
+        if (retryable && this.#sessions.get(session.conversationKey) === session)
+          this.#sessions.delete(session.conversationKey);
+      }
+      throw error62;
     } finally {
       session.configuring = false;
     }
@@ -23934,12 +23969,15 @@ 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 })) : [];
+    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 ?? [];
     return {
       id: this.id,
       displayName: this.displayName,
       readiness,
-      ...this.#adapter.describeModels?.(models) ?? { models },
+      ...model?.type === "select" ? this.#adapter.describeModels?.(models) ?? { models } : {
+        models,
+        ...this.#catalog?.modelGroups ? { modelGroups: this.#catalog.modelGroups } : {}
+      },
       ...model?.type === "select" ? { currentModel: model.currentValue } : selected ? { currentModel: selected } : {},
       supportsAttachments: false,
       supportsModelChange: model?.type === "select"
@@ -23959,11 +23997,11 @@ var AcpExecutor = class {
     if (model) request = { ...request, configuration: { model } };
     let session;
     try {
-      session = this.#session(request);
+      session = await this.#session(request);
     } catch (error62) {
       return failure2(safeErrorMessage(error62), errorCode(error62));
     }
-    if (session.active || session.configuring)
+    if (session.active || session.configuring || session.awaitingAck)
       return failure2(`${this.displayName} ACP Session is busy`, "acp_busy", true);
     const active = { context, tools: /* @__PURE__ */ new Map(), text: "" };
     session.active = active;
@@ -23976,12 +24014,14 @@ var AcpExecutor = class {
           { model: request.configuration.model },
           context.signal
         );
+      await this.#beginPrompt(session, request.turnId);
       const prompt = session.connection.agent.request(methods.agent.session.prompt, {
         sessionId: session.acpSessionId,
         prompt: [{ type: "text", text: promptText(request) }]
       });
       const response = await this.#awaitPrompt(session, prompt, context.signal);
       if (!response) return { status: "cancelled", reason: "timeout" };
+      if (session.record) session.awaitingAck = request.turnId;
       if (context.signal.aborted || response.stopReason === "cancelled") {
         return { status: "cancelled", providerStopReason: response.stopReason };
       }
@@ -23996,8 +24036,10 @@ var AcpExecutor = class {
       }
       return { status: "completed", text: active.text };
     } catch (error62) {
+      if (errorCode(error62) === "acp_history_gap") session.historyGap = true;
       await this.#lose(session);
-      const retryable = !session.acpSessionId && !session.continuityReserved && errorCode(error62) !== "acp_history_only";
+      if (session.record?.sessionId && !session.historyGap) session.restoreFailed = true;
+      const retryable = !session.acpSessionId && !session.continuityReserved && errorCode(error62) !== "acp_history_only" && errorCode(error62) !== "acp_history_gap";
       if (retryable && this.#sessions.get(session.conversationKey) === session)
         this.#sessions.delete(session.conversationKey);
       if (context.signal.aborted) {
@@ -24027,18 +24069,23 @@ var AcpExecutor = class {
     );
     if (failures.length) throw new AggregateError(failures, "ACP process cleanup failed");
   }
-  #session(request) {
+  async #session(request) {
     const cwd = resolve2(request.cwd);
     const existing = this.#sessions.get(request.conversationKey);
     if (existing) {
       if (existing.cwd !== cwd)
         throw new AcpRuntimeError("ACP conversation cannot change workspace", "acp_cwd_changed");
-      if (existing.lost)
+      if (!existing.lost) return existing;
+      if (existing.active || existing.configuring)
+        throw new AcpRuntimeError("ACP Session is busy", "acp_busy");
+      if (!existing.record)
         throw new AcpRuntimeError(
           "ACP conversation is history-only because its external process was lost",
           "acp_history_only"
         );
-      return existing;
+      await existing.loss;
+      if (this.#sessions.get(request.conversationKey) !== existing) return this.#session(request);
+      this.#sessions.delete(request.conversationKey);
     }
     const created = {
       conversationKey: request.conversationKey,
@@ -24058,20 +24105,40 @@ var AcpExecutor = class {
       await initialization;
     } catch (error62) {
       session.initialization = void 0;
+      session.restoring = false;
+      session.replay = void 0;
       throw error62;
     }
   }
   async #initialize(session, signal, probe = false) {
-    if (!probe && await this.#state?.has(session.conversationKey, session.cwd)) {
-      throw new AcpRuntimeError(
-        "ACP conversation is history-only after the Plugin or Host was restarted",
-        "acp_history_only"
-      );
-    }
     const timeout = AbortSignal.timeout(INITIALIZE_TIMEOUT_MS);
     const startupSignal = AbortSignal.any([signal, timeout]);
     startupSignal.throwIfAborted();
     const launch = this.#configured.launch;
+    const stored = probe ? void 0 : this.#state?.read ? decodeContinuity(await this.#state.read(session.conversationKey)) : await this.#state?.has(session.conversationKey, session.cwd) ? "legacy" : void 0;
+    if (stored === "legacy")
+      throw new AcpRuntimeError(
+        "ACP conversation is history-only after the Plugin or Host was restarted",
+        "acp_history_only"
+      );
+    if (stored === "invalid" || stored && stored.cwd !== session.cwd || stored?.phase === "reserved")
+      throw new AcpRuntimeError(
+        "ACP conversation has no recoverable external Session identity",
+        "acp_history_only"
+      );
+    if (stored?.phase === "history_gap")
+      throw new AcpRuntimeError(
+        "External Session history cannot be aligned with saved conversation events",
+        "acp_history_gap"
+      );
+    if (stored) {
+      session.record = stored;
+      session.acpSessionId = stored.sessionId;
+      session.restoring = true;
+    }
+    const binding = !probe && this.#state?.write ? await launchBinding(this.id, launch, startupSignal) : void 0;
+    if (stored && stored.binding !== binding)
+      throw new AcpRuntimeError("ACP Agent installation changed", "acp_restore_identity_changed");
     const executable = await checkedExecutable(launch.executable);
     await Promise.all((launch.requiredExecutables ?? []).map(checkedExecutable));
     const owner = this.#createConnection({
@@ -24101,9 +24168,62 @@ var AcpExecutor = class {
       owner.failed
     ]);
     if (initialized.protocolVersion !== 1) throw new Error("Unsupported ACP protocol version");
+    if (stored) {
+      session.replay = { updates: 0, userChunks: 0 };
+      const pending = stored.phase === "prompt_pending";
+      const supported = pending ? initialized.agentCapabilities?.loadSession : initialized.agentCapabilities?.sessionCapabilities?.resume;
+      if (!supported)
+        throw new AcpRuntimeError(
+          "ACP Agent cannot restore this Session",
+          "acp_restore_unsupported"
+        );
+      const restored = await Promise.race([
+        owner.connection.agent.request(
+          pending ? methods.agent.session.load : methods.agent.session.resume,
+          { sessionId: stored.sessionId, cwd: session.cwd, mcpServers: [] },
+          { cancellationSignal: startupSignal }
+        ),
+        owner.failed
+      ]);
+      session.configOptions = restored.configOptions ?? [];
+      const restoredModel = currentAcpModel(session.configOptions);
+      if (restoredModel) await this.#persistConfirmedModel(session, restoredModel);
+      session.restoring = false;
+      if (pending) {
+        session.historyGap = true;
+        session.record = {
+          ...session.record,
+          phase: "history_gap",
+          pendingTurnId: void 0,
+          gapEvidence: {
+            replayedUpdates: session.replay?.updates ?? 0,
+            replayedUserChunks: session.replay?.userChunks ?? 0
+          }
+        };
+        await this.#state?.write?.(session.conversationKey, session.record);
+        session.replay = void 0;
+        throw new AcpRuntimeError(
+          "External Session was restored, but conversation history may have a gap",
+          "acp_history_gap"
+        );
+      }
+      session.replay = void 0;
+      return;
+    }
     if (!probe) {
       startupSignal.throwIfAborted();
-      await this.#state?.mark(session.conversationKey, session.cwd);
+      if (this.#state?.write && binding) {
+        session.record = {
+          version: 2,
+          cwd: session.cwd,
+          binding,
+          phase: "reserved",
+          committedPrompts: 0
+        };
+        await this.#state.write(session.conversationKey, session.record);
+      } else {
+        await this.#state?.mark(session.conversationKey, session.cwd);
+      }
       session.continuityReserved = true;
     }
     const created = await Promise.race([
@@ -24116,6 +24236,17 @@ var AcpExecutor = class {
     ]);
     session.acpSessionId = created.sessionId;
     session.configOptions = created.configOptions ?? [];
+    if (session.record) {
+      const established = {
+        ...session.record,
+        phase: "established",
+        sessionId: created.sessionId
+      };
+      await this.#state?.write?.(session.conversationKey, established);
+      session.record = established;
+      const createdModel = currentAcpModel(session.configOptions);
+      if (createdModel) await this.#persistConfirmedModel(session, createdModel);
+    }
     if (!probe) {
       await this.#applyInitialConfig(
         session,
@@ -24124,6 +24255,55 @@ var AcpExecutor = class {
       );
     }
   }
+  async #beginPrompt(session, turnId) {
+    if (!session.record) return;
+    const pending = {
+      ...session.record,
+      phase: "prompt_pending",
+      pendingTurnId: turnId
+    };
+    await this.#state?.write?.(session.conversationKey, pending);
+    session.record = pending;
+  }
+  /** Called only after the Runtime Kernel has durably accepted the terminal event. */
+  async acknowledgeExecution(conversationKey, turnId) {
+    const session = this.#sessions.get(conversationKey);
+    if (!session?.record || session.awaitingAck !== turnId || session.record.phase !== "prompt_pending" || session.record.pendingTurnId !== turnId)
+      return;
+    const committed = {
+      ...session.record,
+      phase: "committed",
+      committedPrompts: session.record.committedPrompts + 1,
+      pendingTurnId: void 0
+    };
+    try {
+      await this.#state?.write?.(conversationKey, committed);
+    } catch (error62) {
+      session.historyGap = true;
+      await this.#lose(session);
+      throw error62;
+    }
+    session.record = committed;
+    session.awaitingAck = void 0;
+  }
+  /** The external turn settled, but Maka did not durably consume its terminal event. */
+  async abandonExecution(conversationKey, turnId) {
+    const session = this.#sessions.get(conversationKey);
+    if (!session?.record || session.awaitingAck !== turnId || session.record.phase !== "prompt_pending" || session.record.pendingTurnId !== turnId)
+      return;
+    session.historyGap = true;
+    session.awaitingAck = void 0;
+    session.record = {
+      ...session.record,
+      phase: "history_gap",
+      pendingTurnId: void 0
+    };
+    try {
+      await this.#state?.write?.(conversationKey, session.record);
+    } finally {
+      await this.#lose(session);
+    }
+  }
   async #applyInitialConfig(session, values, signal, restoreOnFailure = false) {
     for (const [key, value] of Object.entries(values)) {
       const option = session.configOptions.find(
@@ -24142,7 +24322,10 @@ var AcpExecutor = class {
           `ACP configuration value is unavailable: ${key}`,
           "acp_config_invalid"
         );
-      if (option.currentValue === value) continue;
+      if (option.currentValue === value) {
+        if (key === "model") await this.#persistConfirmedModel(session, value);
+        continue;
+      }
       signal.throwIfAborted();
       try {
         const updated = await session.connection.agent.request(
@@ -24157,6 +24340,7 @@ var AcpExecutor = class {
             "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) {
@@ -24171,6 +24355,7 @@ var AcpExecutor = class {
             );
             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 {
@@ -24181,16 +24366,22 @@ var AcpExecutor = class {
       }
     }
   }
+  async #persistConfirmedModel(session, model) {
+    if (!session.record || session.record.confirmedModel === model) return;
+    const record2 = { ...session.record, confirmedModel: model };
+    await this.#state?.write?.(session.conversationKey, record2);
+    session.record = record2;
+  }
   #configureClient(session, app) {
     app.onNotification(methods.client.session.update, ({ params }) => {
       if (params.sessionId === session.acpSessionId) this.#acceptUpdate(session, params.update);
     }).onRequest(methods.client.fs.readTextFile, async ({ params }) => {
-      this.#assertSession(session, params.sessionId);
+      this.#assertWorkspaceAccess(session, params.sessionId);
       return {
         content: await readWorkspaceTextFile(session.cwd, params.path, params.line, params.limit)
       };
     }).onRequest(methods.client.fs.writeTextFile, async ({ params }) => {
-      this.#assertSession(session, params.sessionId);
+      this.#assertWorkspaceAccess(session, params.sessionId);
       await writeWorkspaceTextFile(session.cwd, params.path, params.content);
       return {};
     }).onRequest(
@@ -24200,6 +24391,8 @@ var AcpExecutor = class {
   }
   async #requestPermission(session, request) {
     this.#assertSession(session, request.sessionId);
+    if (session.restoring || session.historyGap || session.lost)
+      return { outcome: { outcome: "cancelled" } };
     const active = session.active;
     if (!active) return { outcome: { outcome: "cancelled" } };
     const outcome = await active.context.requestPermission({
@@ -24211,6 +24404,14 @@ var AcpExecutor = class {
     return { outcome };
   }
   #acceptUpdate(session, update) {
+    if (session.restoring) {
+      if (session.replay) {
+        session.replay.updates++;
+        if (update.sessionUpdate === "user_message_chunk") session.replay.userChunks++;
+      }
+      return;
+    }
+    if (session.historyGap || session.lost) return;
     if (update.sessionUpdate === "config_option_update") {
       if (!session.configuring && !session.lost) session.configOptions = update.configOptions;
       return;
@@ -24229,6 +24430,15 @@ var AcpExecutor = class {
     if (update.sessionUpdate === "tool_call") this.#acceptTool(active, update);
     if (update.sessionUpdate === "tool_call_update") this.#acceptTool(active, update);
   }
+  #assertWorkspaceAccess(session, sessionId) {
+    this.#assertSession(session, sessionId);
+    if (session.restoring || session.historyGap || session.lost) {
+      throw new AcpRuntimeError(
+        "ACP filesystem access is unavailable while Session history is untrusted",
+        "acp_history_gap"
+      );
+    }
+  }
   #acceptTool(active, update) {
     const snapshot = active.tools.get(update.toolCallId) ?? {
       id: update.toolCallId,
@@ -24327,6 +24537,12 @@ var AcpExecutor = class {
     if (owner) await owner.dispose();
   }
 };
+function currentAcpModel(options) {
+  const option = options.find(
+    (candidate) => candidate.type === "select" && (candidate.id === "model" || candidate.category === "model")
+  );
+  return option?.type === "select" ? option.currentValue : void 0;
+}
 function toolTextContent(content) {
   return content.flatMap(
     (item) => item.type === "content" && item.content.type === "text" ? [item.content.text] : []
@@ -24350,14 +24566,54 @@ function pluginStateStore(storage, executorId) {
   const key = (conversationKey) => `acp/${executorId}/${createHash("sha256").update(conversationKey).digest("hex")}`;
   return {
     async has(conversationKey) {
-      const value = (await storage.get(key(conversationKey))).value;
-      return value?.version === 1;
+      return (await storage.get(key(conversationKey))).value !== void 0;
     },
     async mark(conversationKey, cwd) {
       await storage.set(key(conversationKey), { version: 1, cwd });
+    },
+    async read(conversationKey) {
+      return (await storage.get(key(conversationKey))).value;
+    },
+    async write(conversationKey, state) {
+      await storage.set(key(conversationKey), state);
     }
   };
 }
+function decodeContinuity(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return "invalid";
+  const record2 = 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))
+    return "invalid";
+  return record2;
+}
+async function launchBinding(adapterId, launch, signal) {
+  const paths = [launch.executable, ...launch.requiredExecutables ?? []];
+  const files = [];
+  for (const path of paths) {
+    signal.throwIfAborted();
+    const resolved = await checkedExecutable(path);
+    const hash2 = createHash("sha256");
+    for await (const chunk of createReadStream(resolved)) {
+      signal.throwIfAborted();
+      hash2.update(chunk);
+    }
+    files.push({ path: resolved, digest: hash2.digest("hex") });
+  }
+  return `sha256:${createHash("sha256").update(
+    JSON.stringify({
+      adapterId,
+      files,
+      args: launch.args ?? [],
+      cwd: launch.cwd ?? dirname2(files[0].path),
+      platform: process.platform,
+      arch: process.arch
+    })
+  ).digest("hex")}`;
+}
 function validateAdapter(adapter) {
   if (!adapter || typeof adapter !== "object" || typeof adapter.id !== "string" || !/^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$/u.test(adapter.id) || typeof adapter.displayName !== "string" || !adapter.displayName.trim() || adapter.clientName !== void 0 && (typeof adapter.clientName !== "string" || !adapter.clientName.trim()) || typeof adapter.configure !== "function") {
     throw new TypeError("Invalid ACP Agent adapter");

package/node_modules/@maka/core/dist/executor-catalog.js

@@ -35,7 +35,16 @@ export function normalizeCatalogEntry(value, id) {
         !isExecutorId(id) ||
         value.id !== id ||
         !isCatalogText(value.displayName) ||
-        !['ready', 'unavailable', 'authentication_required', 'history_only'].includes(value.readiness) ||
+        ![
+            'ready',
+            'unavailable',
+            'authentication_required',
+            'history_only',
+            'restorable',
+            'restoring',
+            'restore_failed',
+            'history_gap',
+        ].includes(value.readiness) ||
         !Array.isArray(value.models) ||
         value.models.length > 256 ||
         !Array.from(value.models).every((model) => model &&

package/node_modules/@maka/core/dist/message-queue-order.js

@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export function exactQueueReorder(current, requestedEntryIds) {
+    if (requestedEntryIds.length !== current.length)
+        return undefined;
+    const remaining = new Map(current.map((entry) => [entry.entryId, entry]));
+    if (remaining.size !== current.length)
+        return undefined;
+    const entries = [];
+    for (const entryId of requestedEntryIds) {
+        const entry = remaining.get(entryId);
+        if (!entry)
+            return undefined;
+        remaining.delete(entryId);
+        entries.push(entry);
+    }
+    return {
+        entries,
+        changed: entries.some((entry, index) => current[index] !== entry),
+    };
+}
+export function moveQueueEntryId(currentEntryIds, sourceEntryId, targetEntryId) {
+    const sourceIndex = currentEntryIds.indexOf(sourceEntryId);
+    const targetIndex = currentEntryIds.indexOf(targetEntryId);
+    if (sourceIndex === -1 || targetIndex === -1 || sourceIndex === targetIndex)
+        return undefined;
+    const entries = [...currentEntryIds];
+    entries.splice(sourceIndex, 1);
+    entries.splice(targetIndex, 0, sourceEntryId);
+    return entries;
+}

package/node_modules/@maka/core/dist/model-metadata.js

@@ -137,7 +137,8 @@ export function lookupModelRuntimeOverride(providerType, modelId) {
 export function openAiAdapterApiProtocol(modelId, providerType) {
     const id = modelId.trim();
     return (providerType === 'deepseek' && deepSeekModelSupportsResponses(id)) ||
-        (providerType === 'opencode-go' && id === 'muse-spark-1.2-contributor') ||
+        (providerType === 'opencode-go' &&
+            (id === 'muse-spark-1.2-contributor' || id === 'muse-spark-1.3-contributor')) ||
         ((providerType === 'alibaba-token-plan-cn' || providerType === 'alibaba-token-plan') &&
             id === 'qwen3.8-max') ||
         /^gpt-[56]/i.test(id) ||

package/node_modules/@maka/core/dist/redaction.js

@@ -36,7 +36,15 @@ const AWS_CONFIG_SECRET_KEY_SOURCE = posixContinuedTokenSource('aws_secret_acces
 const AWS_SECRET_ACCESS_KEY_FLAG_SOURCE = posixContinuedTokenSource('--secret-access-key');
 const AWS_SECRET_ACCESS_KEY_ENV_SOURCE = posixContinuedTokenSource('AWS_SECRET_ACCESS_KEY');
 const QUOTED_SECRET_KEY_VALUE_PATTERN = /((?:"([^"\\]+)"\s*:\s*"))(?:\\.|[^"\\])*/g;
-const ASSIGNED_SECRET_KEY_VALUE_PATTERN = /\b(([A-Za-z][A-Za-z0-9_-]*)(?:[ \t]|\\\r?\n)*[:=](?:[ \t]|\\\r?\n)*['"]?)(?:\\\r?\n|[^\s"'&<>])+/g;
+// The prefix lookahead and the value pattern share this source, so the sticky
+// value pattern always matches where a prefix ends.
+const ASSIGNED_SECRET_VALUE_CHARACTER_SOURCE = `${POSIX_LINE_CONTINUATION_SOURCE}|[^\\s"'&<>]`;
+// The prefix matches a whole key-character run once, and the key starts at the
+// run's first word-initial letter. Trying each such letter as its own start
+// would rescan a long hyphenated run (base64url) once per hyphen.
+const ASSIGNED_SECRET_PREFIX_PATTERN = new RegExp(`(?<![A-Za-z0-9_-])([A-Za-z0-9_-]+)${OPTIONAL_SHELL_SEPARATOR_SOURCE}[:=]${OPTIONAL_SHELL_SEPARATOR_SOURCE}['"]?(?=${ASSIGNED_SECRET_VALUE_CHARACTER_SOURCE})`, 'g');
+const ASSIGNED_SECRET_KEY_PATTERN = /(?<![A-Za-z0-9_])[A-Za-z][A-Za-z0-9_-]*/;
+const ASSIGNED_SECRET_VALUE_PATTERN = new RegExp(`(?:${ASSIGNED_SECRET_VALUE_CHARACTER_SOURCE})+`, 'y');
 const AUTHORIZATION_HEADER_PATTERN = /(^|[^A-Za-z0-9_])(['"]?(?:proxy[-_]?authorization|authorization)['"]?\s*:\s*['"]?(?:bearer|basic|token)\s+)[^\s"'<>]+/gim;
 const AWS_CLI_SPACE_SECRET_PATTERN = new RegExp(`(^|[\\s;&|()])((?:aws${SHELL_SEPARATOR_SOURCE}configure${SHELL_SEPARATOR_SOURCE}set${SHELL_SEPARATOR_SOURCE}${AWS_CONFIG_SECRET_KEY_SOURCE}|${AWS_SECRET_ACCESS_KEY_FLAG_SOURCE})${SHELL_SEPARATOR_SOURCE})${SHELL_SECRET_TOKEN_SOURCE}`, 'gm');
 const AWS_SECRET_ASSIGNMENT_PATTERN = new RegExp(`\\b(${AWS_SECRET_ACCESS_KEY_ENV_SOURCE}${OPTIONAL_SHELL_SEPARATOR_SOURCE}[:=]${OPTIONAL_SHELL_SEPARATOR_SOURCE}['"]?)(?:${POSIX_LINE_CONTINUATION_SOURCE}|[^\\s"'&<>])+`, 'gi');
@@ -59,7 +67,7 @@ function redactTextSecrets(value) {
     next = next.replace(AUTHORIZATION_HEADER_PATTERN, (_match, boundary, prefix) => `${boundary}${prefix}[redacted]`);
     next = next.replace(AWS_CLI_SPACE_SECRET_PATTERN, (_match, boundary, prefix, token) => `${boundary}${prefix}${redactShellToken(token)}`);
     next = next.replace(AWS_SECRET_ASSIGNMENT_PATTERN, (_match, prefix) => `${prefix}[redacted]`);
-    next = next.replace(ASSIGNED_SECRET_KEY_VALUE_PATTERN, (match, prefix, key) => isAssignmentSensitiveKey(key) ? `${prefix}[redacted]` : match);
+    next = redactAssignedSecrets(next);
     for (const pattern of SECRET_PATTERNS) {
         // Each pattern's single capture group matches only the secret token, so the
         // replacement is always the full redaction marker. Never echo any part of
@@ -69,6 +77,34 @@ function redactTextSecrets(value) {
     }
     return next;
 }
+function redactAssignedSecrets(value) {
+    let next = '';
+    let copied = 0;
+    ASSIGNED_SECRET_PREFIX_PATTERN.lastIndex = 0;
+    for (let match = ASSIGNED_SECRET_PREFIX_PATTERN.exec(value); match; match = ASSIGNED_SECRET_PREFIX_PATTERN.exec(value)) {
+        // The prefix stops where the value starts, so every value is still searched
+        // for a nested sensitive assignment (`excerpt: password=…`). This includes a
+        // redacted value: a key with an empty value takes the next `KEY=` as its
+        // value (`token= password="…"`), and that key's own value follows the quote.
+        const key = ASSIGNED_SECRET_KEY_PATTERN.exec(match[1] ?? '')?.[0] ?? '';
+        if (!isAssignmentSensitiveKey(key))
+            continue;
+        const valueStart = ASSIGNED_SECRET_PREFIX_PATTERN.lastIndex;
+        // A value that starts inside the last redacted value ends with it.
+        if (valueStart < copied)
+            continue;
+        ASSIGNED_SECRET_VALUE_PATTERN.lastIndex = valueStart;
+        const valueMatch = ASSIGNED_SECRET_VALUE_PATTERN.exec(value);
+        // The prefix lookahead promises a value here. Should the two patterns ever
+        // disagree, skip: a failed sticky match resets lastIndex, and copying from
+        // there would echo the value after its marker.
+        if (!valueMatch)
+            continue;
+        next += `${value.slice(copied, valueStart)}[redacted]`;
+        copied = valueStart + valueMatch[0].length;
+    }
+    return next + value.slice(copied);
+}
 function posixContinuedTokenSource(token) {
     return [...token]
         .map((character) => escapeRegExpLiteral(character))
@@ -173,9 +209,12 @@ export function isSensitiveKey(key) {
     return qualifiedKey === 'service_account_key' || qualifiedKey === 'secret_access_key';
 }
 function sensitiveKeySegments(key) {
+    // The second split marks one capital per step, which keeps a long uppercase
+    // run (zero-filled base64) linear; `([A-Z]+)([A-Z][a-z])` backtracks through
+    // the run from every capital.
     return key
         .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/([A-Z])(?=[A-Z][a-z])/g, '$1 ')
         .toLowerCase()
         .split(/[^a-z0-9]+/)
         .filter(Boolean);