@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/{channel-worker-group-LFBT7K64.js → channel-worker-group-2ZD7TVAT.js}

@@ -3,15 +3,16 @@
 import {
   ChannelWorkerReconcileError,
   createChannelWorkerGroup
-} from "./chunk-KQQ757OQ.js";
-import "./chunk-D7WXIW7H.js";
-import "./chunk-QKTHJXCS.js";
-import "./chunk-TJTKSVIV.js";
+} from "./chunk-UDX5OBWR.js";
+import "./chunk-5NBDS5S6.js";
+import "./chunk-LK7CHLVP.js";
+import "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RVLZCXEE.js";
+import "./chunk-RWTEFFPU.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-T4TZQJ7W.js";
+import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";

package/chunks/{channel-worker-manager-3RUPERG2.js → channel-worker-manager-4OA4BCGB.js}

@@ -2,20 +2,22 @@
 "use strict";
 import {
   ChannelWorkerReconcileError
-} from "./chunk-KQQ757OQ.js";
+} from "./chunk-UDX5OBWR.js";
 import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError
-} from "./chunk-D7WXIW7H.js";
+} from "./chunk-5NBDS5S6.js";
 import {
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-QKTHJXCS.js";
-import "./chunk-TJTKSVIV.js";
+} from "./chunk-LK7CHLVP.js";
+import "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RVLZCXEE.js";
+import "./chunk-RWTEFFPU.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-T4TZQJ7W.js";
+import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import {
   init_esbuild_shims
@@ -56,6 +58,13 @@ function cloneSelection(selection) {
   return selection.mode === "all" ? { mode: "all" } : { mode: "names", names: [...selection.names] };
 }
 __name(cloneSelection, "cloneSelection");
+function cloneGroups(groups) {
+  return groups.map((group) => ({
+    workspaceCwd: group.workspaceCwd,
+    selection: cloneSelection(group.selection)
+  }));
+}
+__name(cloneGroups, "cloneGroups");
 function selectionsEqual(left, right) {
   if (!left || left.mode !== right.mode) return false;
   if (left.mode === "all") return true;
@@ -73,6 +82,22 @@ function isPartial(workers) {
   });
 }
 __name(isPartial, "isPartial");
+function groupIncludesName(group, name) {
+  return group.selection.mode === "all" || group.selection.names.includes(name);
+}
+__name(groupIncludesName, "groupIncludesName");
+function assertRequiredOwner(targetGroups, requiredOwner) {
+  const owners = targetGroups.filter(
+    (target) => groupIncludesName(target, requiredOwner.name)
+  );
+  if (owners.length !== 1 || owners[0].workspaceCwd !== requiredOwner.workspaceCwd) {
+    throw new ChannelWorkerControlError(
+      "channel_runtime_owner_mismatch",
+      `Channel "${requiredOwner.name}" does not resolve to workspace "${requiredOwner.workspaceCwd}".`
+    );
+  }
+}
+__name(assertRequiredOwner, "assertRequiredOwner");
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -89,6 +114,7 @@ function startupFailureDetails(error) {
 __name(startupFailureDetails, "startupFailureDetails");
 function createChannelWorkerManager(opts) {
   let committedSelection;
+  let committedGroups = [];
   let pendingSelection;
   let transition = "idle";
   let group;
@@ -136,6 +162,7 @@ function createChannelWorkerManager(opts) {
   }, "setTransition");
   const commit = /* @__PURE__ */ __name((selection, groups) => {
     committedSelection = selection ? cloneSelection(selection) : void 0;
+    committedGroups = cloneGroups(groups);
     transition = "idle";
     pendingSelection = void 0;
     opts.onCommittedSelection?.(committedSelection, groups);
@@ -159,7 +186,7 @@ function createChannelWorkerManager(opts) {
       startupFailureDetails(error)
     );
   }, "classifyFailure");
-  const applySelection = /* @__PURE__ */ __name(async (selection, initial) => {
+  const applySelection = /* @__PURE__ */ __name(async (selection, initial, resolvedGroups) => {
     if (hardKilled) throw drainingError();
     const enabling = !snapshot().enabled;
     const replacing = committedSelection !== void 0;
@@ -176,10 +203,7 @@ function createChannelWorkerManager(opts) {
     setTransition(replacing ? "reconciling" : "starting", selection);
     let targetGroups;
     try {
-      targetGroups = await opts.resolveGroups(
-        selection,
-        initial ? "initial" : "set"
-      );
+      targetGroups = resolvedGroups ?? await opts.resolveGroups(selection, initial ? "initial" : "set");
       if (hardKilled) throw drainingError();
       reserve(selection);
     } catch (error) {
@@ -268,6 +292,51 @@ function createChannelWorkerManager(opts) {
       throw classifyFailure(error, "channel_worker_start_failed");
     }
   }, "applySelection");
+  const committedChannelNames = /* @__PURE__ */ __name(() => {
+    if (!committedSelection) return [];
+    if (committedSelection.mode === "names") {
+      return [...committedSelection.names];
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const worker of group?.snapshots() ?? []) {
+      for (const name of worker.requestedChannels ?? worker.channels) {
+        names.add(name);
+      }
+    }
+    return [...names];
+  }, "committedChannelNames");
+  const assertCommittedOwner = /* @__PURE__ */ __name((requiredOwner) => {
+    const owners = (group?.snapshots() ?? []).filter(
+      (worker) => worker.adapters?.some(
+        (adapter) => adapter.name === requiredOwner.name
+      ) || worker.requestedChannels?.includes(requiredOwner.name) || worker.channels.includes(requiredOwner.name)
+    );
+    if (owners.length !== 1 || owners[0].workspaceCwd !== requiredOwner.workspaceCwd) {
+      throw new ChannelWorkerControlError(
+        "channel_runtime_owner_mismatch",
+        `Channel "${requiredOwner.name}" does not have one confirmed runtime owner in workspace "${requiredOwner.workspaceCwd}".`
+      );
+    }
+  }, "assertCommittedOwner");
+  const stopSelectionNow = /* @__PURE__ */ __name(async () => {
+    const hadState = group !== void 0 || leaseReserved;
+    if (!hadState) {
+      return { changed: false, state: snapshot() };
+    }
+    setTransition("stopping");
+    try {
+      if (group) {
+        await group.stop();
+        group = void 0;
+      }
+      release();
+    } catch (error) {
+      setTransition("idle");
+      throw classifyFailure(error, "channel_worker_stop_failed");
+    }
+    commit(void 0, []);
+    return { changed: hadState, state: snapshot() };
+  }, "stopSelectionNow");
   const manager = {
     async startInitial(selection) {
       if (draining) throw drainingError();
@@ -275,36 +344,58 @@ function createChannelWorkerManager(opts) {
         await applySelection(selection, true);
       });
     },
-    setSelection(selection) {
+    setSelection(selection, requiredOwner) {
       if (draining) {
         return Promise.reject(drainingError());
       }
-      return enqueue(() => applySelection(selection, false));
+      return enqueue(async () => {
+        if (!requiredOwner) return applySelection(selection, false);
+        const targetGroups = await opts.resolveGroups(selection, "set");
+        assertRequiredOwner(targetGroups, requiredOwner);
+        if (hardKilled) throw drainingError();
+        return applySelection(selection, false, targetGroups);
+      });
     },
-    stopSelection() {
+    setChannelEnabled(owner, enabled) {
       if (draining) {
         return Promise.reject(drainingError());
       }
       return enqueue(async () => {
-        const hadState = group !== void 0 || leaseReserved;
-        if (!hadState) {
-          return { changed: false, state: snapshot() };
-        }
-        setTransition("stopping");
-        try {
-          if (group) {
-            await group.stop();
-            group = void 0;
+        const committedNames = committedChannelNames();
+        const currentlyEnabled = committedNames.includes(owner.name);
+        if (currentlyEnabled) assertCommittedOwner(owner);
+        if (enabled) {
+          if (currentlyEnabled) {
+            return {
+              changed: false,
+              replaced: false,
+              partial: isPartial(group?.snapshots() ?? []),
+              state: snapshot(),
+              created: false
+            };
           }
-          release();
-        } catch (error) {
-          setTransition("idle");
-          throw classifyFailure(error, "channel_worker_stop_failed");
+          const selection = {
+            mode: "names",
+            names: [...committedNames, owner.name]
+          };
+          const targetGroups = await opts.resolveGroups(selection, "set");
+          assertRequiredOwner(targetGroups, owner);
+          if (hardKilled) throw drainingError();
+          return applySelection(selection, false, targetGroups);
         }
-        commit(void 0, []);
-        return { changed: hadState, state: snapshot() };
+        if (!currentlyEnabled) {
+          return { changed: false, state: snapshot() };
+        }
+        const names = committedNames.filter((name) => name !== owner.name);
+        return names.length === 0 ? stopSelectionNow() : applySelection({ mode: "names", names }, false);
       });
     },
+    stopSelection() {
+      if (draining) {
+        return Promise.reject(drainingError());
+      }
+      return enqueue(stopSelectionNow);
+    },
     reload() {
       if (draining) {
         return Promise.reject(drainingError());
@@ -339,9 +430,67 @@ function createChannelWorkerManager(opts) {
         return snapshots.find((worker) => worker.primary) ?? snapshots[0] ?? { ...DISABLED_SNAPSHOT };
       });
     },
+    reloadWorkspace(workspaceCwd, name) {
+      if (draining) {
+        return Promise.reject(drainingError());
+      }
+      return enqueue(async () => {
+        if (!group || !committedSelection) {
+          throw new ChannelWorkerControlError(
+            "channel_worker_not_enabled",
+            "This daemon has no channel worker to reload."
+          );
+        }
+        setTransition("reconciling", committedSelection);
+        let targetGroups;
+        try {
+          targetGroups = await opts.resolveGroups(committedSelection, "reload");
+          assertRequiredOwner(targetGroups, { name, workspaceCwd });
+          if (targetGroups.filter(
+            (target) => target.workspaceCwd === workspaceCwd
+          ).length !== 1 || committedGroups.filter(
+            (target) => target.workspaceCwd === workspaceCwd
+          ).length !== 1) {
+            throw new ChannelWorkerControlError(
+              "channel_runtime_owner_mismatch",
+              `Workspace "${workspaceCwd}" does not own a committed channel worker.`
+            );
+          }
+        } catch (error) {
+          setTransition("idle");
+          throw error;
+        }
+        if (hardKilled) throw drainingError();
+        try {
+          await group.reconcile(targetGroups, {
+            forceWorkspaceCwd: workspaceCwd,
+            onRollingBack: /* @__PURE__ */ __name(() => setTransition("rolling_back", committedSelection), "onRollingBack")
+          });
+        } catch (error) {
+          setTransition("idle");
+          throw classifyFailure(error, "channel_worker_start_failed");
+        }
+        const targetGroup = targetGroups.find(
+          (target) => target.workspaceCwd === workspaceCwd
+        );
+        const nextCommittedGroups = committedGroups.map(
+          (committedGroup) => committedGroup.workspaceCwd === workspaceCwd ? targetGroup : committedGroup
+        );
+        commit(committedSelection, nextCommittedGroups);
+        const worker = group.snapshots().find((snapshot2) => snapshot2.workspaceCwd === workspaceCwd);
+        if (!worker) {
+          throw new ChannelWorkerControlError(
+            "channel_runtime_owner_mismatch",
+            `Workspace "${workspaceCwd}" has no channel worker after reload.`
+          );
+        }
+        return worker;
+      });
+    },
     state: snapshot,
     primarySnapshot: /* @__PURE__ */ __name(() => group?.primarySnapshot() ?? { ...DISABLED_SNAPSHOT }, "primarySnapshot"),
     snapshots: /* @__PURE__ */ __name(() => group?.snapshots() ?? [], "snapshots"),
+    committedChannelNames,
     enqueueWebhookTask(task) {
       if (!group || draining) {
         return Promise.reject(
@@ -353,6 +502,17 @@ function createChannelWorkerManager(opts) {
       }
       return group.enqueueWebhookTask(task);
     },
+    deliverChannelMessage(workspaceCwd, request) {
+      if (!group || draining) {
+        return Promise.reject(
+          new ChannelDeliveryError(
+            "channel_worker_unavailable",
+            draining ? "Daemon is shutting down." : "Channel worker is not running."
+          )
+        );
+      }
+      return group.deliverChannelMessage(request, workspaceCwd);
+    },
     beginWorkspaceDrain(workspaceCwd) {
       workspaceDrains.add(workspaceCwd);
       group?.beginWorkspaceDrain(workspaceCwd);

package/chunks/{channel-worker-supervisor-A3KVATD3.js → channel-worker-supervisor-V7KCFJTS.js}

@@ -4,14 +4,15 @@ import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
   createChannelWorkerSupervisor
-} from "./chunk-D7WXIW7H.js";
-import "./chunk-QKTHJXCS.js";
-import "./chunk-TJTKSVIV.js";
+} from "./chunk-5NBDS5S6.js";
+import "./chunk-LK7CHLVP.js";
+import "./chunk-JLU636DO.js";
+import "./chunk-BK2UNYWD.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-RVLZCXEE.js";
+import "./chunk-RWTEFFPU.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-T4TZQJ7W.js";
+import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";