@adhdev/daemon-core 0.9.82-rc.424 → 0.9.82-rc.426

package/package.json

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

package/src/commands/med-family/mesh-crud.ts

@@ -222,6 +222,64 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         }
     },
 
+    // ─── MAGI panels (machine-local config, sibling to meshes) ───────────────
+    // Panels live in ~/.adhdev/meshes.json `magiPanels` and are pure local config
+    // (no mesh ownership). These three handlers mirror list_meshes/create_mesh/
+    // update_mesh: dynamic-import the already-exported mesh-config accessors and
+    // surface normalizeMagiPanel's structured error codes (invalid_magi_panel,
+    // magi_panel_exists) verbatim so the dashboard can render them.
+    //
+    // Permission: magi_panel_set / magi_panel_remove are WRITE commands. They are
+    // intentionally NOT listed in canPeerUsePrivilegedShareCommand (daemon-cloud
+    // data-channel-router), so a peer holding ANY share permission hits its
+    // `default → false` branch — identical owner-only gating to create_mesh /
+    // update_mesh / list_meshes (none of which are listed there either). A trusted
+    // peer (no permission = the owner) passes the top `!permission → true` guard.
+    // Mirror, don't invent: do not add a new policy tier here.
+    //
+    // Resolvability (coupling / stale / available) is deliberately NOT computed
+    // here: buildMagiFanoutPlan lives in mcp-server, unreachable from daemon-core.
+    // magi_panel_list returns the raw definitions only; the dashboard derives
+    // member resolvability client-side (web-core MagiPanelManager, reusing the
+    // MagiGroupRow coupling logic) against live mesh_status.
+    magi_panel_list: async (_ctx: MedFamilyContext, _args: any) => {
+        try {
+            const { listMagiPanels } = await import('../../config/mesh-config.js');
+            return { success: true, panels: listMagiPanels() };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
+    magi_panel_set: async (_ctx: MedFamilyContext, args: any) => {
+        const name = typeof args?.name === 'string' ? args.name.trim() : '';
+        if (!name) return { success: false, error: 'invalid_magi_panel: panel name is required' };
+        try {
+            const { upsertMagiPanel } = await import('../../config/mesh-config.js');
+            // normalizeMagiPanel (invoked inside upsertMagiPanel) validates members,
+            // enforces MAX_MAGI_PANEL_MEMBERS, and clamps replica counts. Its
+            // invalid_magi_panel / magi_panel_exists messages flow back as `error`.
+            const panel = upsertMagiPanel(name, args?.panel, { overwrite: args?.overwrite === true });
+            return { success: true, name, panel };
+        } catch (e: any) {
+            // Surface the structured code (invalid_magi_panel: … / magi_panel_exists: …)
+            // verbatim so the editor can map it to a field-level message.
+            return { success: false, error: e.message };
+        }
+    },
+
+    magi_panel_remove: async (_ctx: MedFamilyContext, args: any) => {
+        const name = typeof args?.name === 'string' ? args.name.trim() : '';
+        if (!name) return { success: false, error: 'invalid_magi_panel: panel name is required' };
+        try {
+            const { removeMagiPanel } = await import('../../config/mesh-config.js');
+            const removed = removeMagiPanel(name);
+            return { success: true, removed };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
     add_mesh_node: async (ctx: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';

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

@@ -44,7 +44,7 @@ import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 import { loadConfig } from '../config/config.js';
 import { listMeshes } from '../config/mesh-config.js';
-import { LOG } from '../logging/logger.js';
+import { LOG, getLogLevel } from '../logging/logger.js';
 import { drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, buildPendingEventFingerprint, queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
@@ -319,6 +319,38 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
             ? (inst as any).isModalParked() === true
             : (status === 'waiting_choice' || status === 'waiting_approval');
         const sessionId = readNonEmptyString(state.instanceId);
+        // ── NOTIF (B) desync diagnostic (read-only, no behavior change) ───────────
+        // The confirmed (B) defect: a coordinator whose FSM is idle (status above ===
+        // 'idle' for minutes) is nonetheless classified busy here, so the generating/
+        // modal-park hold never drains and a worker completion is stranded until the
+        // user's next turn edge. Static analysis found no code path where getState()
+        // returns generating while lastStatus and the adapter raw are both idle — so the
+        // divergence is a runtime desync between the three status sources. Capture all
+        // three (plus the auto-approve mask state that getState() overlays at :803) for
+        // EVERY mesh-coordinator candidate on this tick, so the source that diverges from
+        // the others can be read directly against the same-tick "skip → generating"/
+        // "skip → modal-parked" hold logs below (pair by sessionId + timestamp).
+        //
+        // CRITICAL: reuse the `state` already fetched above (line ~301) — do NOT call
+        // getState() again. getState() runs maybeAutoApproveStatus() as a side effect,
+        // which would mutate the very auto-approve mask we are trying to observe. The
+        // adapter raw read uses allowParse:false, which only reads engine.activeModal and
+        // is side-effect-free.
+        if (getLogLevel() === 'debug') {
+            let adapterRaw = '?';
+            try {
+                const a = (inst as any).adapter;
+                if (a && typeof a.getStatus === 'function') {
+                    adapterRaw = readNonEmptyString(a.getStatus({ allowParse: false })?.status) || '?';
+                }
+            } catch (e: any) {
+                adapterRaw = `err:${e?.message || e}`;
+            }
+            const lastStatus = readNonEmptyString((inst as any).lastStatus) || '?';
+            const autoApproveBusy = (inst as any).autoApproveBusy;
+            const maskSince = (inst as any).autoApproveMaskSince;
+            LOG.debug('MeshReconcile', `coordDiag sess=${sessionId || '?'} mesh=${meshId} getState=${status || '?'} lastStatus=${lastStatus} adapterRaw=${adapterRaw} autoApproveBusy=${autoApproveBusy === true} maskSince=${maskSince || 0}`);
+        }
         // Modal-park transition observability: a coordinator entering modal-park is what
         // begins holding completion events under `modal_parked`; one leaving it is what
         // drains them. Both transitions were previously SILENT (the operator had no log
@@ -902,6 +934,12 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
                     }
                 }
                 LOG.info('MeshReconcile', `Reconcile skip → modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued${orphanEscaped > 0 ? `; ${orphanEscaped} orphan-targeted event(s) routed to strict-route TTL` : ''})`);
+                // NOTIF (B) diagnostic: name the session(s) classified modal-parked so the
+                // same-tick coordDiag line (paired by sessionId) shows whether the modal-park
+                // overlay is a real human-await or an unreleased mask (the getState_overlay origin).
+                if (getLogLevel() === 'debug') {
+                    LOG.debug('MeshReconcile', `coordHoldModalParked mesh=${meshId} heldFor=[${modalParkedCoordinators.map(c => c.sessionId || '?').join(',')}] (these were classified modal-parked; cross-ref same-tick coordDiag by sessionId)`);
+                }
                 // C1: mirror held terminal events into the ledger so a held completion's
                 // worker summary is auditable/recoverable even if the modal is never
                 // resolved, the coordinator restarts, or the pending file is later trimmed.
@@ -937,6 +975,14 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
                 }
                 if (hasPending) {
                     LOG.info('MeshReconcile', `Reconcile skip → generating: holding pending event(s) for mesh ${meshId} (${generatingCoordinators.length} coordinator(s) busy; events left queued for the next idle tick)`);
+                    // NOTIF (B) diagnostic: this is the hold that strands the completion. Name
+                    // the sessionId(s) the loop just classified non-idle/non-modal so the
+                    // same-tick coordDiag line above (paired by sessionId) reveals which status
+                    // source diverged. If a coordDiag for one of these sessions shows getState
+                    // (or lastStatus/adapterRaw) === idle, that is the runtime desync origin.
+                    if (getLogLevel() === 'debug') {
+                        LOG.debug('MeshReconcile', `coordHoldGenerating mesh=${meshId} heldFor=[${generatingCoordinators.map(c => c.sessionId || '?').join(',')}] (these were classified busy; cross-ref same-tick coordDiag by sessionId)`);
+                    }
                     recordHeldTerminalEventsToLedger(
                         meshId,
                         drainDaemonIds.length > 0 ? drainDaemonIds : (localDaemonId ? [localDaemonId] : []),