@adhdev/daemon-core 0.9.76-rc.63 → 0.9.76-rc.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.76-rc.63",
+  "version": "0.9.76-rc.65",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/chat/subscription-updates.ts

@@ -8,7 +8,7 @@ import {
   buildSessionModalDeliverySignature,
 } from './chat-signatures.js'
 import { normalizeManagedStatus } from '../status/normalize.js'
-import { filterUserFacingChatMessages, normalizeChatMessages } from '../providers/chat-message-normalization.js'
+import { normalizeChatMessages } from '../providers/chat-message-normalization.js'
 
 export interface ChatTailSubscriptionCursor {
   tailLimit: number
@@ -103,7 +103,7 @@ export function prepareSessionChatTailUpdate(
   }
 
   const fullMessages = normalizeChatMessages(Array.isArray(result.messages) ? result.messages as any[] : [])
-  const messages = filterUserFacingChatMessages(fullMessages)
+  const messages = fullMessages
   const title = typeof result.title === 'string' ? result.title : undefined
   const activeModal = normalizeChatTailActiveModal(result.activeModal)
   const status = typeof result.status === 'string' ? result.status : 'idle'

package/src/commands/router.ts

@@ -41,6 +41,8 @@ import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+import { homedir } from 'os';
+import { join as pathJoin, resolve as pathResolve } from 'path';
 
 type ReleaseChannel = 'stable' | 'preview';
 const CHANNEL_NPM_TAG: Record<ReleaseChannel, 'latest' | 'next'> = { stable: 'latest', preview: 'next' };
@@ -136,6 +138,36 @@ function serializeMeshCoordinatorMcpConfig(config: Record<string, any>, format:
     return loadYamlModule().dump(config, { noRefs: true, lineWidth: 120 });
 }
 
+function resolveHermesUserHome(): string {
+    const explicitHome = process.env.HERMES_HOME?.trim();
+    return explicitHome || pathJoin(homedir(), '.hermes');
+}
+
+function loadHermesCoordinatorBaseConfig(targetConfigPath: string): { config: Record<string, any>; sourceHome: string; sourceConfigPath: string } {
+    const sourceHome = resolveHermesUserHome();
+    const sourceConfigPath = pathJoin(sourceHome, 'config.yaml');
+    if (!fs.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+    if (pathResolve(sourceConfigPath) === pathResolve(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+
+    const parsed = parseMeshCoordinatorMcpConfig(fs.readFileSync(sourceConfigPath, 'utf-8'), 'hermes_config_yaml');
+    const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
+    return { config: baseConfig, sourceHome, sourceConfigPath };
+}
+
+function copyHermesCoordinatorCredentialFiles(sourceHome: string, targetHome: string) {
+    if (pathResolve(sourceHome) === pathResolve(targetHome)) return;
+    for (const fileName of ['.env', 'auth.json']) {
+        const sourcePath = pathJoin(sourceHome, fileName);
+        const targetPath = pathJoin(targetHome, fileName);
+        if (!fs.existsSync(sourcePath)) continue;
+        try {
+            fs.copyFileSync(sourcePath, targetPath);
+        } catch (error: any) {
+            LOG.warn('MeshCoordinator', `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
+        }
+    }
+}
+
 // ─── Types ───
 
 export interface SessionHostControlPlane {
@@ -1601,6 +1633,16 @@ export class DaemonCommandRouter {
                     const hermesManualFallback = cliType === 'hermes-cli' && configFormat === 'hermes_config_yaml'
                         ? createHermesManualMeshCoordinatorSetup(meshId, workspace)
                         : null;
+                    let hermesBaseConfig: { config: Record<string, any>; sourceHome: string; sourceConfigPath: string } | null = null;
+                    if (hermesManualFallback) {
+                        try {
+                            hermesBaseConfig = loadHermesCoordinatorBaseConfig(mcpConfigPath);
+                        } catch (error: any) {
+                            const message = `Failed to parse Hermes base config for automatic coordinator setup: ${error?.message || error}`;
+                            LOG.error('MeshCoordinator', message);
+                            return { success: false, code: 'mesh_coordinator_config_parse_failed', error: message, meshId, cliType, workspace };
+                        }
+                    }
                     const returnManualFallback = (message: string) => ({
                         success: false,
                         code: 'mesh_coordinator_manual_mcp_setup_required',
@@ -1636,10 +1678,14 @@ export class DaemonCommandRouter {
 
                     // Backup existing MCP config if present.
                     const hadExistingMcpConfig = existsSync(mcpConfigPath);
-                    let existingMcpConfig: Record<string, any> = {};
+                    let existingMcpConfig: Record<string, any> = hermesBaseConfig?.config || {};
+                    if (hermesBaseConfig) {
+                        copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname(mcpConfigPath));
+                    }
                     if (hadExistingMcpConfig) {
                         try {
-                            existingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync(mcpConfigPath, 'utf-8'), configFormat);
+                            const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync(mcpConfigPath, 'utf-8'), configFormat);
+                            existingMcpConfig = { ...existingMcpConfig, ...parsedExistingMcpConfig };
                             copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
                         } catch (error: any) {
                             LOG.error('MeshCoordinator', `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);

package/src/index.ts

@@ -79,6 +79,10 @@ export type {
   CliProviderState,
   AcpProviderState,
   ExtensionProviderState,
+  MessageInputSupport,
+  InputMediaStrategyDescriptor,
+  InputAttachmentStrategy,
+  InputMediaType,
 } from './shared-types.js';
 
 // ── Repo Mesh Types (cross-package) ──

package/src/mesh/mesh-events.ts

@@ -99,10 +99,21 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         const workspace = readNonEmptyString(state.workspace);
         if (!workspace) return;
         const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
+
+        // Coordinator sessions must never inject events into themselves.
+        // A coordinator instance carries meshCoordinatorFor but not meshNodeFor/launchedByCoordinator.
+        if (readNonEmptyString(settings.meshCoordinatorFor)) return;
+
         const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
 
-        // Prefer runtime mesh metadata: delegated mesh-node agents can come from inline/cloud meshes
-        // that are not present in local meshes.json. Fall back to persisted mesh lookup for legacy sessions.
+        // Only forward events for sessions that were explicitly launched as mesh-node delegates
+        // (meshNodeFor set by mesh_launch_session) or that carry the launchedByCoordinator flag.
+        // Do NOT fall back to workspace-based mesh lookup: that would pick up coordinator sessions
+        // and any other CLI session that happens to share the same workspace, causing spurious
+        // system-message injection into the coordinator's own conversation.
+        const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
+        if (!isMeshDelegate) return;
+
         const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
         const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
         if (!meshId) return;

package/src/providers/cli-provider-instance.ts

@@ -76,9 +76,33 @@ function materializeImageDataPart(part: Extract<InputPart, { type: 'image' }>, i
     fs.mkdirSync(dir, { recursive: true });
     const filePath = path.join(dir, safeInputImageBasename(index, part.mimeType));
     fs.writeFileSync(filePath, Buffer.from(rawData, 'base64'));
+    cleanupStaleMaterializedImages(dir);
     return filePath;
 }
 
+const MATERIALIZED_IMAGE_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
+const MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+let lastMaterializedImageCleanupAt = 0;
+
+function cleanupStaleMaterializedImages(dir: string): void {
+    const now = Date.now();
+    if (now - lastMaterializedImageCleanupAt < MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS) return;
+    lastMaterializedImageCleanupAt = now;
+    try {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+            if (!entry.startsWith('adhdev-input-image-')) continue;
+            const fullPath = path.join(dir, entry);
+            try {
+                const stat = fs.statSync(fullPath);
+                if (now - stat.mtimeMs > MATERIALIZED_IMAGE_MAX_AGE_MS) {
+                    fs.unlinkSync(fullPath);
+                }
+            } catch { /* file may have been removed concurrently */ }
+        }
+    } catch { /* dir may not exist or be inaccessible */ }
+}
+
 export function buildCliStructuredInputPrompt(
     input: InputEnvelope,
     options: { materializeDir?: string } = {},
@@ -113,7 +137,13 @@ export function buildCliStructuredInputPrompt(
         }
     });
 
-    if (input.textFallback.trim()) promptParts.push(input.textFallback.trim());
+    // Only use textFallback when no explicit text parts were collected — it is
+    // the flattened version of the same parts, so appending it alongside them
+    // would duplicate the content for multipart inputs.
+    const hasExplicitTextParts = input.parts.some((part) => part.type === 'text' && part.text.trim());
+    if (!hasExplicitTextParts && input.textFallback.trim()) {
+        promptParts.push(input.textFallback.trim());
+    }
 
     const ordered = [
         ...imageRefs,