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

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.367",
   "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.367",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/chat-commands.ts

@@ -30,6 +30,7 @@ import {
 import type { ChatMessage } from '../types.js';
 import type { SessionTransport } from '../shared-types.js';
 import { filterUserFacingChatMessages, isActivityChatMessage, isUserFacingChatMessage, normalizeChatMessages } from '../providers/chat-message-normalization.js';
+import { normalizeMeshWorkspaceForCompare } from '@adhdev/mesh-shared';
 
 const RECENT_SEND_WINDOW_MS = 1200;
 export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
@@ -989,6 +990,53 @@ function normalizeComparableWorkspace(value: unknown): string {
     return path.resolve(text);
 }
 
+/**
+ * read_chat node scope verdict. One physical daemon hosts a base node plus several
+ * worktree nodes; mesh_read_chat always dispatches read_chat with the requested
+ * node's workspace (`args.workspace`). When the resolved target session actually
+ * lives in a DIFFERENT worktree, returning its transcript — or worse, letting the
+ * native-history-by-workspace fallback splice sibling worktree turns into the
+ * reply — makes the coordinator believe one session received every worktree's
+ * work. This guard refuses a CONFIRMED cross-workspace read instead of mixing.
+ *
+ * Conservative by design (mirrors the WTCLAIM fix-B "unknown → allow" rule): only
+ * a session id that resolves to a known workspace which is unequal to a known
+ * intended workspace blocks. When either side is unknown — no targetSessionId, no
+ * args.workspace, an unregistered session, the coordinator self-session, or a
+ * plain dashboard read that never passes a node workspace — the read proceeds
+ * untouched, so base-node and same-daemon coordinator reads never regress.
+ */
+export function evaluateReadChatNodeWorkspaceScope(args: {
+    targetSessionId?: string;
+    intendedWorkspace?: string;
+    sessionWorkspace?: string;
+}): { scoped: false } | { scoped: true; intended: string; actual: string } {
+    const targetSessionId = typeof args.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+    if (!targetSessionId) return { scoped: false };
+    const intended = normalizeMeshWorkspaceForCompare(args.intendedWorkspace);
+    const actual = normalizeMeshWorkspaceForCompare(args.sessionWorkspace);
+    if (!intended || !actual) return { scoped: false };
+    if (intended === actual) return { scoped: false };
+    return { scoped: true, intended, actual };
+}
+
+/**
+ * Resolve the target session's ACTUAL workspace from the most authoritative source
+ * available on this daemon: the session registry record (stamped at register
+ * time), then the live CLI adapter's working directory, then the bound instance
+ * state. Returns '' when nothing knows the session's workspace — the caller treats
+ * that as "unknown" and does not block.
+ */
+function resolveTargetSessionActualWorkspace(h: CommandHelpers, targetSessionId: string): string {
+    const registryWorkspace = (h.ctx?.sessionRegistry?.get?.(targetSessionId) as any)?.workspace;
+    if (typeof registryWorkspace === 'string' && registryWorkspace.trim()) return registryWorkspace;
+    const adapter = h.getCliAdapter?.(targetSessionId);
+    if (adapter && typeof adapter.workingDir === 'string' && adapter.workingDir.trim()) return adapter.workingDir;
+    const instanceWorkspace = (getTargetInstance(h, { targetSessionId })?.getState?.() as any)?.workspace;
+    if (typeof instanceWorkspace === 'string' && instanceWorkspace.trim()) return instanceWorkspace;
+    return '';
+}
+
 function isCurrentRuntimePtySafelyAttributed(args: {
     adapter: CliAdapter;
     helpers: CommandHelpers;
@@ -2100,6 +2148,29 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
 }
 
 export async function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult> {
+    // Node scope guard: a daemon hosting a base node + several worktree nodes must
+    // not serve worktree A's transcript (or splice sibling worktree turns via the
+    // native-history-by-workspace fallback) when a coordinator scoped the read to
+    // worktree B. mesh_read_chat always passes the requested node's workspace as
+    // args.workspace; refuse a CONFIRMED cross-workspace read rather than mix.
+    {
+        const guardSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+        if (guardSessionId && typeof args?.workspace === 'string' && args.workspace.trim()) {
+            const verdict = evaluateReadChatNodeWorkspaceScope({
+                targetSessionId: guardSessionId,
+                intendedWorkspace: args.workspace,
+                sessionWorkspace: resolveTargetSessionActualWorkspace(h, guardSessionId),
+            });
+            if (verdict.scoped) {
+                LOG.info('Command', `[read_chat] node scope mismatch: session ${guardSessionId} workspace "${verdict.actual}" ≠ requested node workspace "${verdict.intended}" — refusing cross-worktree transcript`);
+                return {
+                    success: false,
+                    code: 'read_chat_session_node_scope_mismatch',
+                    error: `Session ${guardSessionId} belongs to a different worktree (workspace "${verdict.actual}") than the requested node (workspace "${verdict.intended}"). Refusing to return a cross-worktree transcript — target the node that owns this session.`,
+                };
+            }
+        }
+    }
     // Resolve provider in order: explicit agentType/providerType > registered session.
     // Without this fallback, callers that only have a sessionId (e.g. a chat tail
     // controller that just got handed a session ID over WS) get an empty result
@@ -2649,10 +2720,33 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             });
 
             if (supportsNative && !decision.nativeSelected) {
+                // Dead-end: we are in the history-only path (no live PTY/ACP
+                // adapter was found for this target session) AND provider-native
+                // history is not safely mappable to the requested session
+                // (no historySessionId stamp / workspace mismatch). Previously
+                // this returned `success:false`, which the command logger emits
+                // at warn level on EVERY poll (handler.ts logCommandEnd) —
+                // mesh coordinators poll read_chat continuously, so a worker whose
+                // transcript can never be safely mapped produced a 100% warn-log
+                // storm with no recovery. Switch to a SOFT response: success with
+                // empty messages + pending:true so the coordinator treats it as
+                // "no live messages readable yet" rather than a hard failure, and
+                // carry the machine-readable reason for debuggability. The normal
+                // live-adapter path (above) and the safe-native return (below) are
+                // unaffected — this is strictly the both-absent dead end.
+                LOG.debug('Command', `[read_chat] soft pending: no live adapter and native history not safely mappable target=${String(args?.targetSessionId || '')} provider=${agentStr} reason=native_history_not_safely_available`);
                 return {
-                    success: false,
+                    success: true,
+                    pending: true,
+                    // Both signals are true here: we reached the history-only path
+                    // because no live adapter was found (`live_adapter_not_found`),
+                    // and native history is not safely mappable
+                    // (`native_history_not_safely_available`).
+                    reason: 'native_history_not_safely_available',
+                    reasons: ['live_adapter_not_found', 'native_history_not_safely_available'],
                     code: 'native_history_not_safely_available',
-                    error: 'Provider-native history was not safely available for the requested CLI session.',
+                    messages: [],
+                    status: 'idle',
                     providerSessionId: historyProviderSessionId,
                     messageSource: decision.messageSource,
                     transcriptProvenance: decision.messageSource,

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,
+    }),
+);