@adhdev/daemon-core 0.9.82-rc.482 → 0.9.82-rc.483

package/dist/config/mesh-config.d.ts

@@ -121,6 +121,11 @@ export declare function removeNode(meshId: string, nodeId: string): boolean;
 export declare function updateNode(meshId: string, nodeId: string, opts: {
     userOverrides?: Partial<RepoMeshNodeCapabilities>;
     policy?: RepoMeshNodePolicy;
+    /** Operator-defined custom capability tags used by mesh queue matching.
+     *  Passing an array replaces the node's custom tags (empty/whitespace
+     *  entries dropped, deduped); an empty result clears them. Omit to leave
+     *  the existing tags untouched. */
+    capabilities?: string[];
     worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
     /** Per-node instruction surfaced in the coordinator prompt. Pass an
      *  empty string or undefined to clear it. */

package/dist/index.js

@@ -188,7 +188,7 @@ var init_repo_mesh_types = __esm({
       "checkpoint_then_continue"
     ]);
     MESH_MAX_PARALLEL_TASKS_MIN = 1;
-    MESH_MAX_PARALLEL_TASKS_MAX = 8;
+    MESH_MAX_PARALLEL_TASKS_MAX = 64;
     DEFAULT_MESH_READONLY_MULTIPLIER = 2;
   }
 });
@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "5c311ee659d4fe9b1638a1bb325b681ef6ecc24e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "5c311ee6" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.482" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-08T00:15:56.441Z" : void 0);
+  const commit = readInjected(true ? "0862a3f10fa9de60a46591c0894a7209534db2e2" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "0862a3f1" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.483" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-08T04:27:00.139Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3309,6 +3309,11 @@ function updateNode(meshId, nodeId, opts) {
     node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
   }
   if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+  if (Object.prototype.hasOwnProperty.call(opts, "capabilities")) {
+    const tags = normalizeCapabilityTags(opts.capabilities);
+    if (tags && tags.length) node.capabilities = tags;
+    else delete node.capabilities;
+  }
   if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
   if (Object.prototype.hasOwnProperty.call(opts, "systemPrompt")) {
     if (opts.systemPrompt && opts.systemPrompt.trim()) {
@@ -3601,6 +3606,21 @@ function buildNodeConfigSection(mesh) {
     }).filter(Boolean) : [];
     const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(", ")}` : "";
     lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ""}${providerPriority}${providerRolesSuffix}${suffix}`);
+    const routingTags = [];
+    const custom = Array.isArray(n.capabilities) ? n.capabilities : [];
+    for (const t of custom) {
+      const s2 = typeof t === "string" ? t.trim() : "";
+      if (s2) routingTags.push(s2);
+    }
+    const tagOs = (n.userOverrides?.platform || n.reportedPlatform || "").toString().trim();
+    const tagArch = (n.userOverrides?.arch || n.reportedArch || "").toString().trim();
+    if (tagOs) routingTags.push(`os=${tagOs}`);
+    if (tagArch) routingTags.push(`arch=${tagArch}`);
+    const wtBranch = typeof n.worktreeBranch === "string" ? n.worktreeBranch.trim() : "";
+    if (n.isLocalWorktree && wtBranch) routingTags.push(`worktree=${wtBranch}`);
+    if (routingTags.length) {
+      lines.push(`  \u{1F3F7}\uFE0F routing tags: ${routingTags.map((t) => `\`${t}\``).join(", ")}`);
+    }
     const nodePrompt = typeof n.systemPrompt === "string" ? n.systemPrompt.trim() : "";
     if (nodePrompt) {
       lines.push(`  \u{1F4CC} Node instruction: ${indentFollowing(nodePrompt, "     ")}`);
@@ -3702,6 +3722,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.
+- **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.
 - **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.
 - **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).
@@ -3791,6 +3812,7 @@ Before doing any coordinator work, confirm that the actual callable tool list in
 3. **Queue / Delegate** \u2014 The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   b1. **Keep a branch's work on its worktree (worktree affinity).** A worktree node is a durable per-branch workspace, not a one-task throwaway \u2014 implement, review, and fix for the same branch all belong on the SAME worktree, and it lives until its work is converged (merged/pushed) and it is cleaned up. So once you clone a worktree for a branch, route every subsequent \`code_change\`/\`validation\`/fix task for that branch back to that same node: pass \`required_tags: ["worktree=<branch>"]\` or \`target_node_id: <that worktree node's id>\`. **Where to get the node id / tag:** the \`mesh_clone_node\` result returns the new node's \`id\` and \`worktreeBranch\` directly \u2014 use them immediately. The Configured Nodes list in this prompt is a launch-time snapshot and will NOT list a worktree you cloned after this session started, so do not rely on it for freshly-cloned worktrees; take the id/branch from the \`mesh_clone_node\` result, or call \`mesh_status\` to re-list the live nodes (each worktree there advertises its \`worktree=<branch>\` tag). Do NOT leave same-branch follow-ups untargeted \u2014 an untargeted task is claimed by whichever node polls first (usually the base machine node), which strands the work off the branch's worktree. The ONE exception is a \`convergence\` task (merge/push): that is base-only and must NOT be pinned to the worktree.
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    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.
@@ -4241,6 +4263,9 @@ function shouldDeliverPendingEventToCoordinator(event, drainer) {
   if (!event.intendedFor) return false;
   return coordinatorIdentityEquals(event.intendedFor, drainer);
 }
+function isTerminalTaskEvent(eventName) {
+  return TERMINAL_TASK_EVENTS.has(eventName);
+}
 function defaultScopeForEvent(eventName) {
   if (TERMINAL_TASK_EVENTS.has(eventName) || COORDINATOR_ALERT_EVENTS.has(eventName)) return "unicast";
   return "broadcast";
@@ -4257,7 +4282,11 @@ function buildPendingEventEmitStamp(opts) {
   let scope = opts.scope ?? defaultScopeForEvent(opts.eventName);
   let intendedFor = opts.intendedFor;
   if (scope === "unicast" && !intendedFor) {
-    scope = "broadcast";
+    if (isTerminalTaskEvent(opts.eventName)) {
+      intendedFor = opts.dispatchedBy;
+    } else {
+      scope = "broadcast";
+    }
   }
   if (scope !== "unicast") intendedFor = void 0;
   return {
@@ -8412,6 +8441,16 @@ function routeV2EventsForDrainer(events, drainer, ctx) {
       continue;
     }
     if (validated.scope !== "unicast") {
+      if (validated.scope === "broadcast" && isTerminalTaskEvent(validated.event)) {
+        if (identityDeliversTo(validated.dispatchedBy, drainer)) {
+          ctx.batchSeen.add(eventId);
+          bump("v2Delivered");
+          kept.push(event);
+        } else {
+          bump("v2RoutedAway");
+        }
+        continue;
+      }
       if (shouldDeliverPendingEventToCoordinator(validated, drainer)) {
         ctx.batchSeen.add(eventId);
         bump("v2Delivered");
@@ -40179,6 +40218,53 @@ var statusMetaHandlers = {
 
 // src/commands/low-family/coordinator-prompt.ts
 var coordinatorPromptHandlers = {
+  /**
+   * Render the coordinator system prompt for a mesh + CLI type, so the
+   * dashboard can show the operator exactly what a coordinator session
+   * receives by default. This resolves the mesh, applies its repo-mesh
+   * config, and runs the SAME buildCoordinatorSystemPrompt the launch path
+   * uses — minus the runtime-only best-effort sections (mission / recent
+   * activity / operating notes), which are launch-scope and not part of the
+   * static "default base" an operator is trying to preview here.
+   *
+   * It respects mesh-level and user-file override/append layering, so the
+   * preview reflects the effective prompt: with no overrides configured it
+   * shows the pure daemon default; with an override set it shows that.
+   */
+  coordinator_prompt_preview: async (ctx, args) => {
+    const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+    const cliType = typeof args?.cliType === "string" && args.cliType.trim() ? args.cliType.trim() : "claude-cli";
+    if (!meshId) return { success: false, error: "meshId required" };
+    try {
+      let mesh = null;
+      if (ctx.getMeshForCommand) {
+        const resolved = await ctx.getMeshForCommand(meshId);
+        mesh = resolved?.mesh ?? null;
+      }
+      if (!mesh) {
+        const { getMesh: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+        mesh = getMesh2(meshId);
+      }
+      if (!mesh) return { success: false, error: `mesh not found: ${meshId}` };
+      let effectiveMesh = mesh;
+      try {
+        const { loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2, applyRepoMeshConfig: applyRepoMeshConfig2 } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+        const workspace = typeof mesh?.workspace === "string" ? mesh.workspace : void 0;
+        if (workspace) {
+          const loaded = loadRepoMeshJsonConfig2(workspace);
+          if (loaded?.sourceType !== "invalid") {
+            effectiveMesh = applyRepoMeshConfig2(mesh, loaded?.config);
+          }
+        }
+      } catch {
+      }
+      const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+      const prompt = buildCoordinatorSystemPrompt2({ mesh: effectiveMesh, coordinatorCliType: cliType });
+      return { success: true, prompt, cliType, meshId, bytes: Buffer.byteLength(prompt, "utf8") };
+    } catch (error) {
+      return { success: false, error: error?.message || String(error) };
+    }
+  },
   list_coordinator_prompts: async (_ctx, _args) => {
     const fs41 = await import("fs");
     const path45 = await import("path");
@@ -54816,13 +54902,15 @@ var meshCrudHandlers = {
       const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
       const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
       const repoRoot = typeof args?.repoRoot === "string" && args.repoRoot.trim() ? args.repoRoot.trim() : void 0;
+      const capabilities = Array.isArray(args?.capabilities) ? args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean) : void 0;
       const node = addNode2(meshId, {
         workspace,
         ...repoRoot ? { repoRoot } : {},
         ...daemonId ? { daemonId } : {},
         ...machineId ? { machineId } : {},
         ...policy ? { policy } : {},
-        ...role ? { role } : {}
+        ...role ? { role } : {},
+        ...capabilities && capabilities.length ? { capabilities } : {}
       });
       if (!node) return { success: false, error: "Mesh not found" };
       ctx.invalidateAggregateMeshStatus(meshId);
@@ -54864,6 +54952,9 @@ var meshCrudHandlers = {
       } else if (args?.systemPrompt === null) {
         patch.systemPrompt = void 0;
       }
+      if (Array.isArray(args?.capabilities)) {
+        patch.capabilities = args.capabilities.map((t) => typeof t === "string" ? t.trim() : "").filter(Boolean);
+      }
       const node = updateNode2(meshId, nodeId, patch);
       if (!node) return { success: false, error: "Mesh node not found" };
       ctx.invalidateAggregateMeshStatus(meshId);