@adhdev/daemon-standalone 1.0.45-rc.6 → 1.0.45-rc.7

package/dist/index.js

@@ -36227,6 +36227,7 @@ var require_dist3 = __commonJS({
     function normalizeMeshSchedulingStrategy(value) {
       if (typeof value !== "string") return DEFAULT_MESH_SCHEDULING_STRATEGY;
       const trimmed = value.trim();
+      if (trimmed === "least_loaded" || trimmed === "round_robin") return "fitness";
       return MESH_SCHEDULING_STRATEGIES.includes(trimmed) ? trimmed : DEFAULT_MESH_SCHEDULING_STRATEGY;
     }
     function resolveNodeSchedulingPriority(nodePolicy) {
@@ -36239,12 +36240,14 @@ var require_dist3 = __commonJS({
     function resolveQuotaRoutingPolicy(value) {
       const staleAfterMs = Number(value?.staleAfterMs);
       const sessionMin = Number(value?.sessionMinRemainingPercent);
+      const sessionResetImminentMs = Number(value?.sessionResetImminentMs);
       const weeklyMin = Number(value?.weeklyMinRemainingPercent);
       const spreadMax = Number(value?.spreadBonusMax);
       const clampPercentField = (n, fallback) => Number.isFinite(n) ? Math.min(100, Math.max(0, n)) : fallback;
       return {
         staleAfterMs: Number.isFinite(staleAfterMs) && staleAfterMs >= 0 ? Math.floor(staleAfterMs) : DEFAULT_QUOTA_ROUTING_POLICY.staleAfterMs,
         sessionMinRemainingPercent: clampPercentField(sessionMin, DEFAULT_QUOTA_ROUTING_POLICY.sessionMinRemainingPercent),
+        sessionResetImminentMs: Number.isFinite(sessionResetImminentMs) && sessionResetImminentMs >= 0 ? Math.floor(sessionResetImminentMs) : DEFAULT_QUOTA_ROUTING_POLICY.sessionResetImminentMs,
         weeklyMinRemainingPercent: clampPercentField(weeklyMin, DEFAULT_QUOTA_ROUTING_POLICY.weeklyMinRemainingPercent),
         spreadBonusMax: Number.isFinite(spreadMax) && spreadMax >= 0 ? spreadMax : DEFAULT_QUOTA_ROUTING_POLICY.spreadBonusMax
       };
@@ -36260,6 +36263,9 @@ var require_dist3 = __commonJS({
       if (record2.sessionMinRemainingPercent !== void 0 && resolved.sessionMinRemainingPercent !== DEFAULT_QUOTA_ROUTING_POLICY.sessionMinRemainingPercent) {
         out.sessionMinRemainingPercent = resolved.sessionMinRemainingPercent;
       }
+      if (record2.sessionResetImminentMs !== void 0 && resolved.sessionResetImminentMs !== DEFAULT_QUOTA_ROUTING_POLICY.sessionResetImminentMs) {
+        out.sessionResetImminentMs = resolved.sessionResetImminentMs;
+      }
       if (record2.weeklyMinRemainingPercent !== void 0 && resolved.weeklyMinRemainingPercent !== DEFAULT_QUOTA_ROUTING_POLICY.weeklyMinRemainingPercent) {
         out.weeklyMinRemainingPercent = resolved.weeklyMinRemainingPercent;
       }
@@ -36499,6 +36505,7 @@ var require_dist3 = __commonJS({
         DEFAULT_QUOTA_ROUTING_POLICY = {
           staleAfterMs: 30 * 60 * 1e3,
           sessionMinRemainingPercent: 10,
+          sessionResetImminentMs: 5 * 60 * 1e3,
           weeklyMinRemainingPercent: 15,
           spreadBonusMax: 30
         };
@@ -37020,10 +37027,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "ad6b5dfbb762ac45467586208d4393788832ad7a" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "ad6b5dfb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.45-rc.6" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-12T05:35:42.422Z" : void 0);
+      const commit = readInjected(true ? "c935da6be0da24d1e046a4ecb5139e8490dba7b4" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "c935da6b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.45-rc.7" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-12T10:49:30.678Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -42162,6 +42169,7 @@ ${error48.message || ""}`;
       buildSlotProposal: () => buildSlotProposal,
       canonicalDaemonId: () => canonicalDaemonId,
       daemonIdsEquivalent: () => daemonIdsEquivalent,
+      deriveProviderPriorityFromSlots: () => deriveProviderPriorityFromSlots,
       deriveSlotsFromLegacy: () => deriveSlotsFromLegacy,
       expandDaemonIdForms: () => expandDaemonIdForms,
       formatQuotaAccount: () => formatQuotaAccount,
@@ -42626,6 +42634,16 @@ ${error48.message || ""}`;
         };
       });
     }
+    function deriveProviderPriorityFromSlots(slots) {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const slot of normalizeNodeCapabilitySlots(slots)) {
+        if (seen.has(slot.provider)) continue;
+        seen.add(slot.provider);
+        out.push(slot.provider);
+      }
+      return out;
+    }
     function slotKey(slot) {
       return [
         slot.provider,
@@ -48572,11 +48590,12 @@ Next step: ${nextStep}`;
                 ON mesh_missions(mesh_id, status, updated_at);
 
             -- Load-balancing scheduler: per-mesh round-robin rotation cursor. When
-            -- the schedulingStrategy is 'round_robin', several eligible nodes tied at
-            -- the least load are rotated by this cursor so the tie-break winner cycles
-            -- across scheduling passes instead of always favouring the same array-order
-            -- node. Persisted (not a module Map) so rotation survives daemon restarts
-            -- and stays a single source of truth across scheduling entry points.
+            -- the schedulingStrategy spreads work ('fitness' with no task in scope),
+            -- eligible nodes tied at the same (priority, load) are rotated by this
+            -- cursor so the tie-break winner cycles across scheduling passes instead
+            -- of always favouring the same array-order node. Persisted (not a module
+            -- Map) so rotation survives daemon restarts and stays a single source of
+            -- truth across scheduling entry points.
             CREATE TABLE IF NOT EXISTS mesh_scheduler_cursor (
                 mesh_id TEXT PRIMARY KEY,
                 cursor INTEGER NOT NULL DEFAULT 0
@@ -55243,13 +55262,16 @@ ${rendered}`, "utf-8");
     function readProviderPriorityFromPolicy(policy) {
       const record2 = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
       const raw = record2.providerPriority;
-      if (!Array.isArray(raw)) return [];
-      const seen = /* @__PURE__ */ new Set();
-      return raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
-        if (seen.has(type2)) return false;
-        seen.add(type2);
-        return true;
-      });
+      if (Array.isArray(raw)) {
+        const seen = /* @__PURE__ */ new Set();
+        const explicit = raw.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean).filter((type2) => {
+          if (seen.has(type2)) return false;
+          seen.add(type2);
+          return true;
+        });
+        if (explicit.length) return explicit;
+      }
+      return deriveProviderPriorityFromSlots(record2.slots);
     }
     function normalizeProviderRoles(value) {
       if (!Array.isArray(value)) return [];
@@ -60480,6 +60502,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!Number.isFinite(used)) return void 0;
       return Math.min(100, Math.max(0, 100 - used));
     }
+    function isSessionResetImminent(session, facts, quota, imminentMs, now) {
+      const resetsAt = Number(session?.resetsAt);
+      if (!Number.isFinite(resetsAt) || resetsAt <= 0) return false;
+      const ageMs2 = quotaSnapshotAgeMs(facts, quota, now);
+      if (!Number.isFinite(ageMs2)) return false;
+      const reporterNowMs = Number(quota.updatedAt) + ageMs2;
+      return resetsAt - reporterNowMs < imminentMs;
+    }
     function evaluateProviderQuotaGate(node, providerType, policy, now = Date.now()) {
       const entry = quotaEntryFor(node, providerType);
       if (!entry) return null;
@@ -60488,7 +60518,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!isQuotaSnapshotFresh(facts, quota, policy, now)) return null;
       const resolved = resolveQuotaRoutingPolicy(policy);
       const session = remainingPercent(quota.session);
-      if (session !== void 0 && session < resolved.sessionMinRemainingPercent) {
+      if (session !== void 0 && session < resolved.sessionMinRemainingPercent && !isSessionResetImminent(quota.session, facts, quota, resolved.sessionResetImminentMs, now)) {
         return {
           reason: PROVIDER_QUOTA_SESSION_LOW_SKIP_REASON,
           window: "session",
@@ -61228,7 +61258,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       const priorityOf = (n) => resolveNodeSchedulingPriority(n.node?.policy);
       let rotation = 0;
-      if (strategy === "least_loaded" || strategy === "round_robin") {
+      if (strategy === "fitness") {
         const cursor = opts?.bumpCursor ? MeshRuntimeStore.getInstance().bumpSchedulerCursor(meshId) : MeshRuntimeStore.getInstance().getSchedulerCursor(meshId);
         rotation = (cursor % nodes.length + nodes.length) % nodes.length;
       }
@@ -61236,7 +61266,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       return [...nodes].sort((a, b) => {
         const prioDelta = priorityOf(b) - priorityOf(a);
         if (prioDelta !== 0) return prioDelta;
-        if (strategy === "least_loaded" || strategy === "round_robin") {
+        if (strategy === "fitness") {
           const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
           if (loadDelta !== 0) return loadDelta;
         }
@@ -61610,6 +61640,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
         return false;
       }
+      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null);
+      if (quotaClaimBlock) {
+        LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' has ${quotaClaimBlock.remainingPercent.toFixed(1)}% ${quotaClaimBlock.window} quota remaining (< ${quotaClaimBlock.thresholdPercent}% threshold) \u2014 task left pending until the window resets`);
+        return false;
+      }
       const inlineBootstrapNode = (() => {
         try {
           const inlineMesh = components.router?.getCachedInlineMesh?.(meshId);
@@ -62604,7 +62639,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             const aPrio = resolveNodeSchedulingPriority(a.node?.policy);
             const bPrio = resolveNodeSchedulingPriority(b.node?.policy);
             if (aPrio !== bPrio) return bPrio - aPrio;
-            if (strategy === "least_loaded" || strategy === "round_robin" || strategy === "fitness") {
+            if (strategy === "fitness") {
               const loadDelta = nodeActiveLoad(meshId, a.nodeId) - nodeActiveLoad(meshId, b.nodeId);
               if (loadDelta !== 0) return loadDelta;
             }
@@ -109324,6 +109359,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       if (await isAncestor2(worktreeOssSha, sourceSha)) return "advance";
       return "skip_diverged";
     }
+    function syncProviderPriorityFromSlots(policy, slots = policy.slots) {
+      const derived = deriveProviderPriorityFromSlots(slots);
+      if (derived.length) policy.providerPriority = derived;
+    }
     async function syncClonedWorktreeSubmodules(worktreePath, sourceWorkspace, rg) {
       const submodulePaths = getRegisteredSubmodulePaths(worktreePath);
       if (submodulePaths.size === 0) return;
@@ -109887,12 +109926,15 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
           const providerPriority = Array.isArray(args?.providerPriority) ? args.providerPriority.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean) : [];
           const readOnly = args?.readOnly === true;
           const providerRoles = normalizeProviderRoles(args?.providerRoles);
+          const slots = normalizeNodeCapabilitySlots(args?.slots);
           const policy = {
             ...readOnly ? { readOnly: true } : {},
             ...providerPriority.length ? { providerPriority } : {},
-            ...providerRoles.length ? { providerRoles } : {}
+            ...providerRoles.length ? { providerRoles } : {},
+            ...slots.length ? { slots } : {}
           };
           if (providerRoles.length) migrateProviderRolesToSlots2(policy);
+          if (!providerPriority.length) syncProviderPriorityFromSlots(policy);
           const role = normalizeMeshDaemonRole(args?.role);
           const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
           const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
@@ -109927,7 +109969,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, "node update");
         if (ownerFailure) return ownerFailure;
         try {
-          const { updateNode: updateNode2, normalizeCapabilityTags: normalizeCapabilityTags2, migrateProviderRolesToSlots: migrateProviderRolesToSlots2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const { updateNode: updateNode2, normalizeCapabilityTags: normalizeCapabilityTags2, migrateProviderRolesToSlots: migrateProviderRolesToSlots2, getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
           const policy = args?.policy && typeof args.policy === "object" && !Array.isArray(args.policy) ? { ...args.policy } : {};
           if (Array.isArray(args?.providerPriority)) {
             const providerPriority = args.providerPriority.map((type2) => typeof type2 === "string" ? type2.trim() : "").filter(Boolean);
@@ -109944,6 +109986,10 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             else delete policy.providerRoles;
           }
           migrateProviderRolesToSlots2(policy);
+          if (!Array.isArray(args?.providerPriority) && !Object.prototype.hasOwnProperty.call(policy, "providerPriority")) {
+            const finalSlots = Object.prototype.hasOwnProperty.call(policy, "slots") ? policy.slots : getMesh2(meshId)?.nodes.find((n) => n.id === nodeId)?.policy?.slots;
+            syncProviderPriorityFromSlots(policy, finalSlots);
+          }
           const patch = { policy };
           if (typeof args?.systemPrompt === "string") {
             const trimmed = args.systemPrompt.trim();
@@ -109968,6 +110014,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             ...inlineNode.policy && typeof inlineNode.policy === "object" && !Array.isArray(inlineNode.policy) ? inlineNode.policy : {},
             ...patch.policy
           };
+          if (!Array.isArray(args?.providerPriority) && !Object.prototype.hasOwnProperty.call(patch.policy, "providerPriority")) {
+            syncProviderPriorityFromSlots(inlineNode.policy);
+          }
           if (Object.prototype.hasOwnProperty.call(patch, "systemPrompt")) {
             const sp = patch.systemPrompt;
             if (typeof sp === "string" && sp.trim()) inlineNode.systemPrompt = sp;