@adhdev/daemon-core 0.9.82-rc.506 → 0.9.82-rc.508

package/dist/index.mjs

@@ -412,10 +412,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "d7415812627054f6b93f8caf231387b4e6d0181b" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "d7415812" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.506" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-12T15:25:43.979Z" : void 0);
+  const commit = readInjected(true ? "3c72ac19ec9253071d614cd2410dc9f8d555eb26" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "3c72ac19" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.508" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-12T23:18:59.856Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3558,7 +3558,8 @@ var init_mesh_config = __esm({
 // src/mesh/coordinator-prompt.ts
 var coordinator_prompt_exports = {};
 __export(coordinator_prompt_exports, {
-  buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt
+  buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
+  buildMagiKindPanelsSection: () => buildMagiKindPanelsSection
 });
 import * as fs2 from "fs";
 import * as os2 from "os";
@@ -3647,6 +3648,8 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
   }
   sections.push(buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)));
   sections.push(buildBrainPresetsSection());
+  const magiSection = buildMagiKindPanelsSection(ctx.magiKindPanels);
+  if (magiSection) sections.push(magiSection);
   sections.push(TOOLS_SECTION);
   sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
   sections.push(WORKFLOW_SECTION);
@@ -3863,6 +3866,36 @@ function buildBrainPresetsSection() {
   }
   return lines.join("\n");
 }
+function buildMagiKindPanelsSection(panels) {
+  if (!panels) return null;
+  const configured = Object.entries(panels).filter(([, slots]) => Array.isArray(slots) && slots.length > 0);
+  if (configured.length === 0) return null;
+  const lines = [
+    "## Configured MAGI panels",
+    "",
+    "These machine-local MAGI kind-panels are configured on this mesh \u2014 read-only cross-verification quorums:",
+    ""
+  ];
+  for (const [kind, slots] of configured) {
+    const replicaCount = slots.reduce((sum, s2) => sum + (s2.n && s2.n > 0 ? s2.n : 1), 0);
+    const label = replicaCount === slots.length ? `${slots.length} ${slots.length === 1 ? "slot" : "slots"}` : `${replicaCount} replicas`;
+    const rendered = slots.map(renderMagiSlot).join(", ");
+    lines.push(`- **${kind}** (${label}): ${rendered}`);
+  }
+  lines.push("");
+  lines.push("Use these via `mesh_magi_review` (the `task_kind` is REQUIRED \u2014 it selects BOTH the output schema and the panel). The live authoritative slot list is `mesh_magi_kind_panel_list`. MAGI worker replicas are read-only and typically do NOT have mesh MCP tools exposed, so for live timing / tool-behavior claims you MUST gather the primary evidence yourself and use MAGI only for independent source-level corroboration.");
+  return lines.join("\n");
+}
+function renderMagiSlot(slot) {
+  let s2 = slot.provider;
+  if (slot.nodeId) s2 += `@${slot.nodeId}`;
+  const extra = [];
+  if (slot.model) extra.push(`model: ${slot.model}`);
+  if (slot.capabilityTags && slot.capabilityTags.length) extra.push(`tags: ${slot.capabilityTags.join("+")}`);
+  if (slot.n && slot.n > 1) extra.push(`\xD7${slot.n}`);
+  if (extra.length) s2 += ` (${extra.join(", ")})`;
+  return s2;
+}
 function buildPolicySection(policy) {
   const rules = [];
   if (policy.requirePreTaskCheckpoint) rules.push("- Create a git checkpoint **before** starting each task");
@@ -3889,7 +3922,7 @@ function buildRulesSection(coordinatorCliType) {
 
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator \u2014 keep context lean.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
-- **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
+- **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start a fresh session only when: (a) branch/worktree isolation is required, (b) the existing session had a dispatch failure or provider mismatch, (c) the transcript/runtime is contaminated or interrupted, or (d) the user explicitly asks for a different provider/session. Continuation of the same issue in an already-idle session is allowed and preferred \u2014 this rule blocks concurrent unrelated work interleaved into a live (still-generating) session, not sequential same-issue follow-ups.
 - **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` \u2014 the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
 - **Classify task difficulty to save tokens.** For each task you enqueue, judge its execution difficulty and pass \`difficulty\`: \`easy\` (extraction, renames, doc tweaks, trivial fixes), \`medium\` (ordinary feature/bugfix work), \`difficult\` (architecture, tricky debugging, multi-file refactors, subtle reasoning), or \`freeform\`. The mesh's per-difficulty brain preset then runs easy tasks on a cheaper model at low reasoning effort and hard tasks on a stronger model at high effort \u2014 real token savings on simple work. The current presets are shown in the "Brain presets" section below. You may still pass an explicit \`model\`/\`thinkingLevel\` to override the preset for one task.
 - **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.
@@ -3897,12 +3930,15 @@ function buildRulesSection(coordinatorCliType) {
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1\u20132 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load \u2014 it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).
 - **Check history first.** Call \`mesh_task_history\` at session start to avoid duplicate work and inform recovery. On failure, read task history before retrying.
+- **Don't reopen already-done work after a resume.** Before reopening a reported issue after context compaction or session resume, check current git state and recent session context. If another session has already completed the work, continue from the existing diff/commit instead of starting a duplicate investigation.
 - **Sequence shared-base-moving merges.** Parallel dispatch is encouraged, but merging one worktree can advance another in-flight worktree's base \u2014 especially a shared submodule pointer \u2014 turning a clean fast-forward into a diverged rebase (patch-equivalence correctly blocks this). Before merging an in-flight worktree while siblings are also in flight, land in an intentional order, re-clone long-running worktrees from the advanced base, or expect to manually rebase + ff-only the laggards; merging an independent fix mid-flight can strand siblings into a rebase.
 - **Converge branches.** After worktree tasks: refine/fast-forward, or classify as \`pushed_feature_branch_needs_merge\` / \`blocked_review\` / \`cleanup_candidate\` / \`not_mergeable\`. Clean up with \`mesh_remove_node\`.
 - **Refinery is config-driven.** \`mesh_refine_node\` must run validation from \`.adhdev/refine.{json,yaml,yml}\` or \`repo-mesh.refine.*\`. Heuristics are scaffolding only.
 - **Submodule reachability = publish-needed.** \`submodule_reachability_failed\` \u2192 classify as \`blocked_review\`, request user approval to push to submodule main, then rerun \`mesh_refine_node\`.
 - **Honor per-node instructions.** When a node carries a \u{1F4CC} Node instruction in the nodes section, include the relevant parts of that instruction in the task message you send to that node. Don't paraphrase the instruction into your own words \u2014 quote it verbatim so the worker agent sees exactly what the user wrote.
 - **Mission status does not update itself.** When a mission's tasks are all done or the work is abandoned, explicitly call \`mesh_mission_upsert\` to set status \`completed\` or \`abandoned\`. Never leave a finished mission in \`active\`. All-cancelled tasks with no further work \u2192 \`abandoned\`.
+- **Don't spawn a nested coordinator for simple inspection.** Do not spawn a nested coordinator-like agent for simple inspection tasks. If delegation is required, use explicit provider selection and a fully self-contained, bounded task instruction.
+- **Keep internal traffic out of the transcript.** Internal tool calls, status events, control messages, and debug output must not appear as ordinary user-visible chat transcript content unless explicitly marked user-facing by the producing agent.
 - **Never fabricate tool results.** Always call the actual tool.
 - **Keep the user informed.** One or two sentences after each delegation round.${coordinatorNote}
 
@@ -4004,7 +4040,9 @@ Follow these recovery rules:
 1. **If "Retry recommended"**: Check \`mesh_view_queue\` first \u2014 the daemon may have auto-requeued. If not, re-launch the session on the same node (\`mesh_launch_session\`), then resend the original task (\`mesh_send_task\`). The system message includes the original task text.
 2. **If "Max retries exceeded"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.
 3. **If no recovery context**: The stop may be intentional (normal completion). Use \`mesh_read_chat\` once to verify, then move on.
-4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
+4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.
+5. **Stuck-but-done vs actually-stuck**: If a delegated session appears stuck but has already produced a verified final summary or diff, stop polling noisy tool/terminal transcript bubbles. Verify with \`mesh_git_status\` or a checkpoint and proceed to landing.
+6. **Refinery falsely blocks a verified-clean branch \u2014 manual fast-forward convergence**: When \`mesh_refine_node\` falsely blocks a verified-clean branch (stale preflight, or the submodule-gitlink trivial-fast-forward misjudgment), bypass the refine tool and converge by strict fast-forward \u2014 (1) rebase the submodule commit onto the submodule \`origin/main\`, (2) push the submodule ff-only (verify \`git merge-base --is-ancestor\` first), (3) rebase the root branch and re-bump the submodule pointer so the root diff stays non-empty, (4) push the root ff-only. NEVER force-push or reset; abort and report on any non-fast-forward.`;
     ONBOARDING_SECTION = `## Onboarding / Reinit
 
 When the user asks to **set up / configure / onboard** this repo for Repo Mesh (or to **re-init / reconfigure** an already-onboarded repo), run ONE guided, approval-gated conversation. You draft, the user approves, the daemon writes. Never auto-write a heuristic suggestion without an explicit user approval turn.
@@ -15537,6 +15575,32 @@ var init_mesh_clone_grace = __esm({
   }
 });
 
+// src/mesh/model-provider-compat.ts
+function isAnthropicProvider(providerType) {
+  const p = typeof providerType === "string" ? providerType.trim().toLowerCase() : "";
+  return p.length > 0 && ANTHROPIC_PROVIDER_TYPES.has(p);
+}
+function isAnthropicModel(model) {
+  const m = typeof model === "string" ? model.trim().toLowerCase() : "";
+  if (!m) return false;
+  if (m.startsWith("claude") || m.startsWith("anthropic")) return true;
+  return /^(opus|sonnet|haiku)(\b|[-_])/.test(m);
+}
+function isModelCompatibleWithProvider(model, providerType) {
+  if (!isAnthropicModel(model)) return true;
+  if (isAnthropicProvider(providerType)) return true;
+  return false;
+}
+var ANTHROPIC_PROVIDER_TYPES;
+var init_model_provider_compat = __esm({
+  "src/mesh/model-provider-compat.ts"() {
+    "use strict";
+    ANTHROPIC_PROVIDER_TYPES = /* @__PURE__ */ new Set([
+      "claude-cli"
+    ]);
+  }
+});
+
 // src/mesh/mesh-queue-assignment.ts
 import { existsSync as existsSync18 } from "fs";
 function localCoordinatorDaemonId() {
@@ -16514,8 +16578,12 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           markAutoLaunch(meshId, task.id, { status: "skipped", reason: resolved.reason || "provider_unusable", nodeId });
           continue;
         }
-        const effectiveModel = typeof task.model === "string" && task.model.trim() ? task.model.trim() : resolved.model;
+        const rawEffectiveModel = typeof task.model === "string" && task.model.trim() ? task.model.trim() : resolved.model;
         const effectiveThinkingLevel = typeof task.thinkingLevel === "string" && task.thinkingLevel.trim() ? task.thinkingLevel.trim() : resolved.thinkingLevel;
+        const effectiveModel = isModelCompatibleWithProvider(rawEffectiveModel, resolved.providerType) ? rawEffectiveModel : void 0;
+        if (rawEffectiveModel && effectiveModel === void 0) {
+          LOG.info("MeshQueue", `CODEX-400 GUARD: dropped incompatible launch model '${rawEffectiveModel}' for non-Anthropic provider '${resolved.providerType}' on node ${nodeId} (task ${task.id}); provider will use its own default model`);
+        }
         const providerCap = resolveProviderMaxParallel(node?.policy, resolved.providerType);
         if (providerCap !== void 0 && activeProviderAssignedCount(meshId, nodeId, resolved.providerType) >= providerCap) {
           markAutoLaunch(meshId, task.id, { status: "skipped", reason: "max_provider_parallel_reached", nodeId, providerType: resolved.providerType });
@@ -16846,6 +16914,7 @@ var init_mesh_queue_assignment = __esm({
     init_worktree_bootstrap_config();
     init_mesh_clone_grace();
     init_mesh_task_inflight();
+    init_model_provider_compat();
     IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
     idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
     BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
@@ -56988,6 +57057,14 @@ var meshCoordinatorLaunchHandlers = {
           return void 0;
         }
       };
+      const loadMagiKindPanelsBestEffort = async () => {
+        try {
+          const { listMagiKindPanels: listMagiKindPanels2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+          return listMagiKindPanels2();
+        } catch {
+          return void 0;
+        }
+      };
       let mesh;
       if (args?.inlineMesh && typeof args.inlineMesh === "object") {
         mesh = args.inlineMesh;
@@ -57085,7 +57162,7 @@ var meshCoordinatorLaunchHandlers = {
       if (coordinatorSetup.kind === "cli_command") {
         let cliCmdSystemPrompt = "";
         try {
-          cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id) });
+          cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
         } catch (error) {
           const message = error?.message || String(error);
           LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
@@ -57264,7 +57341,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       let systemPrompt = "";
       try {
-        systemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id) });
+        systemPrompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || void 0, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
       } catch (error) {
         const message = error?.message || String(error);
         LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);