npm - @adhdev/daemon-standalone - Versions diffs - 1.0.45-rc.8 → 1.0.47 - Mend

@adhdev/daemon-standalone 1.0.45-rc.8 → 1.0.47

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/index.js +1887 -1240
package/dist/index.js.map +1 -1
package/package.json +2 -2
package/public/assets/index-CEPCfMWL.css +1 -0
package/public/assets/index-D3K4NyAl.js +116 -0
package/public/index.html +2 -2
package/vendor/mcp-server/index.js +89 -9
package/vendor/mcp-server/index.js.map +1 -1
package/public/assets/index-CH6cVfIs.js +0 -116
package/public/assets/index-TrEtD2r5.css +0 -1

package/public/index.html CHANGED Viewed

@@ -7,9 +7,9 @@
     <meta name="description" content="ADHDev self-hosted dashboard for controlling AI agents" />
     <link rel="icon" href="/otter-logo.png" />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/assets/index-CH6cVfIs.js"></script>
+  <script type="module" crossorigin src="/assets/index-D3K4NyAl.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-DgFmqOGd.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-TrEtD2r5.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-CEPCfMWL.css">
 </head>
 <body>
     <!-- Apply theme immediately to prevent FOIT (Flash of Incorrect Theme) -->

package/vendor/mcp-server/index.js CHANGED Viewed

@@ -996,7 +996,7 @@ var MESH_ENQUEUE_TASK_TOOL = {
       priority: { type: "string", enum: ["low", "normal", "high"], description: "G6 (task-level scheduling priority). Within the claim tier a high task is pulled ahead of an older normal/low task (created_at is the tie-break); low is pulled last. Defaults to normal. This is the TASK priority (which task a node pulls first) \u2014 distinct from a node's schedulingPriority (which node work goes to). Use high to jump an urgent fix ahead of a backlog without cancelling the queue." },
       model: { type: "string", description: "Optional model override for the agent that runs this task, e.g. opus, sonnet, haiku. Best-effort: applied at launch for providers that support a model flag (claude-cli --model, ACP setConfigOption); ignored by providers that cannot honor it. Use a cheaper model for simple tasks to save tokens, a stronger one for hard work. Blank = the provider default." },
       thinkingLevel: { type: "string", enum: ["low", "medium", "high"], description: "Optional reasoning-effort level for this task. Best-effort: applied at launch for providers that support it (claude-cli --effort, codex-cli reasoning effort, ACP thought_level); ignored otherwise. Use low for simple tasks (fewer tokens), high for hard reasoning." },
-      difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "Optional task execution difficulty \u2014 a ROUTING HINT, not a model selector. It is matched against each node's capability slots so the task lands on a slot configured for that difficulty, and THAT SLOT's own model + thinkingLevel are what launch. It does not by itself mean a cheaper or stronger model: to change what a difficulty runs on, edit the node's slots (mesh_node_slots_set) rather than picking a different difficulty. Classify each task by how hard the work actually is. An explicit model/thinkingLevel above always wins." },
+      difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "REQUIRED task execution difficulty \u2014 a ROUTING HINT, not a model selector. It is matched against each node's capability slots so the task lands on a slot configured for that difficulty, and THAT SLOT's own model + thinkingLevel are what launch. It does not by itself mean a cheaper or stronger model: to change what a difficulty runs on, edit the node's slots (mesh_node_slots_set) rather than picking a different difficulty. Classify each task by how hard the work actually is. An explicit model/thinkingLevel above always wins." },
       notBefore: { type: "number", description: "CamelCase alias for not_before. Also accepts an ISO-8601 timestamp string." },
       max_retries: { type: "number", description: "P3 (retry cap). Max automatic requeue attempts before the task auto-fails instead of returning to pending. When requeueCount reaches this, mesh_queue_requeue auto-fails the task unless force=true. Omit to use the mesh policy default (maxTaskRetries, typically 1)." },
       maxRetries: { type: "number", description: "CamelCase alias for max_retries." },
@@ -1005,7 +1005,7 @@ var MESH_ENQUEUE_TASK_TOOL = {
       allow_duplicate: { type: "boolean", description: "G4. Set true to skip duplicate detection entirely (no warning, no block) for an intentional re-enqueue of the same instruction." },
       allowDuplicate: { type: "boolean", description: "CamelCase alias for allow_duplicate." }
     },
-    required: ["message"]
+    required: ["message", "difficulty"]
   }
 };
 var MESH_VIEW_QUEUE_TOOL = {
@@ -1072,9 +1072,10 @@ var MESH_SEND_TASK_TOOL = {
       readonly: { type: "boolean", description: "Optional read-only axis (orthogonal to task_mode). When true the task runs without write isolation, is counted under the read-only cap, and rejects write/commit/push/deploy/destructive instructions like live_debug_readonly. Composable with any task_mode." },
       read_only: { type: "boolean", description: "Snake-case alias for readonly." },
       mission_id: { type: "string", description: "Mission this task belongs to (mesh_mission record id). When set, the directly dispatched task is attributed to the mission task aggregates exactly like mesh_enqueue_task, including terminal completion. Omit for an unattributed direct dispatch." },
-      missionId: { type: "string", description: "CamelCase alias for mission_id." }
+      missionId: { type: "string", description: "CamelCase alias for mission_id." },
+      difficulty: { type: "string", enum: ["easy", "medium", "difficult", "freeform"], description: "REQUIRED task execution difficulty. Classify each task by how hard the work actually is. On a direct dispatch the target node/session is already chosen, so difficulty is not used to ROUTE \u2014 it is recorded on the task so scheduling analytics, mission aggregates and (critically) failure-recovery relaunch all see the same axis a queued task carries. A recovery relaunch inherits this value from the ledger, so an unclassified direct dispatch would silently downgrade its own retry." }
     },
-    required: ["node_id", "session_id", "message"]
+    required: ["node_id", "session_id", "message", "difficulty"]
   }
 };
 var MESH_READ_CHAT_TOOL = {
@@ -3159,6 +3160,8 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
       cliType: resolvedProviderType,
       action: "send_chat",
       message: args.message,
+      // DISPATCH-SOURCE-TRACE: call-site tag echoed in the worker daemon log.
+      dispatchSource: "mesh-tools-internal:ipcDispatchToRemoteAgent",
       // WTCLAIM (B): carry the node workspace so a sessionless dispatch can be
       // scoped to THIS node's session on the worker (findAdapter dir match /
       // findMeshNodeAdapter). Without it, a worker hosting both a base node and a
@@ -3342,10 +3345,10 @@ async function collectRelatedRepoStatuses(ctx, node) {
   return results;
 }
 function readProviderPriority(policy) {
+  const fromSlots = deriveProviderPriorityFromSlots(policy?.slots);
+  if (fromSlots.length) return fromSlots;
   const raw = policy?.providerPriority;
-  const explicit = Array.isArray(raw) ? raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
-  if (explicit.length) return explicit;
-  return deriveProviderPriorityFromSlots(policy?.slots);
+  return Array.isArray(raw) ? raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
 }
 function readNodeSupportedProviders(policy) {
   const seen = /* @__PURE__ */ new Set();
@@ -3929,6 +3932,10 @@ async function meshStatus(ctx, args = {}) {
       const { nodeId: _omit, ...rest } = nodeScheduling;
       entry.scheduling = compact ? { load: rest.load, capReached: rest.capReached } : rest;
     }
+    const lastQuotaRanking = (0, import_daemon_core5.getLastQuotaRanking)(node.id);
+    if (lastQuotaRanking) {
+      entry.scheduling = { ...entry.scheduling ?? {}, lastQuotaRanking };
+    }
     let liveTruthProbed = false;
     try {
       const autoDiscover = node.policy?.autoDiscoverSubmodules !== false;
@@ -6236,6 +6243,22 @@ Target: ${args.target}` : ""}`,
       const task = (0, import_daemon_core5.enqueueTask)(ctx.mesh.id, prompt, {
         readonly: true,
         taskMode: "live_debug_readonly",
+        // DIFFICULTY-REQUIRED (MAGI decision): a fixed 'freeform' sentinel, NOT an
+        // exemption from the guard. MAGI routes on a different axis entirely — each
+        // replica is already hard-pinned to a (node, provider) slot by the kind-panel
+        // via requiredTags (`provider=<X>`) and often an explicit targetNodeId, and
+        // its model comes from that slot. Difficulty exists to MATCH a task against
+        // node capability slots at assignment time; here the slot is already chosen,
+        // so any difficulty we stamped would be inert at best and would fight the
+        // panel's own slot selection at worst.
+        //
+        // 'freeform' is the correct sentinel rather than a guard bypass: it is a real
+        // member of the axis meaning "no difficulty-based constraint", so the fan-out
+        // satisfies the required-difficulty invariant honestly instead of carving out
+        // a hole that a future non-MAGI caller could slip through. Deliberately NOT
+        // caller-configurable — exposing a difficulty knob on mesh_magi_review would
+        // imply it influences replica placement, which it does not.
+        difficulty: "freeform",
         requiredTags: replica.requiredTags,
         missionId: mission.id,
         consensusGroupId,
@@ -6686,6 +6709,8 @@ ${magiOutputContractFor(kind)}`;
         agentType: task.assignedProviderType,
         action: "send_chat",
         message,
+        // DISPATCH-SOURCE-TRACE: call-site tag echoed in the worker daemon log.
+        dispatchSource: "mesh-tools-magi:sendKindRetry",
         meshContext: {
           meshId: ctx.mesh.id,
           nodeId: task.assignedNodeId,
@@ -7035,6 +7060,7 @@ async function meshNodeSlotsPropose(ctx, args = {}) {
 }
 // src/tools/mesh-tools-session.ts
+var import_daemon_core7 = require("@adhdev/daemon-core");
 function computeIdleDispatchAckRisk(sessionWasIdle, dispatchPreRecorded, sessionId) {
   if (!sessionWasIdle || dispatchPreRecorded) return {};
   return {
@@ -7103,6 +7129,16 @@ async function meshSendTask(ctx, args) {
   const requestedTaskMode = readString(args.task_mode) || readString(args.taskMode);
   const readonly = args.readonly === true || args.read_only === true;
   const missionId = readString(args.missionId) || readString(args.mission_id) || void 0;
+  const difficultyRaw = readString(args.difficulty);
+  if (!difficultyRaw || !isMeshTaskDifficulty(difficultyRaw)) {
+    return JSON.stringify({
+      success: false,
+      code: difficultyRaw ? "invalid_difficulty" : "missing_difficulty",
+      error: difficultyRaw ? `mesh_send_task received an unrecognized \`difficulty\` value '${difficultyRaw}'. Allowed: ${MESH_TASK_DIFFICULTIES.join(" | ")}.` : `mesh_send_task requires a \`difficulty\`. Allowed: ${MESH_TASK_DIFFICULTIES.join(" | ")}. Classify the task by how hard the work actually is.`,
+      allowedDifficulties: MESH_TASK_DIFFICULTIES
+    });
+  }
+  const difficulty = difficultyRaw;
   const modeValidation = (0, import_daemon_core5.validateMeshTaskModeRequest)(requestedTaskMode, message, readonly);
   if (!modeValidation.valid) {
     return JSON.stringify({
@@ -7252,6 +7288,7 @@ async function meshSendTask(ctx, args) {
             assignedNodeId: args.node_id,
             assignedSessionId: dispatchedSessionId,
             taskMode,
+            difficulty,
             ...readonly ? { readonly: true } : {},
             dispatchedAt
           });
@@ -7354,6 +7391,7 @@ async function meshSendTask(ctx, args) {
             targetNodeId: args.node_id,
             targetSessionId: args.session_id,
             taskMode,
+            difficulty,
             ...readonly ? { readonly: true } : {},
             ...missionId ? { missionId } : {},
             ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
@@ -7423,6 +7461,8 @@ async function meshSendTask(ctx, args) {
         providerType: resolvedProviderType,
         action: "send_chat",
         message,
+        // DISPATCH-SOURCE-TRACE: call-site tag echoed in the worker daemon log.
+        dispatchSource: "mesh-tools-session:mesh_send_task:direct",
         meshContext: {
           meshId: ctx.mesh.id,
           nodeId: args.node_id,
@@ -7455,6 +7495,7 @@ async function meshSendTask(ctx, args) {
           assignedNodeId: args.node_id,
           assignedSessionId: args.session_id,
           taskMode,
+          difficulty,
           ...readonly ? { readonly: true } : {},
           dispatchedAt
         });
@@ -7498,6 +7539,7 @@ async function meshSendTask(ctx, args) {
       targetNodeId: args.node_id,
       targetSessionId: args.session_id,
       taskMode,
+      difficulty,
       ...readonly ? { readonly: true } : {},
       ...missionId ? { missionId } : {},
       ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
@@ -7692,6 +7734,7 @@ async function meshLaunchSession(ctx, args) {
   {
     const requestedType = typeof args.type === "string" && args.type.trim() ? args.type.trim() : "";
     let resolvedProviderType = requestedType;
+    let explicitTypeQuotaWarning = null;
     if (requestedType) {
       const slotProviders = normalizeNodeCapabilitySlots(node.policy?.slots).map((s) => s.provider);
       if (slotProviders.length && !slotProviders.includes(requestedType)) {
@@ -7704,6 +7747,19 @@ async function meshLaunchSession(ctx, args) {
           supportedProviders: slotProviders
         }, null, 2);
       }
+      const explicitBlock = (0, import_daemon_core7.evaluateProviderQuotaGate)(node, requestedType, ctx.mesh.policy?.quotaRouting ?? null);
+      if (explicitBlock) {
+        explicitTypeQuotaWarning = {
+          quotaWarning: `Provider '${requestedType}' on node '${args.node_id}' is quota-gated (${explicitBlock.reason}; ${explicitBlock.window} window at ${explicitBlock.remainingPercent}% remaining, threshold ${explicitBlock.thresholdPercent}%). Launching anyway because the type was requested explicitly \u2014 the session may fail immediately if the provider rejects on quota.`,
+          quotaBlock: {
+            providerType: requestedType,
+            reason: explicitBlock.reason,
+            window: explicitBlock.window,
+            remainingPercent: explicitBlock.remainingPercent,
+            thresholdPercent: explicitBlock.thresholdPercent
+          }
+        };
+      }
     }
     if (!resolvedProviderType) {
       const providerPriority = readProviderPriority(node.policy);
@@ -7711,6 +7767,7 @@ async function meshLaunchSession(ctx, args) {
         return JSON.stringify({ success: false, error: missingProviderPriorityMessage(args.node_id) });
       }
       const failed = [];
+      const detectedCandidates = [];
       let unreachableError = null;
       for (const providerType of providerPriority) {
         let detectedPayload;
@@ -7722,11 +7779,33 @@ async function meshLaunchSession(ctx, args) {
           break;
         }
         if (detectedPayload?.success && detectedPayload?.detected) {
-          resolvedProviderType = providerType;
-          break;
+          if (!detectedCandidates.includes(providerType)) detectedCandidates.push(providerType);
+          continue;
         }
         failed.push(`${providerType}: ${detectedPayload?.error || "not detected"}`);
       }
+      if (detectedCandidates.length) {
+        const ranked = (0, import_daemon_core7.rankProvidersByQuotaGate)(node, detectedCandidates, ctx.mesh.policy?.quotaRouting ?? null);
+        if (ranked.clear.length) {
+          resolvedProviderType = ranked.clear[0];
+        } else {
+          const detail = ranked.gated.map((g) => `${g.providerType}: ${g.block.reason}`).join("; ");
+          return JSON.stringify({
+            success: false,
+            code: "mesh_all_providers_quota_gated",
+            error: `Every detected provider on node '${args.node_id}' is quota-gated (${detail}). This is a WAIT, not a misconfiguration \u2014 the quota windows reset on their own.`,
+            nodeId: args.node_id,
+            gated: ranked.gated.map((g) => ({
+              providerType: g.providerType,
+              reason: g.block.reason,
+              window: g.block.window,
+              remainingPercent: g.block.remainingPercent,
+              thresholdPercent: g.block.thresholdPercent
+            })),
+            nextAction: `Enqueue the work (mesh_enqueue_task) so the drain claims it when a window resets, or launch on a node whose providers still have quota. Retrying mesh_launch_session immediately will hit the same gate.`
+          }, null, 2);
+        }
+      }
       if (!resolvedProviderType) {
         if (unreachableError) {
           return JSON.stringify({ success: false, error: `Node '${args.node_id}' is unreachable \u2014 cannot detect a provider (${unreachableError}). The node's daemon may be offline; retry once it reconnects.` });
@@ -7855,6 +7934,7 @@ async function meshLaunchSession(ctx, args) {
       ...launchPayload,
       resolvedProviderType,
       ...providerSessionId ? { providerSessionId } : {},
+      ...explicitTypeQuotaWarning ?? {},
       queueTrigger,
       ...buildQueueTriggerGuidance(queueTrigger)
     }, null, 2);