@adhdev/daemon-standalone 1.0.58-rc.1 → 1.0.58-rc.2

package/dist/index.js

@@ -36768,10 +36768,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "e38506ee9da3e916fb4e3c99c19b636f20e5a35c" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "e38506ee" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.1" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-22T12:35:42.535Z" : void 0);
+      const commit = readInjected(true ? "8e051f2dacc04bd04da37212168709c3ade00877" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "8e051f2d" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-22T14:13:56.874Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -44084,6 +44084,7 @@ ${error48.message || ""}`;
     __export2(mesh_config_exports, {
       addNode: () => addNode,
       applyMeshHostJoinRequest: () => applyMeshHostJoinRequest,
+      collectIgnoredMagiSlotFields: () => collectIgnoredMagiSlotFields,
       configureMeshHostPairing: () => configureMeshHostPairing,
       createMesh: () => createMesh,
       createMeshHostPairingToken: () => createMeshHostPairingToken,
@@ -44680,6 +44681,22 @@ ${error48.message || ""}`;
       }
       return s2;
     }
+    function collectIgnoredMagiSlotFields(slots) {
+      if (!Array.isArray(slots)) return [];
+      const out = [];
+      slots.forEach((entry, idx) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
+        for (const key2 of Object.keys(entry)) {
+          if (MAGI_SLOT_KNOWN_KEYS.includes(key2)) continue;
+          out.push({
+            slot: idx,
+            field: key2,
+            reason: MAGI_SLOT_IGNORED_FIELD_REASONS[key2] ?? `not a recognized MAGI slot key (accepted: ${MAGI_SLOT_KNOWN_KEYS.join(", ")}); it was dropped and has no effect.`
+          });
+        }
+      });
+      return out;
+    }
     function normalizeMagiSlots(slots, knownNodeIds) {
       const allowed = knownNodeIds ? new Set(knownNodeIds) : void 0;
       if (!Array.isArray(slots) || slots.length === 0) {
@@ -44862,6 +44879,8 @@ ${error48.message || ""}`;
     var mergeMeshPolicy;
     var MAGI_KIND_PANEL_KINDS;
     var MAX_MAGI_KIND_SLOTS;
+    var MAGI_SLOT_KNOWN_KEYS;
+    var MAGI_SLOT_IGNORED_FIELD_REASONS;
     var QUOTA_ROUTING_PERCENT_FIELDS;
     var QUOTA_ROUTING_NONNEGATIVE_FIELDS;
     var init_mesh_config = __esm2({
@@ -44878,6 +44897,13 @@ ${error48.message || ""}`;
         mergeMeshPolicy = mergeAndNormalizePolicy;
         MAGI_KIND_PANEL_KINDS = ["claim_audit", "rca", "design", "freeform"];
         MAX_MAGI_KIND_SLOTS = 24;
+        MAGI_SLOT_KNOWN_KEYS = ["provider", "nodeId", "model", "capabilityTags", "n"];
+        MAGI_SLOT_IGNORED_FIELD_REASONS = Object.freeze({
+          thinkingLevel: "not part of a MAGI slot \u2014 a panel selects WHO answers independently, not how hard each replica thinks. Set thinkingLevel on the node's capability slots (mesh_node_slots_set), which is the routing axis.",
+          difficulty: "not part of a MAGI slot \u2014 MAGI always enqueues its replicas with the fixed 'freeform' difficulty sentinel because the panel has already chosen the (node, provider) target. Set difficulty on the node's capability slots instead.",
+          maxParallel: "not part of a MAGI slot \u2014 per-slot concurrency is a node capability-slot axis. Use the per-slot `n` replica count to control MAGI fan-out width.",
+          capability: "not a MAGI slot key \u2014 did you mean `capabilityTags`?"
+        });
         QUOTA_ROUTING_PERCENT_FIELDS = /* @__PURE__ */ new Set(["sessionMinRemainingPercent", "weeklyMinRemainingPercent"]);
         QUOTA_ROUTING_NONNEGATIVE_FIELDS = /* @__PURE__ */ new Set(["staleAfterMs", "sessionResetImminentMs", "spreadBonusMax"]);
       }
@@ -48569,6 +48595,36 @@ ${blocks.join("\n\n")}`;
         divergenceLogOnce = /* @__PURE__ */ new Set();
       }
     });
+    function s(v) {
+      return typeof v === "string" && v.trim() ? v.trim() : "";
+    }
+    function meshEventTraceKey(ctx) {
+      const segs = [`task=${s(ctx.taskId) || "-"}`];
+      const eventId = s(ctx.eventId);
+      if (eventId) segs.push(`evt=${eventId}`);
+      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
+      const nodeId = s(ctx.nodeId);
+      if (nodeId) segs.push(`node=${nodeId}`);
+      const meshId = s(ctx.meshId);
+      if (meshId) segs.push(`mesh=${meshId}`);
+      const event = s(ctx.event);
+      if (event) segs.push(`event=${event}`);
+      return segs.join(" ");
+    }
+    function traceMeshEventStage(stage, ctx, detail) {
+      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    function traceMeshEventDrop(reason, ctx, detail) {
+      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
+    }
+    var CAT;
+    var init_mesh_event_trace = __esm2({
+      "src/mesh/mesh-event-trace.ts"() {
+        "use strict";
+        init_logger();
+        CAT = "EvtTrace";
+      }
+    });
     function isSupportedMeshProtocolVersion(value) {
       return typeof value === "string" && SUPPORTED_MESH_PROTOCOL_VERSIONS.includes(value);
     }
@@ -49039,13 +49095,55 @@ ${blocks.join("\n\n")}`;
       }
       return backfilled.reverse();
     }
+    function readPendingEventTaskId(event) {
+      const metadataEvent = readRecord2(event.metadataEvent);
+      return readNonEmptyString(metadataEvent?.taskId);
+    }
+    function dropStaleTerminalTaskEvents(meshId, events) {
+      if (!events.some((event) => STALE_TASK_DROPPABLE_EVENTS.has(event.event))) return events;
+      let store;
+      try {
+        store = MeshRuntimeStore.getInstance();
+      } catch {
+        return events;
+      }
+      const terminalByTaskId = /* @__PURE__ */ new Map();
+      const isTaskTerminal = (taskId) => {
+        const cached5 = terminalByTaskId.get(taskId);
+        if (cached5 !== void 0) return cached5;
+        let terminal = false;
+        try {
+          const entry = store.findQueueEntryById(meshId, taskId);
+          terminal = !!entry && STALE_TASK_TERMINAL_STATUSES.has(entry.status);
+        } catch {
+          terminal = false;
+        }
+        terminalByTaskId.set(taskId, terminal);
+        return terminal;
+      };
+      return events.filter((event) => {
+        if (!STALE_TASK_DROPPABLE_EVENTS.has(event.event)) return true;
+        const taskId = readPendingEventTaskId(event);
+        if (!taskId) return true;
+        if (!isTaskTerminal(taskId)) return true;
+        traceMeshEventDrop("stale_task_terminal", {
+          taskId,
+          sessionId: resolveEventSessionId(event.metadataEvent) ?? event.targetCoordinatorSessionId,
+          nodeId: event.nodeId,
+          meshId,
+          event: event.event
+        }, "task row is already terminal (completed/failed/cancelled) \u2014 non-terminal alert is stale");
+        return false;
+      });
+    }
     function reconcilePendingMeshCoordinatorEvents(meshId, events) {
       const backfilled = refineTerminalEventFromLedger(meshId, events);
       const terminalJobIds = new Set(
         [...events.filter((event) => REFINE_TERMINAL_EVENTS.has(event.event)), ...backfilled].map((event) => readRefineJobId2(event)).filter(Boolean)
       );
       const reconciled = terminalJobIds.size === 0 ? events : events.filter((event) => !(event.event === "refine:accepted" && terminalJobIds.has(readRefineJobId2(event))));
-      return backfilled.length === 0 ? reconciled : [...reconciled, ...backfilled];
+      const fresh = dropStaleTerminalTaskEvents(meshId, reconciled);
+      return backfilled.length === 0 ? fresh : [...fresh, ...backfilled];
     }
     function getPendingRetentionCounters() {
       return { ...pendingRetentionCounters };
@@ -49430,6 +49528,8 @@ ${blocks.join("\n\n")}`;
     var TERMINAL_COMPLETION_EVENTS;
     var COORDINATOR_ALERT_EVENTS_WITH_REASON_FINGERPRINT;
     var TERMINAL_COMPLETION_DEDUP_TTL_MS;
+    var STALE_TASK_DROPPABLE_EVENTS;
+    var STALE_TASK_TERMINAL_STATUSES;
     var PENDING_EVENTS_DRAINED_RETENTION_MS;
     var PENDING_EVENTS_UNDRAINED_RETENTION_MS;
     var PENDING_RETENTION_EXPIRED_HOLD_REASON;
@@ -49444,6 +49544,7 @@ ${blocks.join("\n\n")}`;
         init_mesh_runtime_store();
         init_mesh_turn_presentation();
         init_mesh_events_utils();
+        init_mesh_event_trace();
         init_dist();
         init_contracts();
         REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
@@ -49484,6 +49585,15 @@ ${blocks.join("\n\n")}`;
           "mesh:dispatch_blocked"
         ]);
         TERMINAL_COMPLETION_DEDUP_TTL_MS = 60 * 60 * 1e3;
+        STALE_TASK_DROPPABLE_EVENTS = /* @__PURE__ */ new Set([
+          // Actionable dispatch-skip page ("this task will NOT dispatch on its own"). Meaningless
+          // once the task is terminal — the measured 081317f3 case.
+          "mesh:dispatch_blocked",
+          // Stall watchdog ("no progress observed"). A terminal task cannot make progress; the
+          // alert only invites the coordinator to re-drive already-finished work.
+          "monitor:no_progress"
+        ]);
+        STALE_TASK_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
         PENDING_EVENTS_DRAINED_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
         PENDING_EVENTS_UNDRAINED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
         PENDING_RETENTION_EXPIRED_HOLD_REASON = "pending_retention_expired";
@@ -49504,36 +49614,6 @@ ${blocks.join("\n\n")}`;
         };
       }
     });
-    function s(v) {
-      return typeof v === "string" && v.trim() ? v.trim() : "";
-    }
-    function meshEventTraceKey(ctx) {
-      const segs = [`task=${s(ctx.taskId) || "-"}`];
-      const eventId = s(ctx.eventId);
-      if (eventId) segs.push(`evt=${eventId}`);
-      segs.push(`sess=${s(ctx.sessionId) || "-"}`);
-      const nodeId = s(ctx.nodeId);
-      if (nodeId) segs.push(`node=${nodeId}`);
-      const meshId = s(ctx.meshId);
-      if (meshId) segs.push(`mesh=${meshId}`);
-      const event = s(ctx.event);
-      if (event) segs.push(`event=${event}`);
-      return segs.join(" ");
-    }
-    function traceMeshEventStage(stage, ctx, detail) {
-      LOG2.info(CAT, `[stage:${stage}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    function traceMeshEventDrop(reason, ctx, detail) {
-      LOG2.warn(CAT, `[drop:${reason}] ${meshEventTraceKey(ctx)}${detail ? ` \u2014 ${detail}` : ""}`);
-    }
-    var CAT;
-    var init_mesh_event_trace = __esm2({
-      "src/mesh/mesh-event-trace.ts"() {
-        "use strict";
-        init_logger();
-        CAT = "EvtTrace";
-      }
-    });
     function taskIsParked(task) {
       return !!readNonEmptyString(task?.parked?.reason);
     }
@@ -58370,6 +58450,7 @@ ${rules.join("\n")}`;
 - **Classify task difficulty honestly.** Judge each task's real difficulty (\`easy\`/\`medium\`/\`difficult\`/\`freeform\`) per the Task difficulty section above \u2014 it is a routing hint, and the matched slot's own model/thinking is what launches. Never bend difficulty to chase a model; retune slots instead (\`mesh_node_slots_set\`).
 - **Retune node profiles when routing is a poor fit \u2014 but only with approval.** A node's capability slots (its provider/model/thinking + difficulty range + capability tags, seen via \`mesh_node_slots_list\`) are what task\u2192node fitness routing matches against. If you notice a persistent mismatch \u2014 e.g. every \`difficult\` task lands on a node whose only slot is a cheap model, or a capability a node clearly has isn't declared \u2014 you MAY propose a slot change with \`mesh_node_slots_set\` (write=false). That returns current-vs-proposed; present that diff to the user with a one-line reason and apply (write=true) ONLY after they approve. It is a WHOLESALE replacement of the node's slots, so include the slots you want to keep. Never rewrite a node's profile silently or without a clear routing reason.
 - **Bootstrap a node's slots from what's actually installed.** When a node has NO slots configured (routing then falls back to "first available provider"), or CLI agents were newly installed on it, call \`mesh_node_slots_propose({ node_id })\` instead of hand-writing a profile. It detects the node's installed CLI agents and drafts a slot list from them \u2014 read-only, it never writes. Present its \`proposedSlots\` with the \`droppedSlots\` / \`destructive\` fields it reports (a wholesale write would delete any existing hand-tuned slot the draft doesn't reproduce, including providers not currently on PATH), then apply with \`mesh_node_slots_set({ slots: proposedSlots, write: true })\` after approval. It flags \`unknownProvider\` / \`provisional\` slots whose placement is a conservative guess rather than an attested one \u2014 call those out rather than presenting them as settled.
+- **When a MAGI panel is unconfigured, bootstrap it from the same detection.** \`mesh_magi_review({ task_kind })\` resolves its panel SOLELY from the configured kind-panel binding, so a task_kind with no slots fails outright with \`magi_kind_not_configured\` \u2014 MAGI is simply unavailable until someone binds it, and the usual reason nobody has is that this path is easy to miss. Pass \`mesh_node_slots_propose({ node_id, include_magi: true })\` to also get a \`magiPanel\` draft: one slot per DISTINCT detected provider, with no model pinned, because a panel's value is cross-provider independence rather than picking the best provider. It is read-only like the rest of the tool. Apply it per kind with \`mesh_magi_kind_panel_set({ task_kind, slots, write: true })\` after approval \u2014 and note that write is a WHOLESALE replacement of that kind's binding, so present the dry-run's \`currentSlots\` first. Do NOT reach for \`include_magi\` on every slot proposal; it is for when the panels are actually empty or a newly installed provider should join them.
 - **Respect explicit provider requests.** Map: Hermes \u2192 \`hermes-cli\`, Claude/Claude Code \u2192 \`claude-cli\`, Codex \u2192 \`codex-cli\`, Gemini \u2192 \`gemini-cli\`, Antigravity \u2192 \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Match concurrency to task kind.** Independent read-only tasks (\`live_debug_readonly\`) dispatch all at once up to the read-only cap \u2014 no worktree, no free node needed. Each write task needs its OWN branch workspace (Workflow 3.b0); spreading writes across base nodes is NOT a substitute: a mesh with four base nodes still has zero branch isolation. Ramp up cautiously only when tasks share a base branch or submodule pointer (landing order matters). Never launch a second session onto in-flight work for the same issue, even when \`mesh_read_chat\` shows no final message yet \u2014 successive stages of one investigation stay in their session (see Workflow 3f).
@@ -58530,6 +58611,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
    f. **Let the investigator apply the fix when the findings settle it \u2014 otherwise split deliberately.** An investigator that has read the source and named the file:line and the fix already holds context a fresh worker must rebuild from scratch, and you would have to restate its findings in the new task message to get there. Task mode is **per task, not per session**: the read-only guardrail is evaluated on each dispatch from that task's own \`readonly\`/\`task_mode\`, so you hand off by sending a follow-up \`mesh_send_task\` to the SAME session WITHOUT the read-only flag (use \`task_mode: "code_change"\`). You do not need a new session or a fresh worktree for the mode to change. **Hand off in-session when** the findings match your hypothesis, the fix stays inside the files just investigated, and no user decision is pending. **Split to a separate task when** the investigation needs a user decision (it surfaced design options, or a cost/risk tradeoff), when it OVERTURNED your hypothesis so the direction itself needs rethinking, or when the fix touches files another in-flight worker owns. **Never convert an investigation whose own conclusion was "do not change this"** \u2014 a correct no-op finding is a completed task, and pushing it into a fix produces an unverified change nobody asked for. Dispatching the investigation as an ordinary report-first task skips the handoff, but drops the guardrail against premature fixes \u2014 keep \`live_debug_readonly\` whenever the point is to find out whether anything is wrong at all.
 4. **Monitor** \u2014 Prefer event-driven completion/status notifications. Do **not** poll \`mesh_read_chat\` repeatedly. Do **not** repeatedly call \`mesh_status\` or \`mesh_view_queue\` just to wait for assigned/generating work. After dispatching a direct or queued task, send one progress update with the task/session handle, then stop. Wait for \`pendingCoordinatorEvents\` or another completion/approval/status signal, an explicit user status request, or a real timeout/stall signal before reading status/chat/queue again. Use at most one compact \`mesh_read_chat\` check after a terminal signal. Handle approvals via \`mesh_approve\`. **Proactively parallelize new work.** When the user reports a new bug or asks for new work, start it immediately if it is independent of in-flight tasks and there is headroom under \`maxParallelTasks\` \u2014 do not wait for a current task to finish or for the user to prompt you to parallelize. Read-only diagnosis (\`live_debug_readonly\`) has no isolation or merge cost, so dispatch it in parallel right away. The no-polling / concurrency-limit rules constrain *re-checking or duplicating already-dispatched work*; they are **not** a reason to defer starting a new, independent task.
+       - **Arrival order is not occurrence order \u2014 identify every notification by its \`taskId\`/\`sessionId\`.** While you are generating, worker notifications are held in the queue and injected together on the tick after you go idle. This is intended (a raw write into a generating session is not consumed as a turn), and the delay is normally well under a minute \u2014 measured median ~1 minute, worst case ~10 minutes. The consequence is that a notification arriving now is **not necessarily about the task you most recently dispatched**. Never infer a notification's subject from timing or from what you just sent: read the \`taskId\`/\`sessionId\` in the notification itself and match it to your own record of what you dispatched. Also note that your own coordinator session id appears in these traces, so a session id in a notification is not automatically a worker's. If a notification refers to a task you have already cancelled or completed, treat it as stale \u2014 do not act on it, and say so rather than silently reinterpreting it as being about current work.
 5. **Verify** \u2014 When a task reports completion or git work is visible, call \`mesh_git_status\` to verify changes were made.
 6. **Checkpoint** \u2014 Call \`mesh_checkpoint\` to save the work.
 7. **Converge branches** \u2014 Before marking any task complete, classify every touched node/branch into exactly one final state: \`merged_to_main\`, \`pushed_feature_branch_needs_merge\`, \`blocked_review\`, \`cleanup_candidate\`, or \`not_mergeable\`. Use \`mesh_status\` branchConvergenceSummary. For obvious clean branch catch-up (ahead 0, behind > 0, upstream fresh, no dirty/stash/submodule issues), use \`mesh_fast_forward_node\` dry-run first and execute only when explicitly safe/approved; this avoids consuming an agent session. Use \`mesh_refine_node\` for clean worktree branches when safe \u2014 but when 2+ sibling worktrees share a base, converge them with \`mesh_refine_batch\` rather than repeated single-node calls (see the sequencing rule in Rules). Before/refine merging root commits that contain submodule gitlink changes, require each submodule commit to be reachable from the configured submodule remote main branch, not merely present on a feature ref or local checkout. If \`mesh_refine_node\` returns \`submodule_reachability_failed\` or publish-required evidence, keep the public convergence bucket as \`blocked_review\`; unless \`allowAutoPublishSubmoduleMainCommits\` is explicitly enabled and Refinery reports successful non-force publish plus post-publish verification, ask the user for explicit approval to push/publish the unreachable submodule commit(s) to submodule main, then rerun \`mesh_refine_node\`. Do not merge the root branch until the submodule commit(s) are reachable from submodule origin/main. A task that remains on a non-main branch is not fully complete unless the final report names the follow-up state and next step.
@@ -85561,6 +85643,7 @@ ${e?.stderr || ""}`;
       clearDebugTrace: () => clearDebugTrace,
       clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       codexSessionsDir: () => codexSessionsDir,
+      collectIgnoredMagiSlotFields: () => collectIgnoredMagiSlotFields,
       collectPendingApprovals: () => collectPendingApprovals,
       collectSyncTargetTypes: () => collectSyncTargetTypes,
       commitMeshGraphPlan: () => commitMeshGraphPlan,
@@ -120702,10 +120785,17 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         if (!kind) return { success: false, error: "invalid_magi_kind_panel: task_kind is required" };
         const requestedMeshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         try {
-          const { setMagiKindPanel: setMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const { setMagiKindPanel: setMagiKindPanel2, resolveScopedMeshId: resolveScopedMeshId2, collectIgnoredMagiSlotFields: collectIgnoredMagiSlotFields2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          const ignoredFields = collectIgnoredMagiSlotFields2(args?.slots);
           const slots = setMagiKindPanel2(kind, args?.slots, requestedMeshId || void 0);
           const meshId = requestedMeshId || resolveScopedMeshId2();
-          return { success: true, kind, slots, meshId: meshId ?? null };
+          return {
+            success: true,
+            kind,
+            slots,
+            meshId: meshId ?? null,
+            ...ignoredFields.length ? { ignoredFields } : {}
+          };
         } catch (e) {
           return { success: false, error: e.message };
         }