@adhdev/daemon-core 0.9.82-rc.14 → 0.9.82-rc.141

package/src/commands/cli-manager.ts

@@ -18,6 +18,7 @@ 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 } 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';
@@ -80,6 +81,114 @@ export interface CliManagerDeps {
 
 type CommandResult = { success: boolean;[key: string]: unknown };
 
+const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'long_generating']);
+const ZERO_MESSAGE_STARTING_SEND_WAIT_MS = 2_000;
+
+function normalizeAgentStatus(value: unknown): string {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function hasNonEmptyModalButtons(activeModal: unknown): boolean {
+    const buttons = (activeModal as any)?.buttons;
+    return Array.isArray(buttons) && buttons.some((button) => String(button || '').trim().length > 0);
+}
+
+function hasAdapterPendingResponse(adapter: any): boolean {
+    if (adapter?.isWaitingForResponse === true) return true;
+    if (adapter?.currentTurnScope) return true;
+    try {
+        if (typeof adapter?.isProcessing === 'function' && adapter.isProcessing()) return true;
+    } catch { /* defensive: send guard should not fail on diagnostics */ }
+    try {
+        const partial = typeof adapter?.getPartialResponse === 'function' ? adapter.getPartialResponse() : '';
+        if (typeof partial === 'string' && partial.trim()) return true;
+    } catch { /* defensive: missing partial means no pending evidence */ }
+    return false;
+}
+
+function countMessages(value: unknown): number {
+    return Array.isArray(value) ? value.length : 0;
+}
+
+function hasFinalAssistantMessage(value: unknown): boolean {
+    const messages = Array.isArray(value) ? value : [];
+    const last = messages[messages.length - 1] as any;
+    if (!last || last.role !== 'assistant') return false;
+    if (last.bubbleState === 'streaming') return false;
+    if (last.meta?.streaming === true) return false;
+    return typeof last.content === 'string' && last.content.trim().length > 0;
+}
+
+function hasZeroMessageStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (parsedRawStatus && parsedRawStatus !== 'starting' && parsedRawStatus !== 'generating') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    if (countMessages(adapterStatus?.messages) > 0 || countMessages(parsedStatus?.messages) > 0) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function hasCompletedStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (hasAdapterPendingResponse(adapter)) return false;
+
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (parsedRawStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return hasFinalAssistantMessage(parsedStatus?.messages);
+}
+
+function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
+    if (adapterStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function getEffectiveAgentSendStatus(adapter: any): string {
+    const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+    if (adapterStatus === 'starting' && hasCompletedStartingLaunch(adapter)) return 'idle';
+    if (adapterStatus && adapterStatus !== 'idle') return adapterStatus;
+    if (adapterStatus !== 'idle') return adapterStatus;
+
+    if (typeof adapter?.getScriptParsedStatus !== 'function') return adapterStatus;
+    try {
+        const parsedStatus = adapter.getScriptParsedStatus();
+        const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+        if (BUSY_AGENT_STATUSES.has(parsedRawStatus) && !shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter)) {
+            return parsedRawStatus;
+        }
+    } catch {
+        return adapterStatus;
+    }
+    return adapterStatus;
+}
+
+async function waitForZeroMessageStartingLaunch(adapter: any): Promise<boolean> {
+    try {
+        if (!hasZeroMessageStartingLaunch(adapter)) return false;
+    } catch {
+        return false;
+    }
+    await new Promise(resolve => setTimeout(resolve, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
+    try {
+        return hasZeroMessageStartingLaunch(adapter);
+    } catch {
+        return false;
+    }
+}
+
 export interface CliTransportFactoryParams {
     runtimeId: string;
     providerType: string;
@@ -255,10 +364,14 @@ function detectExplicitProviderSessionId(
 
     const subcommands = resume?.sessionIdFromSubcommand;
     if (Array.isArray(subcommands) && subcommands.length > 0) {
+        const hasResumeSubcommand = args.some((arg) => subcommands.includes(arg));
         const subcommandSessionId = readSubcommandSessionId(args, subcommands);
         if (subcommandSessionId) {
             return { providerSessionId: subcommandSessionId, launchMode: 'resume' };
         }
+        if (hasResumeSubcommand) {
+            return { launchMode: 'resume' };
+        }
     }
 
     return { launchMode: 'manual' };
@@ -292,6 +405,12 @@ export function resolveCliSessionBinding(
             launchMode: explicit.launchMode,
         };
     }
+    if (explicit.launchMode === 'resume') {
+        return {
+            cliArgs: baseArgs,
+            launchMode: 'resume',
+        };
+    }
     if (explicit.launchMode === 'manual' && hasArg(baseArgs || [], ['--session-id'])) {
         return {
             cliArgs: baseArgs,
@@ -435,7 +554,9 @@ export class DaemonCliManager {
                 providerSessionId,
                 attachExisting,
             );
-            return new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            const adapter = new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            if (providerSessionId) adapter.updateRuntimeMeta({ providerSessionId });
+            return adapter;
         }
 
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
@@ -457,6 +578,7 @@ export class DaemonCliManager {
                             this.deps.removeAgentTracking(key);
                             sessionRegistry?.unregisterByInstanceKey(key);
                             instanceManager?.removeInstance(key);
+                            unregisterMeshCoordinator(key);
                             LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${cliType}`);
                             this.deps.onStatusChange();
                         }
@@ -783,6 +905,7 @@ export class DaemonCliManager {
             this.deps.removeAgentTracking(key);
             this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
             this.deps.getInstanceManager()?.removeInstance(key);
+            unregisterMeshCoordinator(key);
             LOG.info('CLI', `🛑 Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
             this.deps.onStatusChange();
         } else {
@@ -792,6 +915,7 @@ export class DaemonCliManager {
                 this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
                 im.removeInstance(key);
                 this.deps.removeAgentTracking(key);
+                unregisterMeshCoordinator(key);
                 LOG.warn('CLI', `🧹 Force-removed orphan entry: ${key}`);
                 this.deps.onStatusChange();
             }
@@ -1073,6 +1197,12 @@ export class DaemonCliManager {
                 const { adapter, key } = found;
 
                 if (action === 'send_chat') {
+                    let currentStatus = getEffectiveAgentSendStatus(adapter);
+                    if (currentStatus === 'starting' && await waitForZeroMessageStartingLaunch(adapter)) {
+                        currentStatus = 'idle';
+                    } else if (currentStatus === 'starting') {
+                        currentStatus = getEffectiveAgentSendStatus(adapter);
+                    }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
                     if (provider?.category === 'acp') {
@@ -1082,8 +1212,20 @@ export class DaemonCliManager {
                     }
                     const message = input.textFallback;
                     if (!message) throw new Error('message required for send_chat');
-                    await adapter.sendMessage(message);
-                    return { success: true, status: 'generating' };
+                    const forceSend = args?.force === true || args?.forceSend === true;
+                    if (forceSend && typeof (adapter as any).forceSendMessage === 'function') {
+                        await (adapter as any).forceSendMessage(message);
+                    } else if (forceSend) {
+                        await adapter.sendMessage(message, { force: true });
+                    } else {
+                        await adapter.sendMessage(message);
+                    }
+                    return {
+                        success: true,
+                        status: BUSY_AGENT_STATUSES.has(currentStatus) ? currentStatus : 'generating',
+                        ...(BUSY_AGENT_STATUSES.has(currentStatus) ? { queued: true, queuedReason: 'agent_runtime_busy' } : {}),
+                        ...(forceSend ? { forceSent: true, queued: false } : {}),
+                    };
                 } else if (action === 'clear_history') {
                     if (typeof adapter.clearHistory === 'function') adapter.clearHistory();
                     return { success: true, cleared: true };

package/src/commands/handler.ts

@@ -408,12 +408,19 @@ export class DaemonCommandHandler implements CommandHelpers {
             'invoke_provider_script',
         ]);
 
+        // read_chat and get_chat_debug_bundle can serve historical transcript data even
+        // when the live session record is gone (stopped/destroyed). Allow the fallback
+        // when the provider type is known and any session identity hint is present:
+        // an explicit providerSessionId/historySessionId, or the targetSessionId itself
+        // (which getHistorySessionId already uses as a fallback history key).
+        const isReadOrDebugCmd = cmd === 'read_chat' || cmd === 'get_chat_debug_bundle';
         const allowsInactiveReadChatFallback =
-            cmd === 'read_chat'
+            isReadOrDebugCmd
             && !!this._currentRoute.providerType
             && (
                 (typeof args?.providerSessionId === 'string' && args.providerSessionId.trim().length > 0)
                 || (typeof args?.historySessionId === 'string' && args.historySessionId.trim().length > 0)
+                || (typeof args?.targetSessionId === 'string' && args.targetSessionId.trim().length > 0)
             );
 
         if (this._currentRoute.sessionLookupFailed && sessionScopedCommands.has(cmd) && !allowsInactiveReadChatFallback) {

package/src/commands/mesh-coordinator.ts

@@ -1,9 +1,6 @@
-import { execFileSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
-import { existsSync, readdirSync, realpathSync } from 'node:fs'
-import { createRequire } from 'node:module'
 import * as os from 'node:os'
-import { dirname, isAbsolute, join, resolve } from 'node:path'
+import { isAbsolute, join, resolve } from 'node:path'
 import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
 
 export interface MeshCoordinatorMcpServerLaunch {
@@ -55,7 +52,7 @@ export interface ResolveMeshCoordinatorSetupOptions {
 }
 
 const DEFAULT_SERVER_NAME = 'adhdev-mesh'
-const DEFAULT_ADHDEV_MCP_COMMAND = 'adhdev-mcp'
+const DEFAULT_ADHDEV_MCP_COMMAND = 'adhdev'
 const HERMES_CLI_TYPE = 'hermes-cli'
 const HERMES_MCP_CONFIG_PATH = '~/.hermes/config.yaml'
 
@@ -67,8 +64,7 @@ function isHermesProvider(provider: ProviderModule | null | undefined, cliType?:
 function resolveHermesMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup {
   const mcpServer = resolveAdhdevMcpServerLaunch({
     meshId: options.meshId,
-    nodeExecutable: options.nodeExecutable,
-    adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    adhdevMcpCommand: options.adhdevMcpCommand,
     adhdevMcpTransport: options.adhdevMcpTransport,
     adhdevMcpPort: options.adhdevMcpPort,
   })
@@ -100,7 +96,7 @@ export function createHermesManualMeshCoordinatorSetup(meshId: string, workspace
     requiresRestart: true,
     instructions: 'Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.',
     template: renderMeshCoordinatorTemplate(
-      'mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n',
+      'mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - mcp\n      - --mode\n      - ipc\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n',
       {
         meshId,
         workspace,
@@ -141,8 +137,7 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
       meshId,
-      nodeExecutable: options.nodeExecutable,
-      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+      adhdevMcpCommand: options.adhdevMcpCommand,
       adhdevMcpTransport: options.adhdevMcpTransport,
       adhdevMcpPort: options.adhdevMcpPort,
     })
@@ -222,25 +217,25 @@ function resolveMcpConfigPath(configPath: string, workspace: string): string {
 
 function resolveAdhdevMcpServerLaunch(options: {
   meshId: string
-  nodeExecutable?: string
-  adhdevMcpEntryPath?: string
+  adhdevMcpCommand?: string
   adhdevMcpTransport?: 'local' | 'ipc'
   adhdevMcpPort?: number
 }): MeshCoordinatorMcpServerLaunch | null {
-  const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath)
-  if (!entryPath) return null
-  const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable)
-  if (!nodeExecutable) return null
+  const command = resolveAdhdevCommand(options.adhdevMcpCommand)
   const transport = resolveMcpTransport(options.adhdevMcpTransport)
-  const args = [entryPath, '--mode', transport, '--repo-mesh', options.meshId]
+  const args = ['mcp', '--mode', transport, '--repo-mesh', options.meshId]
   const port = resolveMcpPort(options.adhdevMcpPort)
   if (port !== undefined) args.push('--port', String(port))
   return {
-    command: nodeExecutable,
+    command,
     args,
   }
 }
 
+function resolveAdhdevCommand(explicitCommand?: string): string {
+  return explicitCommand?.trim() || process.env.ADHDEV_COORDINATOR_MCP_COMMAND?.trim() || DEFAULT_ADHDEV_MCP_COMMAND
+}
+
 function resolveMcpTransport(explicitTransport?: 'local' | 'ipc'): 'local' | 'ipc' {
   if (explicitTransport === 'local' || explicitTransport === 'ipc') return explicitTransport
   const envTransport = process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT?.trim()
@@ -254,128 +249,3 @@ function resolveMcpPort(explicitPort?: number): number | undefined {
   const parsed = Number(raw)
   return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
 }
-
-function resolveMcpNodeExecutable(explicitExecutable?: string): string | null {
-  const explicit = explicitExecutable?.trim()
-  if (explicit) return explicit
-
-  const candidates: string[] = []
-  const addCandidate = (candidate?: string | null) => {
-    const trimmed = candidate?.trim()
-    if (!trimmed) return
-    const normalized = normalizeExistingPath(trimmed) || trimmed
-    if (!candidates.includes(normalized)) candidates.push(normalized)
-  }
-
-  addCandidate(process.env.ADHDEV_MCP_NODE_EXECUTABLE)
-  addCandidate(process.env.ADHDEV_NODE_EXECUTABLE)
-  addCandidate(process.env.npm_node_execpath)
-  addNodeCandidatesFromPath(process.env.PATH, addCandidate)
-  addNodeCandidatesFromNvm(os.homedir(), addCandidate)
-  addCandidate('/opt/homebrew/bin/node')
-  addCandidate('/usr/local/bin/node')
-  addCandidate('/usr/bin/node')
-  addCandidate(process.execPath)
-
-  for (const candidate of candidates) {
-    if (nodeRuntimeSupportsWebSocket(candidate)) return candidate
-  }
-  return null
-}
-
-function addNodeCandidatesFromPath(pathValue: string | undefined, addCandidate: (candidate?: string | null) => void) {
-  for (const entry of (pathValue || '').split(':')) {
-    const dir = entry.trim()
-    if (!dir) continue
-    addCandidate(join(dir, 'node'))
-  }
-}
-
-function addNodeCandidatesFromNvm(homeDir: string, addCandidate: (candidate?: string | null) => void) {
-  const versionsDir = join(homeDir, '.nvm', 'versions', 'node')
-  try {
-    const versionDirs = readdirSync(versionsDir, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort(compareNodeVersionNamesDescending)
-    for (const versionDir of versionDirs) {
-      addCandidate(join(versionsDir, versionDir, 'bin', 'node'))
-    }
-  } catch {
-    // nvm is optional; PATH and process.execPath candidates still cover normal installs.
-  }
-}
-
-function compareNodeVersionNamesDescending(a: string, b: string): number {
-  const parse = (value: string) => value.replace(/^v/, '').split('.').map((part) => Number.parseInt(part, 10) || 0)
-  const left = parse(a)
-  const right = parse(b)
-  for (let i = 0; i < Math.max(left.length, right.length); i++) {
-    const diff = (right[i] || 0) - (left[i] || 0)
-    if (diff !== 0) return diff
-  }
-  return b.localeCompare(a)
-}
-
-function nodeRuntimeSupportsWebSocket(nodeExecutable: string): boolean {
-  try {
-    execFileSync(nodeExecutable, ['-e', "process.exit(typeof WebSocket === 'function' ? 0 : 42)"], {
-      stdio: 'ignore',
-      timeout: 3000,
-    })
-    return true
-  } catch {
-    return false
-  }
-}
-
-function resolveAdhdevMcpEntryPath(explicitPath?: string): string | null {
-  const explicit = explicitPath?.trim()
-  if (explicit) return normalizeExistingPath(explicit) || explicit
-
-  const envPath = process.env.ADHDEV_MCP_SERVER_PATH?.trim()
-  if (envPath) return normalizeExistingPath(envPath) || envPath
-
-  const candidates: string[] = []
-  const addCandidate = (candidate: string) => {
-    if (!candidates.includes(candidate)) candidates.push(candidate)
-  }
-  const addPackagedCandidates = (baseFile?: string) => {
-    if (!baseFile) return
-    const realBase = normalizeExistingPath(baseFile) || baseFile
-    const dir = dirname(realBase)
-    addCandidate(resolve(dir, '../vendor/mcp-server/index.js'))
-    addCandidate(resolve(dir, '../../vendor/mcp-server/index.js'))
-    addCandidate(resolve(dir, '../../../vendor/mcp-server/index.js'))
-    // Source checkout/dev mode does not vendor the MCP server into daemon-standalone.
-    // Resolve the sibling workspace build directly so Repo Mesh auto-import still
-    // writes an absolute Node entrypoint instead of falling back to a PATH bin shim.
-    addCandidate(resolve(dir, '../../mcp-server/dist/index.js'))
-    addCandidate(resolve(dir, '../../../mcp-server/dist/index.js'))
-  }
-
-  addPackagedCandidates(process.argv[1])
-
-  for (const candidate of candidates) {
-    const normalized = normalizeExistingPath(candidate)
-    if (normalized) return normalized
-  }
-
-  try {
-    const requireBase = process.argv[1] ? (normalizeExistingPath(process.argv[1]) || process.argv[1]) : join(process.cwd(), 'adhdev-daemon.js')
-    const req = createRequire(requireBase)
-    const resolvedModule = req.resolve('@adhdev/mcp-server')
-    return normalizeExistingPath(resolvedModule) || resolvedModule
-  } catch {
-    return null
-  }
-}
-
-function normalizeExistingPath(filePath: string): string | null {
-  try {
-    if (!existsSync(filePath)) return null
-    return realpathSync.native(filePath)
-  } catch {
-    return null
-  }
-}