@adhdev/daemon-standalone 1.0.58-rc.15 → 1.0.58-rc.16

package/dist/index.js

@@ -36882,10 +36882,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "0b39364ac334ce9649b42e58d5bda606abe274ec" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "0b39364a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.15" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-26T02:38:01.516Z" : void 0);
+      const commit = readInjected(true ? "0ff2241634e4035f73e2d9a41eb69f223706ff3c" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "0ff22416" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.16" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-26T06:35:36.671Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38284,11 +38284,11 @@ var require_dist3 = __commonJS({
       const override = env2.ADHDEV_CONFIG_DIR;
       if (!override || !override.trim()) return false;
       const sibling = otherTrackConfigDir(env2, homeDir2);
-      const normalize5 = (p) => {
+      const normalize6 = (p) => {
         const unified = p.trim().replace(/[\\/]+$/, "").replace(/\\/g, "/");
         return platform11 === "win32" ? unified.toLowerCase() : unified;
       };
-      return normalize5(override) === normalize5(sibling);
+      return normalize6(override) === normalize6(sibling);
     }
     function configDirChannelMismatch(resolvedConfigDir, resolvedChannel, hasExplicitChannelSignal) {
       if (hasExplicitChannelSignal) return null;
@@ -52098,6 +52098,15 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         const reclaims = (entry.strandedReclaimCount || 0) + 1;
         const prevNode = entry.assignedNodeId;
         const prevSession = entry.assignedSessionId;
+        const prevProvider = entry.assignedProviderType;
+        entry.lastReclaim = {
+          ...prevProvider ? { providerType: prevProvider } : {},
+          ...prevNode ? { nodeId: prevNode } : {},
+          ...prevSession ? { sessionId: prevSession } : {},
+          reason,
+          reclaimCount: reclaims,
+          at: now
+        };
         delete entry.assignedNodeId;
         delete entry.assignedSessionId;
         delete entry.assignedProviderType;
@@ -52130,9 +52139,15 @@ The instruction it carried was never delivered to anyone. If it still matters, r
             kind: "task_reclaimed",
             nodeId: prevNode,
             sessionId: prevSession,
+            // REDRIVE-PROVIDER-FLIP (a): name the provider being torn down. This is the
+            // "before" half of the flip; the "after" half is the redriveProvenance block
+            // on the next task_dispatched, so the comparison no longer needs a manual
+            // two-entry join.
+            ...prevProvider ? { providerType: prevProvider } : {},
             payload: {
               taskId,
               reason,
+              ...prevProvider ? { providerType: prevProvider } : {},
               ...typeof opts?.ageMs === "number" ? { ageMs: opts.ageMs } : {},
               reclaimCount: reclaims,
               outcome: entry.status
@@ -59168,7 +59183,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           "p2p_dispatch_failed",
           "dispatch_failed",
           "dispatch_duplicate_rebound",
-          "queue_hold_hard_deadline"
+          "queue_hold_hard_deadline",
+          // REDRIVE-PROVIDER-FLIP (a): joinable by kind+taskId alongside the task's
+          // task_dispatched/task_reclaimed rows — the whole point is to read a task's
+          // redrive history without an O(n) payload scan.
+          "redrive_provider_changed"
         ]);
         LEDGER_DIR_NAME = "mesh-ledger";
         MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
@@ -65199,7 +65218,22 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         if (wb.confidence !== wa.confidence) return wb.confidence - wa.confidence;
         return wb.remainingPercent - wa.remainingPercent;
       });
-      return { clear, gated };
+      const rankingEvidence = clear.map((providerType) => {
+        const session = sessionByProvider?.get(providerType);
+        const reading = session ?? weeklyByProvider.get(providerType);
+        const axis = session ? "session" : "weekly";
+        return {
+          providerType,
+          axis,
+          ...reading ? {
+            risk: reading.risk,
+            confidence: reading.confidence,
+            rankedRisk: rankedRisk(reading),
+            remainingPercent: reading.remainingPercent
+          } : {}
+        };
+      });
+      return { clear, gated, sessionAxisActive, rankingEvidence };
     }
     function resolveRecoveryRelaunchProvider(node, failedProviderType, nodeProviderTypes = [], policy, now = Date.now(), context) {
       if (!failedProviderType) return { action: "block" };
@@ -66172,6 +66206,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           providerType: candidate.providerType,
           ...candidate.slot.model ? { model: candidate.slot.model } : {},
           selectionRank,
+          fitnessInputRank: selectionRank,
           capacitySortKey: selectionCapacity.available ? 1 : 0,
           capacityAvailable: selectionCapacity.available,
           capacity: taskCapacity,
@@ -66198,8 +66233,16 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         ...args.ranked.clear,
         ...args.ranked.gated.map((entry) => entry.providerType)
       ]);
+      const evidenceByProvider = new Map(
+        (args.ranked.rankingEvidence ?? []).map((entry, clearOrderIndex) => {
+          const { providerType, ...rest } = entry;
+          return [providerType, { ...rest, clearOrderIndex }];
+        })
+      );
       const quotaDiagnostics = bonusDiagnostics.map((detail) => {
         const { providerType, ...bonus } = detail;
+        const ranking = evidenceByProvider.get(detail.providerType);
+        const withRanking = ranking ? { ranking } : {};
         const gated = args.ranked.gated.find((entry) => entry.providerType === detail.providerType);
         if (!rankedProviders.has(detail.providerType)) {
           return { providerType, bonus, gate: { outcome: "not-evaluated-floor" } };
@@ -66218,7 +66261,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         return {
           providerType,
           bonus,
-          gate: failOpen ? { outcome: "fail-open", reason: detail.zeroReason } : { outcome: "clear" }
+          gate: failOpen ? { outcome: "fail-open", reason: detail.zeroReason } : { outcome: "clear" },
+          ...withRanking
         };
       });
       const previewOnly = args.unbounded ? {
@@ -68898,6 +68942,65 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_chat_history();
       }
     });
+    function normalize3(value) {
+      const trimmed = typeof value === "string" ? value.trim() : "";
+      return trimmed ? trimmed : void 0;
+    }
+    function buildRedriveProvenance(lastReclaim, dispatchedProviderType) {
+      if (!lastReclaim) return null;
+      const previousProviderType = normalize3(lastReclaim.providerType);
+      const providerType = normalize3(dispatchedProviderType) ?? dispatchedProviderType;
+      const providerChanged = !!previousProviderType && !!normalize3(dispatchedProviderType) && previousProviderType !== providerType;
+      return {
+        reason: lastReclaim.reason,
+        reclaimCount: lastReclaim.reclaimCount,
+        ...previousProviderType ? { previousProviderType } : {},
+        ...normalize3(lastReclaim.nodeId) ? { previousNodeId: normalize3(lastReclaim.nodeId) } : {},
+        ...normalize3(lastReclaim.sessionId) ? { previousSessionId: normalize3(lastReclaim.sessionId) } : {},
+        reclaimedAt: lastReclaim.at,
+        providerType,
+        providerChanged
+      };
+    }
+    function describeRedriveProviderFlip(provenance, taskId, meshId) {
+      return `Redrive of task ${taskId} on mesh ${meshId} CHANGED PROVIDER: ${provenance.previousProviderType ?? "?"} \u2192 ${provenance.providerType} (reason ${provenance.reason}, reclaim #${provenance.reclaimCount}, previous node=${provenance.previousNodeId ?? "?"} session=${provenance.previousSessionId ?? "?"}). The reclaim path re-claims an idle session WITHOUT recomputing routing, so the task is now running on a provider it was not routed to. Recorded for measurement; no behavior changed here.`;
+    }
+    var init_mesh_redrive_provenance = __esm2({
+      "src/mesh/mesh-redrive-provenance.ts"() {
+        "use strict";
+      }
+    });
+    async function waitForRemoteSessionReady(meshId, nodeId, sessionId, opts) {
+      if (!sessionId) return false;
+      const timeoutMs = opts.timeoutMs ?? REMOTE_LAUNCH_READY_TIMEOUT_MS;
+      const pollMs = opts.pollMs ?? REMOTE_LAUNCH_READY_POLL_MS;
+      const now = opts.now ?? (() => Date.now());
+      const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve31) => setTimeout(resolve31, ms)));
+      const deadline = now() + timeoutMs;
+      for (; ; ) {
+        let ready = false;
+        try {
+          ready = opts.isReady();
+        } catch {
+          return false;
+        }
+        if (ready) return true;
+        if (now() >= deadline) break;
+        await sleep3(pollMs);
+      }
+      LOG2.warn("MeshQueue", `Remote auto-launched session ${sessionId} on node ${nodeId} (mesh ${meshId}) did not report agent:ready within ${timeoutMs}ms; proceeding optimistically \u2014 unchanged behavior, the claim still fires via the normal event/reconcile path`);
+      return false;
+    }
+    var REMOTE_LAUNCH_READY_TIMEOUT_MS;
+    var REMOTE_LAUNCH_READY_POLL_MS;
+    var init_mesh_remote_ready_wait = __esm2({
+      "src/mesh/mesh-remote-ready-wait.ts"() {
+        "use strict";
+        init_logger();
+        REMOTE_LAUNCH_READY_TIMEOUT_MS = 15e3;
+        REMOTE_LAUNCH_READY_POLL_MS = 100;
+      }
+    });
     function isAnthropicProvider(providerType) {
       const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
       return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
@@ -70301,6 +70404,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       LOG2.warn("MeshQueue", `Auto-launched session ${sessionId} not interactive after ${LOCAL_LAUNCH_READY_TIMEOUT_MS}ms; dispatching anyway (adapter queue-until-ready will buffer)`);
     }
+    function remoteSessionReadyProbe(meshId, nodeId, sessionId) {
+      return () => MeshRuntimeStore.getInstance().getRemoteIdleSessions(meshId).some((s2) => sessionIdsEquivalent(s2.sessionId, sessionId) && meshNodeIdMatches({ nodeId: s2.nodeId }, nodeId));
+    }
     function recordTaskDispatchedLedger(ctx, deliveryId) {
       const task = ctx.task;
       const routing = ctx.routingDecision;
@@ -70327,6 +70433,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         ...routing?.selectionTrajectory ? { selectionTrajectory: routing.selectionTrajectory } : {},
         ...routing?.reason ? { reason: routing.reason } : {}
       };
+      const redriveProvenance = buildRedriveProvenance(task.lastReclaim, ctx.providerType);
       appendLedgerEntry(ctx.meshId, {
         kind: "task_dispatched",
         nodeId: ctx.nodeId,
@@ -70341,9 +70448,30 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           ...ctx.sourceCoordinatorSessionId ? { coordinatorSessionId: ctx.sourceCoordinatorSessionId } : {},
           ...ctx.sourceCoordinatorDaemonId ? { coordinatorDaemonId: ctx.sourceCoordinatorDaemonId } : {},
           ...Array.isArray(task.requiredTags) && task.requiredTags.length ? { requiredTags: task.requiredTags } : {},
-          routingDecision
+          routingDecision,
+          ...redriveProvenance ? { redriveProvenance } : {}
         }
       });
+      if (redriveProvenance?.providerChanged) {
+        LOG2.warn("MeshQueue", describeRedriveProviderFlip(redriveProvenance, task.id, ctx.meshId));
+        traceMeshEventStage("redrive_provider_changed", {
+          taskId: task.id,
+          sessionId: ctx.sessionId,
+          nodeId: ctx.nodeId,
+          meshId: ctx.meshId
+        }, `${redriveProvenance.previousProviderType} \u2192 ${redriveProvenance.providerType} (${redriveProvenance.reason}, reclaim #${redriveProvenance.reclaimCount})`);
+        try {
+          appendLedgerEntry(ctx.meshId, {
+            kind: "redrive_provider_changed",
+            nodeId: ctx.nodeId,
+            sessionId: ctx.sessionId,
+            providerType: ctx.providerType,
+            taskId: task.id,
+            payload: { taskId: task.id, deliveryId, transport: ctx.transport, ...redriveProvenance }
+          });
+        } catch {
+        }
+      }
     }
     function deliverTaskToSession(dispatchThunk, ctx, warmup) {
       const delivery = createSessionDelivery({
@@ -71320,6 +71448,11 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
                 logAutoLaunchQuotaFallbackSuccess(resolved, task.id, nodeId, remoteSessionId || void 0);
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
                 sweepExpiredCooldowns();
+                if (remoteSessionId) {
+                  await waitForRemoteSessionReady(meshId, nodeId, remoteSessionId, {
+                    isReady: remoteSessionReadyProbe(meshId, nodeId, remoteSessionId)
+                  }).catch(() => false);
+                }
                 return true;
               }
               markAutoLaunch(meshId, task.id, { status: "started", nodeId, providerType: effectiveProviderType, ...effectiveModel ? { model: effectiveModel } : {}, ...effectiveThinkingLevel ? { thinkingLevel: effectiveThinkingLevel } : {} });
@@ -71577,6 +71710,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_runtime_store();
         init_mesh_claim_refusal();
         init_mesh_event_trace();
+        init_mesh_redrive_provenance();
+        init_mesh_remote_ready_wait();
         init_mesh_warmup_deadline();
         init_repo_mesh_types();
         init_mesh_json_config();
@@ -79042,7 +79177,7 @@ ${cleanBody}`;
                   nodeId: row.assignedNodeId,
                   meshId,
                   event: "agent:generating_started"
-                }, `delivered_not_consumed ${Math.round(ageMs2 / 1e3)}s \u2192 ${redriven.status}`);
+                }, `delivered_not_consumed ${Math.round(ageMs2 / 1e3)}s \u2192 ${redriven.status}${row.assignedProviderType ? ` (provider ${row.assignedProviderType} released; the re-claim adopts an idle session without re-ranking, so it may differ)` : ""}`);
                 continue;
               }
             }
@@ -92542,6 +92677,7 @@ ${e?.stderr || ""}`;
     init_mesh_routing_decision();
     init_mesh_scheduling_fitness();
     init_mesh_work_queue();
+    var QUOTA_STAGE_NOTE = "fitnessOrder/fitnessWinner(=fitnessOrderHead) are the INPUT order to quota ranking, not a result. The selected provider is `winner`; per-candidate ranking numbers are in quotaDiagnostics[].ranking.";
     function providerReportedDisabled(node, providerType) {
       return node?.nodeFacts?.providerEnablement?.[providerType]?.enabled === false;
     }
@@ -92587,7 +92723,15 @@ ${e?.stderr || ""}`;
           stages: {
             difficultyFloor: { required: difficultyFloorRequired, admittedSlots: [], excludedSlots: [] },
             fitness: [],
-            quota: { fitnessOrder: [], clearOrder: [], gated: [], reordered: false }
+            quota: {
+              fitnessOrder: [],
+              clearOrder: [],
+              gated: [],
+              reordered: false,
+              note: QUOTA_STAGE_NOTE,
+              axis: "weekly",
+              sessionAxisActive: false
+            }
           },
           quotaDiagnostics: []
         };
@@ -92615,7 +92759,7 @@ ${e?.stderr || ""}`;
         return { ...slotIdentity(candidate), reason: reason2 };
       });
       const fitnessOrder = selection.candidates.map((candidate) => candidate.providerType);
-      const fitnessWinner = fitnessOrder[0];
+      const fitnessOrderHead = fitnessOrder[0];
       const winner = selection.winner?.providerType;
       const winnerIndex = selection.winner ? usableSlots.indexOf(selection.winner) : -1;
       const winnerScore = winnerIndex >= 0 ? scores[winnerIndex] : void 0;
@@ -92645,10 +92789,13 @@ ${e?.stderr || ""}`;
               providerType: entry.providerType,
               reason: entry.block.reason
             })),
-            ...fitnessWinner ? { fitnessWinner } : {},
+            ...fitnessOrderHead ? { fitnessWinner: fitnessOrderHead, fitnessOrderHead } : {},
+            note: QUOTA_STAGE_NOTE,
             ...winner ? { winner } : {},
-            reordered: !!winner && !!fitnessWinner && winner !== fitnessWinner,
-            ...winner && fitnessWinner && winner !== fitnessWinner ? { displacedFitnessWinner: fitnessWinner } : {}
+            reordered: !!winner && !!fitnessOrderHead && winner !== fitnessOrderHead,
+            ...winner && fitnessOrderHead && winner !== fitnessOrderHead ? { displacedFitnessWinner: fitnessOrderHead } : {},
+            axis: selection.ranked.sessionAxisActive ? "session" : "weekly",
+            sessionAxisActive: selection.ranked.sessionAxisActive === true
           }
         },
         quotaDiagnostics: selection.diagnostics.quotaDiagnostics ?? []
@@ -109883,8 +110030,8 @@ ${marker}`,
         const landedQuestion = readFocusedClaudeTuiQuestion(landed.screenText);
         const rereadQuestion = readFocusedClaudeTuiQuestion(reread);
         if (!landedQuestion || !rereadQuestion) return true;
-        const normalize5 = (text) => text.replace(/\s+/g, " ").trim();
-        return normalize5(landedQuestion.question) === normalize5(rereadQuestion.question);
+        const normalize6 = (text) => text.replace(/\s+/g, " ").trim();
+        return normalize6(landedQuestion.question) === normalize6(rereadQuestion.question);
       }
       async captureClaudeTuiPrompt(firstScreen, headers) {
         if (this.claudeTuiCaptureSuppressed) return;
@@ -110101,8 +110248,8 @@ ${marker}`,
       };
     }
     function isPathInsideWorkspace(configPath, workspace) {
-      const normalize5 = (value) => value.replace(/[\\/]+$/, "");
-      const ws = normalize5(workspace);
+      const normalize6 = (value) => value.replace(/[\\/]+$/, "");
+      const ws = normalize6(workspace);
       if (!ws) return false;
       const separatorAgnostic = (value) => value.replace(/\\/g, "/");
       const normalizedPath = separatorAgnostic(configPath);
@@ -123469,9 +123616,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
       compareVersions(a, b) {
-        const normalize5 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
-        const pa = normalize5(a);
-        const pb = normalize5(b);
+        const normalize6 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+        const pa = normalize6(a);
+        const pb = normalize6(b);
         for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
           const va = pa[i] || 0;
           const vb = pb[i] || 0;