@adhdev/daemon-core 0.9.82-rc.365 → 0.9.82-rc.366

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

@@ -59,6 +59,14 @@ export interface MeshQueueTriggerResult {
         status?: string;
     }>;
     autoLaunchStarted: boolean;
+    /**
+     * True when a worker session is already on its way to claim a still-pending task —
+     * either launched this tick (autoLaunchStarted) or launched on a prior tick and still
+     * booting/awaiting-claim. Callers MUST treat this as "wait, do not launch another
+     * session": a second launch double-edits the worktree. Mutually informative with
+     * `noIdleMeshSessionAvailable`, which is suppressed whenever this is true.
+     */
+    autoLaunchPending?: boolean;
     noIdleMeshSessionAvailable?: boolean;
 }
 export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;

package/package.json

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

package/src/commands/cli-manager.ts

@@ -19,7 +19,7 @@ import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
 import { shortHash } from '../system/hash.js';
-import { unregisterMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
+import { unregisterMeshCoordinator, getCoordinatorForSession, listCoordinatorsForWorkspace } from '../mesh/coordinator-registry.js';
 import { upsertSavedProviderSession } from '../config/saved-sessions.js';
 import { buildLegacyModelModeSummaryMetadata, normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
@@ -1069,7 +1069,33 @@ export class DaemonCliManager {
             // Both restores are provider-agnostic — getSettings is keyed by provider type and the
             // registry mark is type-independent.
             const restoredSettings: Record<string, any> = { ...this.providerLoader.getSettings(normalizedType) };
-            const coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+            // Primary rebind: exact persisted-registry match by runtimeId (stable across
+            // restart, see session-host runtimeId = runtimeRecord.sessionId).
+            let coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+            // CORDBADGE fallback: the by-id match misses when a coordinator's runtime
+            // re-attaches under a different runtimeId than the one it was registered with
+            // (the registry survived, but its key no longer lines up). Without a rebind the
+            // restored session silently loses meshCoordinatorFor → the coordinator badge and
+            // selfIdentification block vanish and pending mesh events stop draining into its
+            // PTY, and the only recovery is a manual coordinator restart. Recover the mark
+            // from the persisted registry scoped to this exact workspace, but ONLY when it is
+            // UNAMBIGUOUS: exactly one registered coordinator for this workspace AND its
+            // cliType matches the restored session's type. The registry never holds worker
+            // sessions (only launch_mesh_coordinator registrations), so this cannot mis-mark a
+            // delegated worker; the uniqueness + cliType gate keeps it from guessing when two
+            // coordinators ever shared a workspace. Anything ambiguous stays unbound (we would
+            // rather miss a badge than mis-attribute one).
+            if (!coordinatorEntry?.meshId && record.workspace) {
+                const workspaceCoordinators = listCoordinatorsForWorkspace(record.workspace)
+                    .filter(e => e.meshId && (!e.cliType || e.cliType === record.cliType));
+                if (workspaceCoordinators.length === 1) {
+                    coordinatorEntry = workspaceCoordinators[0];
+                    LOG.info(
+                        'CLI',
+                        `↻ Rebound coordinator mark by workspace for ${record.runtimeKey || record.runtimeId} (mesh ${coordinatorEntry.meshId} @ ${record.workspace}); registry key did not match runtimeId`
+                    );
+                }
+            }
             if (coordinatorEntry?.meshId) {
                 restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
             }

package/src/commands/high-family/index.ts

@@ -0,0 +1,28 @@
+/**
+ * RF-ROUTER HIGH family — command registry.
+ *
+ * Aggregates the high-coupling command handlers extracted from
+ * DaemonCommandRouter.executeDaemonCommand into a single cmd → handler map. The
+ * router consults this registry after the LOW- and MED-family registries and
+ * before its remaining switch (registry hit → return the handler result; miss →
+ * fall through to the switch / CommandHandler delegation), so the facade and
+ * dispatch semantics are unchanged.
+ *
+ * HIGH handlers are the most router-coupled: beyond the MED collaborators they
+ * reach the router's aggregate-status memory cache and running-refine-job table.
+ * The router binds those onto HighFamilyContext at dispatch — see types.ts.
+ */
+import { meshEventsHandlers } from './mesh-events.js';
+import { meshCoordinatorLaunchHandlers } from './mesh-coordinator-launch.js';
+import { meshStatusHandlers } from './mesh-status.js';
+import type { HighFamilyRegistry } from './types.js';
+
+export type { HighFamilyContext, HighFamilyHandler, HighFamilyRegistry } from './types.js';
+
+export const highFamilyRegistry: HighFamilyRegistry = new Map(
+    Object.entries({
+        ...meshEventsHandlers,
+        ...meshCoordinatorLaunchHandlers,
+        ...meshStatusHandlers,
+    }),
+);