@adhdev/daemon-core 0.9.82-rc.547 → 0.9.82-rc.549

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.547",
+  "version": "0.9.82-rc.549",
   "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.547",
-    "@adhdev/session-host-core": "0.9.82-rc.547",
+    "@adhdev/mesh-shared": "0.9.82-rc.549",
+    "@adhdev/session-host-core": "0.9.82-rc.549",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/med-family/cli-agent.ts

@@ -14,10 +14,81 @@ import { loadState } from '../../config/state-store.js';
 import { getRecentActivity } from '../../config/recent-activity.js';
 import { getSavedProviderSessions } from '../../config/saved-sessions.js';
 import { listProviderHistorySessions } from '../../config/chat-history.js';
-import { buildMeshWorkerRelayStamp } from '../../mesh/mesh-events-utils.js';
+import { buildMeshWorkerRelayStamp, readNonEmptyString } from '../../mesh/mesh-events-utils.js';
+import { LOG } from '../../logging/logger.js';
 import { readStringValue } from '../router.js';
 import type { MedFamilyContext, MedFamilyHandler } from './types.js';
 
+/** Outcome of the coordinator-mirror refresh: not a mesh worker (no-op), refreshed, or failed. */
+type MirrorForwardOutcome = 'skipped' | 'refreshed' | 'failed';
+
+/**
+ * MESH-WORKER-PREFS Fix B: when a mesh WORKER session's per-conversation Hide/Mute is toggled
+ * (set_conversation_prefs, forwarded to the worker daemon by the coordinator's
+ * MESH_FORWARDABLE_SESSION_COMMANDS router), the worker updates its own live-session
+ * userHidden/userMuted but the COORDINATOR's mirror of that session (adhdev-daemon
+ * meshOwnedSessions) is only refreshed by a `mesh_forward_event` carrying `sessionSettings`.
+ * Without one the mirror stays stale, so when the coordinator re-emits the session metadata to
+ * the dashboard the old surfaceHidden/muted comes back and the toggle reverts after the 8s
+ * optimistic overlay expires. Push a `mesh_forward_event` to the coordinator daemon with the
+ * fresh prefs so its mirror updates immediately. The coordinator's mesh_forward_event command
+ * consumer calls updateMeshOwnedSession(args) BEFORE routing, so the mirror is refreshed even
+ * though the (non coordinator-event) event name is otherwise ignored.
+ *
+ * Fix (4) — atomicity: the worker's local updateSettings and the coordinator mirror refresh were
+ * fire-and-forget, so a dropped/rejected forward left the mirror stale and the dashboard toggle
+ * silently reverted (the exact "restore does nothing" defect). This now AWAITS the dispatch, retries
+ * once on failure, and reports the outcome so the handler can flag a stale mirror to the caller
+ * instead of returning an unqualified success. It never rejects — a failure is reported, not thrown,
+ * so the local write (already applied) still returns success with a mirrorStale marker.
+ */
+async function forwardConversationPrefsToCoordinator(
+    ctx: MedFamilyContext,
+    sessionId: string,
+    patch: Record<string, unknown>,
+): Promise<MirrorForwardOutcome> {
+    const dispatch = ctx.deps.dispatchMeshCommand;
+    if (!dispatch) return 'skipped';
+    let settings: Record<string, unknown> = {};
+    try {
+        const state = ctx.deps.instanceManager.getInstance(sessionId)?.getState?.();
+        if (state?.settings && typeof state.settings === 'object') {
+            settings = state.settings as Record<string, unknown>;
+        }
+    } catch { /* best-effort — no session settings, nothing to forward */ }
+
+    const coordinatorDaemonId = readNonEmptyString(settings.meshCoordinatorDaemonId);
+    const meshId = readNonEmptyString(settings.meshNodeFor);
+    // A non-delegated (non-mesh) session has no coordinator anchor — nothing to mirror.
+    if (!coordinatorDaemonId || !meshId) return 'skipped';
+    const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.meshLastNodeId);
+
+    // sessionSettings mirrors the exact keys updateMeshOwnedSession merges onto the mirror's
+    // settings (userHidden / userMuted). The coordinator's mirror resolver reads these to derive
+    // surfaceHidden/muted, so the dashboard sees the fresh value on the next metadata flush.
+    const payload: Record<string, unknown> = {
+        event: 'session:settings_changed',
+        meshId,
+        targetSessionId: sessionId,
+        ...(nodeId ? { nodeId } : {}),
+        sessionSettings: { ...patch },
+    };
+
+    // Await the mirror refresh (Fix 4). One retry: a transient P2P blip on the coordinator
+    // channel shouldn't strand the mirror stale when the worker's own state already moved.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            await dispatch(coordinatorDaemonId, 'mesh_forward_event', payload);
+            return 'refreshed';
+        } catch (e: any) {
+            if (attempt === 0) continue;
+            LOG.warn('Mesh', `[Mesh] set_conversation_prefs mirror forward to coordinator ${coordinatorDaemonId.slice(0, 12)} failed after retry: ${e?.message || e}`);
+            return 'failed';
+        }
+    }
+    return 'failed';
+}
+
 export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
     launch_cli: async (ctx: MedFamilyContext, args: any) => {
         // The coordinator routing anchor (meshCoordinatorDaemonId) is stamped
@@ -89,8 +160,25 @@ export const cliAgentHandlers: Record<string, MedFamilyHandler> = {
         // Push a fresh status snapshot so all clients see the updated
         // surfaceHidden/muted immediately (cloud path). The standalone server has a
         // parallel broadcast gate keyed on the command name (see daemon-standalone).
+        // Fired BEFORE the awaited mirror refresh so the local write is visible even if
+        // the coordinator mirror dispatch is slow or fails.
         ctx.deps.onStatusChange?.();
-        return { success: true, sessionId, ...patch };
+        // MESH-WORKER-PREFS Fix B + Fix (4): if this is a mesh worker session, mirror the fresh
+        // prefs onto the coordinator so its stale meshOwnedSessions copy can't revert the toggle
+        // when it re-emits the dashboard metadata. AWAITED (with one retry) so a dropped mirror
+        // refresh is reported to the caller (mirrorStale) instead of silently leaving the
+        // coordinator to re-stamp the old value — the "restore does nothing" revert. No-op for
+        // non-mesh sessions. Never throws: the local write already succeeded.
+        const mirror = await forwardConversationPrefsToCoordinator(ctx, sessionId, patch);
+        return {
+            success: true,
+            sessionId,
+            ...patch,
+            // Only surface the mirror status for a genuine mesh worker session (refreshed/failed);
+            // a non-mesh session ('skipped') carries no mirror field, so nothing changes for it.
+            ...(mirror === 'failed' ? { mirrorStale: true } : {}),
+            ...(mirror === 'refreshed' ? { mirrorRefreshed: true } : {}),
+        };
     },
 
     agent_command: async (ctx: MedFamilyContext, args: any) => {