@adhdev/daemon-core 0.9.76-rc.21 → 0.9.76-rc.23

package/package.json

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

package/src/commands/cli-manager.ts

@@ -8,7 +8,7 @@
 import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { execFileSync } from 'child_process';
 import chalk from 'chalk';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
@@ -138,6 +138,56 @@ type CliStartOptions = {
     extraEnv?: Record<string, string>;
 };
 
+const COORDINATOR_DELEGATED_ENV_UNSETS: Record<string, string> = {
+    ADHDEV_INLINE_MESH: '',
+    ADHDEV_MCP_TRANSPORT: '',
+    ADHDEV_MESH_ID: '',
+    HERMES_EPHEMERAL_SYSTEM_PROMPT: '',
+};
+
+export interface CoordinatorDelegatedCliLaunchOptionsInput {
+    cliType: string;
+    workspace: string;
+    cliArgs?: string[];
+    env?: Record<string, string>;
+}
+
+export interface CoordinatorDelegatedCliLaunchOptions {
+    cliArgs: string[];
+    env: Record<string, string>;
+}
+
+function hasCliArg(args: string[], flag: string): boolean {
+    return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+
+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 filePath = path.join(baseDir, `${workspaceHash}.json`);
+    writeFileSync(filePath, JSON.stringify({ mcpServers: {} }, null, 2), 'utf-8');
+    return filePath;
+}
+
+export function buildCoordinatorDelegatedCliLaunchOptions(
+    input: CoordinatorDelegatedCliLaunchOptionsInput,
+): CoordinatorDelegatedCliLaunchOptions {
+    const cliType = String(input.cliType || '').trim();
+    const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
+    const env: Record<string, string> = { ...(input.env || {}), ...COORDINATOR_DELEGATED_ENV_UNSETS };
+
+    if (cliType === 'hermes-cli' && !hasCliArg(cliArgs, '--ignore-user-config')) {
+        cliArgs.unshift('--ignore-user-config');
+    }
+
+    if (cliType === 'claude-cli' && !hasCliArg(cliArgs, '--mcp-config')) {
+        cliArgs.unshift('--mcp-config', ensureEmptyDelegatedMcpConfig(input.workspace));
+    }
+
+    return { cliArgs, env };
+}
+
 function isUuid(value: string): boolean {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
@@ -909,12 +959,25 @@ export class DaemonCliManager {
                 const launchSource = resolved.source;
                 if (!cliType) throw new Error('cliType required');
 
+                const settingsOverride = args?.settings && typeof args.settings === 'object' ? args.settings : undefined;
+                const delegatedLaunch = settingsOverride?.launchedByCoordinator === true
+                    ? buildCoordinatorDelegatedCliLaunchOptions({
+                        cliType,
+                        workspace: dir,
+                        cliArgs: args?.cliArgs,
+                        env: args?.env,
+                    })
+                    : null;
                 const started = await this.startSession(
                     cliType,
                     dir,
-                    args?.cliArgs,
+                    delegatedLaunch ? delegatedLaunch.cliArgs : args?.cliArgs,
                     args?.initialModel,
-                    { resumeSessionId: args?.resumeSessionId, settingsOverride: args?.settings, extraEnv: args?.env },
+                    {
+                        resumeSessionId: args?.resumeSessionId,
+                        settingsOverride,
+                        extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env,
+                    },
                 );
 
                 return {

package/src/git/git-commands.ts

@@ -152,6 +152,7 @@ const FAILURE_REASONS = new Set<GitFailureReason>([
   'dirty_index_required',
   'conflict',
   'invalid_args',
+  'nothing_to_commit',
   'git_command_failed',
 ]);
 
@@ -454,7 +455,10 @@ async function gitCheckpoint(
   } catch (err: any) {
     const output = (err?.stdout || '') + (err?.stderr || '');
     if (/nothing to commit/i.test(output)) {
-      throw new GitCommandError('git_command_failed', 'Nothing to commit');
+      throw new GitCommandError('nothing_to_commit', 'Nothing to commit — working tree is clean.', {
+        stdout: err?.stdout,
+        stderr: err?.stderr,
+      });
     }
     throw err;
   }

package/src/git/git-types.ts

@@ -14,6 +14,7 @@ export type GitFailureReason =
   | 'dirty_index_required'
   | 'conflict'
   | 'invalid_args'
+  | 'nothing_to_commit'
   | 'git_command_failed';
 
 export interface GitRepoIdentity {

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

@@ -985,12 +985,33 @@ export class CliProviderInstance implements ProviderInstance {
     private mergeConversationMessages(parsedMessages: any[]): ChatMessage[] {
         if (this.runtimeMessages.length === 0) return normalizeChatMessages(parsedMessages);
 
-        return normalizeChatMessages([...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)]
-            .map((message, index) => ({ message, index }))
+        type MergeEntry = { message: ChatMessage; index: number; source: 'parsed' | 'runtime' };
+        const parsedEntries: MergeEntry[] = parsedMessages.map((message, index) => ({
+            message,
+            index,
+            source: 'parsed',
+        }));
+        const runtimeEntries: MergeEntry[] = this.runtimeMessages.map((entry, index) => ({
+            message: entry.message,
+            index: parsedMessages.length + index,
+            source: 'runtime',
+        }));
+        const getTime = (message: ChatMessage): number => {
+            const value = typeof message.receivedAt === 'number'
+                ? message.receivedAt
+                : typeof message.timestamp === 'number'
+                    ? message.timestamp
+                    : 0;
+            return Number.isFinite(value) && value > 0 ? value : 0;
+        };
+
+        return normalizeChatMessages([...parsedEntries, ...runtimeEntries]
             .sort((a, b) => {
-                const aTime = a.message.receivedAt || a.message.timestamp || 0;
-                const bTime = b.message.receivedAt || b.message.timestamp || 0;
-                if (aTime !== bTime) return aTime - bTime;
+                const aTime = getTime(a.message);
+                const bTime = getTime(b.message);
+                if (aTime && bTime && aTime !== bTime) return aTime - bTime;
+                if (aTime && !bTime && a.source === 'runtime' && b.source === 'parsed') return -1;
+                if (!aTime && bTime && a.source === 'parsed' && b.source === 'runtime') return 1;
                 return a.index - b.index;
             })
             .map((entry) => entry.message));