@adhdev/daemon-core 0.9.82-rc.364 → 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/dist/system/hash.d.ts

@@ -0,0 +1,8 @@
+/** Full lowercase hex SHA-256 digest of `input`. */
+export declare function sha256Hex(input: string): string;
+/**
+ * Truncated SHA-256 hex digest — the first `length` hex chars (default 16).
+ * Used for stable short identifiers (workspace hashes, token ids, coordinator
+ * home dirs) where collision risk at 16 hex chars (64 bits) is negligible.
+ */
+export declare function shortHash(input: string, length?: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.364",
+  "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.364",
+    "@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

@@ -18,7 +18,8 @@ import { loadConfig } from '../config/config.js';
 import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
-import { unregisterMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
+import { shortHash } from '../system/hash.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';
@@ -301,7 +302,7 @@ function hasConfigOverride(args: string[], key: string): boolean {
 function ensureEmptyDelegatedMcpConfig(workspace: string): string {
     const baseDir = path.join(os.tmpdir(), 'adhdev-delegated-agent-empty-mcp');
     mkdirSync(baseDir, { recursive: true });
-    const workspaceHash = crypto.createHash('sha256').update(path.resolve(workspace || os.tmpdir())).digest('hex').slice(0, 16);
+    const workspaceHash = shortHash(path.resolve(workspace || os.tmpdir()));
     const filePath = path.join(baseDir, `${workspaceHash}.json`);
     writeFileSync(filePath, JSON.stringify({ mcpServers: {} }, null, 2), 'utf-8');
     return filePath;
@@ -1068,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,
+    }),
+);