@adhdev/daemon-core 0.9.82-rc.505 → 0.9.82-rc.507

package/dist/mesh/coordinator-prompt.d.ts

@@ -21,6 +21,7 @@
  * a static prompt, which is also fine.
  */
 import type { LocalMeshEntry, RepoMeshStatus } from '../repo-mesh-types.js';
+import type { MagiKindPanelMap } from '@adhdev/mesh-shared';
 /**
  * Cheap, locally-derived "what just happened" snapshot for the coordinator
  * prompt. Built at launch from the local ledger + work-queue stats — no remote
@@ -91,5 +92,25 @@ export interface CoordinatorPromptContext {
      * section.
      */
     operatingNotes?: CoordinatorOperatingNote[];
+    /**
+     * Machine-local MAGI kind-panel bindings (`~/.adhdev/meshes.json`
+     * `magiKindPanels`), read live at launch. Omitted / empty / all-empty →
+     * no "## Configured MAGI panels" section, so a mesh with no MAGI configured
+     * renders identically to before. Threaded in the same systematic way as the
+     * brain presets: read machine-local config at launch, render a pure section.
+     */
+    magiKindPanels?: MagiKindPanelMap;
 }
 export declare function buildCoordinatorSystemPrompt(ctx: CoordinatorPromptContext): string;
+/**
+ * Render the machine-local MAGI kind-panel bindings so the coordinator KNOWS
+ * which cross-verification panels (rca / design / claim_audit / freeform) are
+ * actually configured on this machine. Without this the coordinator only sees
+ * the `mesh_magi_*` tools in the static table and has no idea MAGI is set up.
+ *
+ * Pure — takes the panels map (read live at launch, mirroring how brain presets
+ * read getDifficultyBrains). Returns null (section OMITTED) when nothing usable
+ * is configured: undefined/null map, or every kind maps to an empty slot list.
+ * That keeps a MAGI-less mesh's prompt byte-identical to before.
+ */
+export declare function buildMagiKindPanelsSection(panels: MagiKindPanelMap | undefined | null): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.505",
+  "version": "0.9.82-rc.507",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.505",
-    "@adhdev/session-host-core": "0.9.82-rc.505",
+    "@adhdev/mesh-shared": "0.9.82-rc.507",
+    "@adhdev/session-host-core": "0.9.82-rc.507",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -138,6 +138,19 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         } catch { return undefined; }
                     };
 
+                    // MAGI panels: load the machine-local kind-panel bindings so the
+                    // coordinator prompt auto-lists which cross-verification panels
+                    // (rca / design / claim_audit / freeform) are configured. Same
+                    // systematic pattern as the brain presets — read machine-local
+                    // config at launch. Best-effort: a read failure or empty map just
+                    // omits the "## Configured MAGI panels" section.
+                    const loadMagiKindPanelsBestEffort = async () => {
+                        try {
+                            const { listMagiKindPanels } = await import('../../config/mesh-config.js');
+                            return listMagiKindPanels();
+                        } catch { return undefined; }
+                    };
+
                     // Support inline mesh data from cloud (bypasses local meshes.json lookup)
                     let mesh: any;
                     if (args?.inlineMesh && typeof args.inlineMesh === 'object') {
@@ -264,7 +277,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         // Build coordinator prompt first — fail closed on errors.
                         let cliCmdSystemPrompt = '';
                         try {
-                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id) });
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
                         } catch (error: any) {
                             const message = error?.message || String(error);
                             LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
@@ -484,7 +497,7 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                     // broken mesh state is visible instead of silently launching with weaker rules.
                     let systemPrompt = '';
                     try {
-                        systemPrompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id) });
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined, missionSection: buildMissionSectionBestEffort(mesh.id), recentActivity: await buildRecentActivityBestEffort(mesh.id), operatingNotes: await buildEffectiveOperatingNotes(mesh.id), magiKindPanels: await loadMagiKindPanelsBestEffort() });
                     } catch (error: any) {
                         const message = error?.message || String(error);
                         LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);

package/src/mesh/coordinator-prompt.ts

@@ -34,6 +34,7 @@ import type {
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
 import { getDifficultyBrains } from '../config/mesh-config.js';
 import { MESH_TASK_DIFFICULTIES } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, MagiSlot, MagiTaskKind } from '@adhdev/mesh-shared';
 
 /**
  * Cheap, locally-derived "what just happened" snapshot for the coordinator
@@ -109,6 +110,14 @@ export interface CoordinatorPromptContext {
      * section.
      */
     operatingNotes?: CoordinatorOperatingNote[];
+    /**
+     * Machine-local MAGI kind-panel bindings (`~/.adhdev/meshes.json`
+     * `magiKindPanels`), read live at launch. Omitted / empty / all-empty →
+     * no "## Configured MAGI panels" section, so a mesh with no MAGI configured
+     * renders identically to before. Threaded in the same systematic way as the
+     * brain presets: read machine-local config at launch, render a pure section.
+     */
+    magiKindPanels?: MagiKindPanelMap;
 }
 
 /**
@@ -284,6 +293,11 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
     // ── Brain presets (difficulty → model/thinking) ──
     sections.push(buildBrainPresetsSection());
 
+    // ── Configured MAGI panels (machine-local magiKindPanels) — only present
+    //     when at least one task_kind has a non-empty slot list. ──
+    const magiSection = buildMagiKindPanelsSection(ctx.magiKindPanels);
+    if (magiSection) sections.push(magiSection);
+
     // ── Tools ──
     sections.push(TOOLS_SECTION);
 
@@ -634,6 +648,58 @@ function buildBrainPresetsSection(): string {
     return lines.join('\n');
 }
 
+/**
+ * Render the machine-local MAGI kind-panel bindings so the coordinator KNOWS
+ * which cross-verification panels (rca / design / claim_audit / freeform) are
+ * actually configured on this machine. Without this the coordinator only sees
+ * the `mesh_magi_*` tools in the static table and has no idea MAGI is set up.
+ *
+ * Pure — takes the panels map (read live at launch, mirroring how brain presets
+ * read getDifficultyBrains). Returns null (section OMITTED) when nothing usable
+ * is configured: undefined/null map, or every kind maps to an empty slot list.
+ * That keeps a MAGI-less mesh's prompt byte-identical to before.
+ */
+export function buildMagiKindPanelsSection(panels: MagiKindPanelMap | undefined | null): string | null {
+    if (!panels) return null;
+    // Keep only kinds with a non-empty slot list; drop empty/undefined bindings.
+    const configured = (Object.entries(panels) as Array<[MagiTaskKind, MagiSlot[] | undefined]>)
+        .filter(([, slots]) => Array.isArray(slots) && slots.length > 0) as Array<[MagiTaskKind, MagiSlot[]]>;
+    if (configured.length === 0) return null;
+
+    const lines = [
+        '## Configured MAGI panels',
+        '',
+        'These machine-local MAGI kind-panels are configured on this mesh — read-only cross-verification quorums:',
+        '',
+    ];
+
+    for (const [kind, slots] of configured) {
+        const replicaCount = slots.reduce((sum, s) => sum + (s.n && s.n > 0 ? s.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 — 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');
+}
+
+/** Render one MAGI slot as `provider[@nodeId][ (model, tags…, xN)]`. */
+function renderMagiSlot(slot: MagiSlot): string {
+    let s = slot.provider;
+    if (slot.nodeId) s += `@${slot.nodeId}`;
+    const extra: string[] = [];
+    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(`×${slot.n}`);
+    if (extra.length) s += ` (${extra.join(', ')})`;
+    return s;
+}
+
 function buildPolicySection(policy: RepoMeshPolicy): string {
     const rules: string[] = [];
     if (policy.requirePreTaskCheckpoint) rules.push('- Create a git checkpoint **before** starting each task');

package/src/mesh/mesh-event-forwarding.ts

@@ -16,7 +16,7 @@ import { enqueueUnresolvedDelegateForward, nudgeUnresolvedForwardRetry } from '.
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { getLastDisplayMessage } from '../status/snapshot.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
-import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
+import { meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, sessionIdsEquivalent, withStatusProbeMarker, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
     findTerminalLedgerEvidenceForTask,
@@ -760,7 +760,15 @@ function stopStaleMeshWorker(
             } catch { /* best-effort */ }
         }
         if (daemonId && components.dispatchMeshCommand) {
-            Promise.resolve(components.dispatchMeshCommand(daemonId, 'stop_cli', stopArgs))
+            // OFFLINE-NODE-BLOCKING: this stop is fire-and-forget. Without a short connect-wait,
+            // a stop_cli to a worker node whose daemon is powered off leaves a pending request
+            // hanging for the full 90s connect deadline before its .catch fires (a leaked
+            // pending per stale worker). Stamp the status-origin marker so the daemon-cloud relay
+            // grants the SHORT connect-wait budget — an offline node rejects in ~2s and the .catch
+            // logs it immediately. The marker only affects the connect wait and is stripped before
+            // stop_cli executes, so a live worker is stopped identically. (Best-effort by design:
+            // a failed stop only loses the belt-and-suspenders stop; the ack was already rejected.)
+            Promise.resolve(components.dispatchMeshCommand(daemonId, 'stop_cli', withStatusProbeMarker(stopArgs)))
                 .catch((e: any) => LOG.warn('MeshQueue', `Remote stop of stale worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
         } else {
             LOG.warn('MeshQueue', `Cannot stop stale worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${args.nodeId ?? '?'}). Ack already rejected — task will re-strand-and-fail if the worker completes.`);

package/src/mesh/mesh-queue-assignment.ts

@@ -15,7 +15,7 @@ import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
 import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, deriveSlotsFromLegacy, normalizeNodeCapabilitySlots, isMeshTaskDifficulty, type MeshNodeIdentified, type NodeCapabilitySlot, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
+import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, canonicalDaemonId, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, sessionIdsEquivalent, deriveSlotsFromLegacy, normalizeNodeCapabilitySlots, isMeshTaskDifficulty, withStatusProbeMarker, type MeshNodeIdentified, type NodeCapabilitySlot, type MeshTaskDifficulty } from '@adhdev/mesh-shared';
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 import { readMeshNodeDaemonId } from './mesh-node-identity.js';
@@ -2100,7 +2100,15 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                     markAutoLaunch(meshId, task.id, { status: 'started', nodeId, providerType: resolved.providerType });
                     let launchResult: any;
                     try {
-                        launchResult = await components.dispatchMeshCommand!(launchTarget.daemonId!, 'launch_cli', {
+                        // OFFLINE-NODE-BLOCKING: no peer-connected pre-check before this remote
+                        // launch_cli meant an OFFLINE target node sank the dispatch into the 90s
+                        // connect deadline, stalling the 4s auto-launch loop for a full 90s. Stamp
+                        // the status-origin marker so the daemon-cloud relay grants the SHORT
+                        // connect-wait budget — an offline node throws in ~2s, the catch below sets
+                        // the 25s cooldown (autoLaunchCooldownUntil) that already gates retries, so
+                        // the loop moves on. The marker only affects the connect wait and is
+                        // stripped before launch_cli executes, so a live node spawns identically.
+                        launchResult = await components.dispatchMeshCommand!(launchTarget.daemonId!, 'launch_cli', withStatusProbeMarker({
                             cliType: resolved.providerType,
                             dir: node.workspace,
                             settings: remoteSettings,
@@ -2110,7 +2118,7 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                             ...(effectiveModel ? { initialModel: effectiveModel } : {}),
                             // BRAIN-ROUTING thinking axis: forward the effective thinking level (initialThinkingLevel).
                             ...(effectiveThinkingLevel ? { initialThinkingLevel: effectiveThinkingLevel } : {}),
-                        });
+                        }));
                     } catch (e: any) {
                         markAutoLaunch(meshId, task.id, { status: 'failed', reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
                         autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS); sweepExpiredCooldowns();

package/src/mesh/mesh-reconcile-loop.ts

@@ -59,7 +59,7 @@ import {
 } from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
-import { expandDaemonIdForms, daemonIdsEquivalent, sessionIdsEquivalent, meshNodeIdMatches } from '@adhdev/mesh-shared';
+import { expandDaemonIdForms, daemonIdsEquivalent, sessionIdsEquivalent, meshNodeIdMatches, withStatusProbeMarker } from '@adhdev/mesh-shared';
 import { getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
 import { resolveSessionBusyVerdict } from './mesh-queue-assignment.js';
 import { readLedgerEntries } from './mesh-ledger.js';
@@ -1637,7 +1637,15 @@ async function retryUnresolvedDelegateForwards(components: DaemonComponents): Pr
         let result: any;
         try {
             traceMeshEventStage('forward_send', entryTraceCtx, `retry → ${entry.coordinatorDaemonId}`);
-            result = await dispatchMeshCommand(entry.coordinatorDaemonId, 'mesh_forward_event', pushPayload);
+            // OFFLINE-NODE-BLOCKING: stamp the status-origin marker so the daemon-cloud relay
+            // grants the SHORT connect-wait budget. Without it, a retry to a coordinator whose
+            // daemon is powered off sinks into the 90s connect deadline per entry, serializing
+            // the whole unresolved-forward outbox behind one dead coordinator. With it, the
+            // dispatch throws in ~2s and the entry is left queued for the next tick — the
+            // existing retry-backoff and age-expiry below are unchanged. The marker only
+            // affects the connect wait and is stripped before mesh_forward_event executes, so
+            // delivery semantics are identical.
+            result = await dispatchMeshCommand(entry.coordinatorDaemonId, 'mesh_forward_event', withStatusProbeMarker(pushPayload));
         } catch (e: any) {
             // Coordinator unreachable (transport threw) — keep the entry queued and try again
             // next tick. This is NOT a hard rejection, so it does not count toward the cap;