@adhdev/daemon-standalone 0.9.82-rc.380 → 0.9.82-rc.381

package/dist/index.js

@@ -29754,6 +29754,56 @@ var require_dist3 = __commonJS({
     function resolveAutoConvergeCodeChange(policy) {
       return policy?.autoConvergeCodeChange === true;
     }
+    function resolveMaxParallelTasks(value) {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return DEFAULT_MESH_POLICY.maxParallelTasks;
+      return Math.max(MESH_MAX_PARALLEL_TASKS_MIN, Math.min(MESH_MAX_PARALLEL_TASKS_MAX, Math.floor(n)));
+    }
+    function normalizeAutoFastForwardPolicy(value) {
+      const record2 = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+      const maxBehind = Number(record2.maxBehind);
+      return {
+        enabled: record2.enabled !== false,
+        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+        requireCleanSubmodules: record2.requireCleanSubmodules !== false
+      };
+    }
+    function mergeAndNormalizePolicy(base, patch) {
+      const autoFastForward = normalizeAutoFastForwardPolicy({
+        ...DEFAULT_MESH_POLICY.autoFastForward,
+        ...base?.autoFastForward && typeof base.autoFastForward === "object" ? base.autoFastForward : {},
+        ...patch?.autoFastForward && typeof patch.autoFastForward === "object" ? patch.autoFastForward : {}
+      });
+      const policy = {
+        ...DEFAULT_MESH_POLICY,
+        ...base || {},
+        ...patch || {},
+        autoFastForward
+      };
+      if (!DIRTY_WORKSPACE_BEHAVIORS.has(policy.dirtyWorkspaceBehavior)) {
+        policy.dirtyWorkspaceBehavior = "warn";
+      }
+      policy.maxParallelTasks = resolveMaxParallelTasks(policy.maxParallelTasks);
+      policy.allowAutoPublishSubmoduleMainCommits = policy.allowAutoPublishSubmoduleMainCommits === true;
+      if (!SESSION_CLEANUP_MODES.has(policy.sessionCleanupOnNodeRemove)) {
+        policy.sessionCleanupOnNodeRemove = "preserve";
+      }
+      if (!SPAWNED_SESSION_VISIBILITY_MODES.has(policy.spawnedSessionVisibility)) {
+        policy.spawnedSessionVisibility = DEFAULT_MESH_POLICY.spawnedSessionVisibility;
+      }
+      const normalizedStrategy = normalizeMeshSchedulingStrategy(policy.schedulingStrategy);
+      if (normalizedStrategy === "first_eligible") {
+        delete policy.schedulingStrategy;
+      } else {
+        policy.schedulingStrategy = normalizedStrategy;
+      }
+      if (policy.autoConvergeCodeChange === true) {
+        policy.autoConvergeCodeChange = true;
+      } else {
+        delete policy.autoConvergeCodeChange;
+      }
+      return policy;
+    }
     function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy) {
       if (typeof nodePolicy?.delegatedWorkerAutoApprove === "boolean") {
         return nodePolicy.delegatedWorkerAutoApprove;
@@ -29783,6 +29833,11 @@ var require_dist3 = __commonJS({
     var MESH_CONVERGE_REFINE_TAG;
     var MESH_CONVERGE_FAST_FORWARD_TAG;
     var DEFAULT_MESH_POLICY;
+    var SESSION_CLEANUP_MODES;
+    var SPAWNED_SESSION_VISIBILITY_MODES;
+    var DIRTY_WORKSPACE_BEHAVIORS;
+    var MESH_MAX_PARALLEL_TASKS_MIN;
+    var MESH_MAX_PARALLEL_TASKS_MAX;
     var init_repo_mesh_types = __esm2({
       "src/repo-mesh-types.ts"() {
         "use strict";
@@ -29812,6 +29867,23 @@ var require_dist3 = __commonJS({
           autoFastForward: { enabled: true },
           maxTaskRetries: 1
         };
+        SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set([
+          "preserve",
+          "stop",
+          "delete_stopped",
+          "stop_and_delete"
+        ]);
+        SPAWNED_SESSION_VISIBILITY_MODES = /* @__PURE__ */ new Set([
+          "visible",
+          "hidden"
+        ]);
+        DIRTY_WORKSPACE_BEHAVIORS = /* @__PURE__ */ new Set([
+          "block",
+          "warn",
+          "checkpoint_then_continue"
+        ]);
+        MESH_MAX_PARALLEL_TASKS_MIN = 1;
+        MESH_MAX_PARALLEL_TASKS_MAX = 8;
       }
     });
     var git_executor_exports = {};
@@ -30036,10 +30108,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "5fff0bee3f6a8e8f00989177c53d1d2a1cf607ad" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "5fff0bee" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.380" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-25T10:08:02.752Z" : void 0);
+      const commit = readInjected(true ? "18afac213951f79c502feb6b25b7399fe4d709b3" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "18afac21" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.381" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-25T11:45:12.459Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -32098,52 +32170,6 @@ ${error48.message || ""}`;
       if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
       return identity;
     }
-    function mergeMeshPolicy(base, patch) {
-      const autoFastForward = normalizeAutoFastForwardPolicy({
-        ...DEFAULT_MESH_POLICY.autoFastForward,
-        ...base?.autoFastForward && typeof base.autoFastForward === "object" ? base.autoFastForward : {},
-        ...patch?.autoFastForward && typeof patch.autoFastForward === "object" ? patch.autoFastForward : {}
-      });
-      const policy = {
-        ...DEFAULT_MESH_POLICY,
-        ...base || {},
-        ...patch || {},
-        autoFastForward
-      };
-      if (!["block", "warn", "checkpoint_then_continue"].includes(policy.dirtyWorkspaceBehavior)) {
-        policy.dirtyWorkspaceBehavior = "warn";
-      }
-      const maxParallelTasks = Number(policy.maxParallelTasks);
-      policy.maxParallelTasks = Number.isFinite(maxParallelTasks) ? Math.max(1, Math.min(8, Math.floor(maxParallelTasks))) : 2;
-      policy.allowAutoPublishSubmoduleMainCommits = policy.allowAutoPublishSubmoduleMainCommits === true;
-      if (!SESSION_CLEANUP_MODES.has(String(policy.sessionCleanupOnNodeRemove))) {
-        policy.sessionCleanupOnNodeRemove = "preserve";
-      }
-      if (!SPAWNED_SESSION_VISIBILITY_MODES.has(String(policy.spawnedSessionVisibility))) {
-        policy.spawnedSessionVisibility = DEFAULT_MESH_POLICY.spawnedSessionVisibility;
-      }
-      const normalizedStrategy = normalizeMeshSchedulingStrategy(policy.schedulingStrategy);
-      if (normalizedStrategy === "first_eligible") {
-        delete policy.schedulingStrategy;
-      } else {
-        policy.schedulingStrategy = normalizedStrategy;
-      }
-      if (policy.autoConvergeCodeChange === true) {
-        policy.autoConvergeCodeChange = true;
-      } else {
-        delete policy.autoConvergeCodeChange;
-      }
-      return policy;
-    }
-    function normalizeAutoFastForwardPolicy(value) {
-      const record2 = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-      const maxBehind = Number(record2.maxBehind);
-      return {
-        enabled: record2.enabled !== false,
-        ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
-        requireCleanSubmodules: record2.requireCleanSubmodules !== false
-      };
-    }
     function listMeshes() {
       return loadMeshConfig().meshes;
     }
@@ -32445,8 +32471,7 @@ ${error48.message || ""}`;
     var import_fs3;
     var import_path3;
     var import_crypto3;
-    var SESSION_CLEANUP_MODES;
-    var SPAWNED_SESSION_VISIBILITY_MODES;
+    var mergeMeshPolicy;
     var init_mesh_config = __esm2({
       "src/config/mesh-config.ts"() {
         "use strict";
@@ -32457,8 +32482,7 @@ ${error48.message || ""}`;
         init_config();
         init_repo_mesh_types();
         init_mesh_host_ownership();
-        SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set(["preserve", "stop", "delete_stopped", "stop_and_delete"]);
-        SPAWNED_SESSION_VISIBILITY_MODES = /* @__PURE__ */ new Set(["visible", "hidden"]);
+        mergeMeshPolicy = mergeAndNormalizePolicy;
       }
     });
     function readRecord(value) {
@@ -32775,7 +32799,7 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
       if (recentActivity) sections.push(recentActivity);
       const operatingNotes = buildOperatingNotesSection(ctx.operatingNotes);
       if (operatingNotes) sections.push(operatingNotes);
-      sections.push(buildPolicySection({ ...DEFAULT_MESH_POLICY, ...mesh.policy || {} }));
+      sections.push(buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)));
       sections.push(TOOLS_SECTION);
       sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
       sections.push(WORKFLOW_SECTION);
@@ -32808,7 +32832,7 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
         mission: ctx.missionSection?.trim() || "",
         recentActivity: buildRecentActivitySection(ctx.recentActivity) || "",
         operatingNotes: buildOperatingNotesSection(ctx.operatingNotes) || "",
-        policy: buildPolicySection({ ...DEFAULT_MESH_POLICY, ...mesh.policy || {} }),
+        policy: buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)),
         tools: TOOLS_SECTION,
         workflow: WORKFLOW_SECTION,
         rules: buildRulesSection(coordinatorCliType),
@@ -35524,6 +35548,28 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
               AND status NOT IN ('completed', 'failed')
         `).run({ status, meshId, sessionId, updatedAt: now });
           }
+          /**
+           * MESH-DISPATCH-MISROUTE (fix 3, consumer residual): resolve the task_id of the SINGLE
+           * non-terminal direct dispatch a session owns. Returns the task_id only when the session
+           * holds exactly ONE active ('dispatched'/'acked') row — the case where a taskId-less
+           * lifecycle event (a legacy/relayed worker whose producer never stamped meshActiveTaskId)
+           * unambiguously belongs to that one dispatch. With zero rows there is nothing to ack; with
+           * two or more (a re-dispatch/nudge sibling) the firing event's owner is ambiguous, so we
+           * return null and the caller MUST NOT fall back to the session_id sweep that would flip a
+           * sibling row ("may flip a sibling dispatch row"). This narrows the legacy fallback to the
+           * only safe case instead of removing the producer-side TASKIDLESS stamp's safety net.
+           */
+          getSoleActiveDirectDispatchTaskId(meshId, sessionId) {
+            if (!sessionId) return null;
+            const rows = this.db.prepare(`
+            SELECT task_id FROM mesh_direct_dispatches
+            WHERE mesh_id = ? AND session_id = ?
+              AND status NOT IN ('completed', 'failed', 'stale')
+        `).all(meshId, sessionId);
+            if (rows.length !== 1) return null;
+            const taskId = typeof rows[0]?.task_id === "string" ? rows[0].task_id.trim() : "";
+            return taskId || null;
+          }
           cleanupTerminalDirectDispatches(olderThanMs) {
             const cutoff = new Date(Date.now() - olderThanMs).toISOString();
             this.db.prepare(`
@@ -40604,8 +40650,8 @@ Next step: ${nextStep}`;
       const maxParallelTasks = Math.max(1, Math.floor(Number(mesh?.policy?.maxParallelTasks) || 2));
       const maxReadonlyParallelTasks = Math.max(2, maxParallelTasks * 2);
       for (const task of pending) {
-        const isReadonly = task.taskMode === "live_debug_readonly";
-        if (isReadonly) {
+        const isReadonly2 = task.taskMode === "live_debug_readonly";
+        if (isReadonly2) {
           if (activeReadonlyAssignedCount(meshId) >= maxReadonlyParallelTasks) {
             markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_readonly_parallel_tasks_reached" });
             continue;
@@ -44054,8 +44100,19 @@ ${cleanBody}`;
         }
         if (sessionId) {
           const startedTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
-          if (startedTaskId || sessionHasActiveAssignment(args.meshId, sessionId)) {
+          if (startedTaskId) {
             updateDirectDispatchStatus(args.meshId, sessionId, "acked", startedTaskId);
+          } else if (sessionHasActiveAssignment(args.meshId, sessionId)) {
+            const soleTaskId = (() => {
+              try {
+                return MeshRuntimeStore.getInstance().getSoleActiveDirectDispatchTaskId(args.meshId, sessionId);
+              } catch {
+                return null;
+              }
+            })();
+            if (soleTaskId) {
+              updateDirectDispatchStatus(args.meshId, sessionId, "acked", soleTaskId);
+            }
           }
           const activeDeliveries = (() => {
             try {
@@ -50923,6 +50980,8 @@ ${lastSnapshot}`;
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
+      MESH_MAX_PARALLEL_TASKS_MAX: () => MESH_MAX_PARALLEL_TASKS_MAX,
+      MESH_MAX_PARALLEL_TASKS_MIN: () => MESH_MAX_PARALLEL_TASKS_MIN,
       MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
       MESH_NODE_LIVE_TRUTH_MARKER: () => MESH_NODE_LIVE_TRUTH_MARKER,
       MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
@@ -50973,6 +51032,7 @@ ${lastSnapshot}`;
       buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
       buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
       buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
+      buildMeshSchedulingRuntime: () => buildMeshSchedulingRuntime,
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -51121,11 +51181,13 @@ ${lastSnapshot}`;
       markSetupComplete: () => markSetupComplete,
       markStaleDirectDispatches: () => markStaleDirectDispatches,
       maybeRunDaemonUpgradeHelperFromEnv: () => maybeRunDaemonUpgradeHelperFromEnv2,
+      mergeAndNormalizePolicy: () => mergeAndNormalizePolicy,
       meshNodeIdMatches: () => meshNodeIdMatches,
       namedKeyToAnsi: () => namedKeyToAnsi,
       namedKeysToAnsi: () => namedKeysToAnsi,
       nodeSatisfiesRequiredTags: () => nodeSatisfiesRequiredTags,
       normalizeActiveChatData: () => normalizeActiveChatData,
+      normalizeAutoFastForwardPolicy: () => normalizeAutoFastForwardPolicy,
       normalizeChatMessage: () => normalizeChatMessage,
       normalizeChatMessageKind: () => normalizeChatMessageKind,
       normalizeChatMessages: () => normalizeChatMessages,
@@ -51187,11 +51249,13 @@ ${lastSnapshot}`;
       resolveDelegatedWorkerAutoApprove: () => resolveDelegatedWorkerAutoApprove,
       resolveDeliveryDecision: () => resolveDeliveryDecision,
       resolveGitRepository: () => resolveGitRepository,
+      resolveMaxParallelTasks: () => resolveMaxParallelTasks,
       resolveMeshHostStatus: () => resolveMeshHostStatus,
       resolveMeshNodeAttribution: () => resolveMeshNodeAttribution,
       resolveMeshRefineValidationPlan: () => resolveMeshRefineValidationPlan,
       resolveMeshSurfacedSessionPreview: () => resolveMeshSurfacedSessionPreview,
       resolveNodeSchedulingPriority: () => resolveNodeSchedulingPriority,
+      resolveProviderMaxParallel: () => resolveProviderMaxParallel,
       resolveSessionHostAppName: () => resolveSessionHostAppName,
       resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution2,
       resolveWorktreePath: () => resolveWorktreePath,
@@ -53074,6 +53138,98 @@ ${lastSnapshot}`;
     init_mesh_work_queue();
     init_mesh_active_work();
     init_mesh_refine_status();
+    init_repo_mesh_types();
+    init_dist();
+    function isReadonly(task) {
+      return task.taskMode === "live_debug_readonly";
+    }
+    function isAssigned(task) {
+      return task.status === "assigned";
+    }
+    function buildMeshSchedulingRuntime(mesh, queue) {
+      const strategy = normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+      const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
+      const maxReadonlyParallelTasks = Math.max(2, maxParallelTasks * 2);
+      const assignedTasks = (Array.isArray(queue) ? queue : []).filter(isAssigned);
+      const activeWriteAssigned = assignedTasks.filter((t) => !isReadonly(t)).length;
+      const activeReadonlyAssigned = assignedTasks.filter(isReadonly).length;
+      const globalWriteCapReached = activeWriteAssigned >= maxParallelTasks;
+      const globalReadonlyCapReached = activeReadonlyAssigned >= maxReadonlyParallelTasks;
+      const writeAssignedByNode = /* @__PURE__ */ new Map();
+      const assignedByNode = /* @__PURE__ */ new Map();
+      const providerCountByNode = /* @__PURE__ */ new Map();
+      for (const task of assignedTasks) {
+        const nodeId = typeof task.assignedNodeId === "string" ? task.assignedNodeId.trim() : "";
+        if (!nodeId) continue;
+        assignedByNode.set(nodeId, (assignedByNode.get(nodeId) ?? 0) + 1);
+        if (!isReadonly(task)) {
+          writeAssignedByNode.set(nodeId, (writeAssignedByNode.get(nodeId) ?? 0) + 1);
+        }
+        const provider = typeof task.assignedProviderType === "string" ? task.assignedProviderType : "";
+        if (provider) {
+          let byProvider = providerCountByNode.get(nodeId);
+          if (!byProvider) {
+            byProvider = /* @__PURE__ */ new Map();
+            providerCountByNode.set(nodeId, byProvider);
+          }
+          byProvider.set(provider, (byProvider.get(provider) ?? 0) + 1);
+        }
+      }
+      const nodes = [];
+      for (const rawNode of Array.isArray(mesh?.nodes) ? mesh.nodes : []) {
+        const nodeId = normalizeMeshNodeId(rawNode);
+        if (!nodeId) continue;
+        const policy = rawNode?.policy || void 0;
+        const load4 = assignedByNode.get(nodeId) ?? 0;
+        const schedulingPriority = resolveNodeSchedulingPriority(policy);
+        const capReasons = [];
+        if (globalWriteCapReached) capReasons.push("global_max_parallel_tasks_reached");
+        if ((writeAssignedByNode.get(nodeId) ?? 0) > 0) capReasons.push("node_has_active_assignment");
+        let providerRoles;
+        const declaredRoles = Array.isArray(policy?.providerRoles) ? policy.providerRoles : [];
+        if (declaredRoles.length) {
+          const byProvider = providerCountByNode.get(nodeId);
+          providerRoles = [];
+          for (const role of declaredRoles) {
+            if (!role || typeof role !== "object") continue;
+            const providerType = typeof role.providerType === "string" ? role.providerType.trim() : "";
+            if (!providerType) continue;
+            const maxParallel = resolveProviderMaxParallel(policy, providerType);
+            const activeAssigned = byProvider?.get(providerType) ?? 0;
+            const capReached = maxParallel !== void 0 && activeAssigned >= maxParallel;
+            providerRoles.push({
+              providerType,
+              ...maxParallel !== void 0 ? { maxParallel } : {},
+              activeAssigned,
+              capReached
+            });
+            if (capReached) capReasons.push(`max_provider_parallel_reached:${providerType}`);
+          }
+          if (!providerRoles.length) providerRoles = void 0;
+        }
+        const maxConcurrentSessions = Number(policy?.maxConcurrentSessions);
+        const hasSessionCap = Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0;
+        nodes.push({
+          nodeId,
+          load: load4,
+          schedulingPriority,
+          ...hasSessionCap ? { maxConcurrentSessions: Math.floor(maxConcurrentSessions) } : {},
+          ...providerRoles ? { providerRoles } : {},
+          capReached: capReasons.length > 0,
+          capReasons
+        });
+      }
+      return {
+        strategy,
+        maxParallelTasks,
+        maxReadonlyParallelTasks,
+        activeWriteAssigned,
+        activeReadonlyAssigned,
+        globalWriteCapReached,
+        globalReadonlyCapReached,
+        nodes
+      };
+    }
     init_mesh_host_ownership();
     init_mesh_events();
     init_mesh_events_utils();