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

package/dist/index.mjs

@@ -38,6 +38,56 @@ function resolveNodeSchedulingPriority(nodePolicy) {
 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 record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const maxBehind = Number(record.maxBehind);
+  return {
+    enabled: record.enabled !== false,
+    ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
+    requireCleanSubmodules: record.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;
@@ -62,7 +112,7 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   }
   return void 0;
 }
-var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
@@ -92,6 +142,23 @@ var init_repo_mesh_types = __esm({
       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;
   }
 });
 
@@ -311,10 +378,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "5fff0bee3f6a8e8f00989177c53d1d2a1cf607ad" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "5fff0bee" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:07:36.562Z" : 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 version = 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:44:40.598Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2366,52 +2433,6 @@ function normalizeRepoIdentity(remoteUrl) {
   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 record = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-  const maxBehind = Number(record.maxBehind);
-  return {
-    enabled: record.enabled !== false,
-    ...Number.isFinite(maxBehind) && maxBehind >= 0 ? { maxBehind: Math.floor(maxBehind) } : {},
-    requireCleanSubmodules: record.requireCleanSubmodules !== false
-  };
-}
 function listMeshes() {
   return loadMeshConfig().meshes;
 }
@@ -2710,7 +2731,7 @@ function updateNode(meshId, nodeId, opts) {
   saveMeshConfig(config);
   return node;
 }
-var SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES;
+var mergeMeshPolicy;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
@@ -2718,8 +2739,7 @@ var init_mesh_config = __esm({
     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;
   }
 });
 
@@ -3043,7 +3063,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);
@@ -3076,7 +3096,7 @@ function expandPromptPlaceholders(template, ctx) {
     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),
@@ -5741,6 +5761,28 @@ var init_mesh_runtime_store = __esm({
               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(`
@@ -10815,8 +10857,8 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   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;
@@ -14244,8 +14286,19 @@ function injectMeshSystemMessage(components, args) {
     }
     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 {
@@ -22921,6 +22974,102 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 init_mesh_work_queue();
 init_mesh_active_work();
 init_mesh_refine_status();
+
+// src/mesh/mesh-scheduling-runtime.ts
+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
+  };
+}
+
+// src/index.ts
 init_mesh_host_ownership();
 init_mesh_events();
 init_mesh_events_utils();
@@ -62209,6 +62358,8 @@ export {
   MAX_LEDGER_SLICE_LIMIT,
   MESH_CONVERGE_FAST_FORWARD_TAG,
   MESH_CONVERGE_REFINE_TAG,
+  MESH_MAX_PARALLEL_TASKS_MAX,
+  MESH_MAX_PARALLEL_TASKS_MIN,
   MESH_MISSION_STATUSES,
   MESH_NODE_LIVE_TRUTH_MARKER,
   MESH_REFINE_CONFIG_LOCATIONS,
@@ -62259,6 +62410,7 @@ export {
   buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness,
   buildMeshNodeProbeFreshness,
+  buildMeshSchedulingRuntime,
   buildMissionPromptSection,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,
@@ -62407,11 +62559,13 @@ export {
   markSetupComplete,
   markStaleDirectDispatches,
   maybeRunDaemonUpgradeHelperFromEnv,
+  mergeAndNormalizePolicy,
   meshNodeIdMatches,
   namedKeyToAnsi,
   namedKeysToAnsi,
   nodeSatisfiesRequiredTags,
   normalizeActiveChatData,
+  normalizeAutoFastForwardPolicy,
   normalizeChatMessage,
   normalizeChatMessageKind,
   normalizeChatMessages,
@@ -62473,11 +62627,13 @@ export {
   resolveDelegatedWorkerAutoApprove,
   resolveDeliveryDecision,
   resolveGitRepository,
+  resolveMaxParallelTasks,
   resolveMeshHostStatus,
   resolveMeshNodeAttribution,
   resolveMeshRefineValidationPlan,
   resolveMeshSurfacedSessionPreview,
   resolveNodeSchedulingPriority,
+  resolveProviderMaxParallel,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
   resolveWorktreePath,