@adhdev/daemon-core 0.9.82-rc.65 → 0.9.82-rc.67

package/dist/installer.d.ts

@@ -28,10 +28,7 @@ export interface InstallResult {
     alreadyInstalled: boolean;
     error?: string;
 }
-/**
- * Check if an extension is already installed
- */
-export declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): boolean;
+export declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): Promise<boolean>;
 /**
  * Install a single extension
  */

package/dist/launch.d.ts

@@ -18,7 +18,7 @@
 /** Kill IDE process (graceful → force) */
 export declare function killIdeProcess(ideId: string): Promise<boolean>;
 /** Check if IDE process is running */
-export declare function isIdeRunning(ideId: string): boolean;
+export declare function isIdeRunning(ideId: string): Promise<boolean>;
 export interface LaunchOptions {
     ideId?: string;
     workspace?: string;

package/dist/logging/async-batch-writer.d.ts

@@ -0,0 +1,10 @@
+export declare class AsyncBatchWriter {
+    private static buffers;
+    private static writePromises;
+    private static flushTimer;
+    /**
+     * Queues data to be written to a file asynchronously in a batch.
+     */
+    static write(filePath: string, data: string): void;
+    private static flushAll;
+}

package/dist/mesh/beads-db.d.ts

@@ -0,0 +1,18 @@
+import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
+export declare class BeadsDB {
+    private static instance;
+    private readonly db;
+    private readonly migratedMeshIds;
+    private constructor();
+    static getInstance(): BeadsDB;
+    static resetForTests(): void;
+    close(): void;
+    transaction<T>(fn: () => T): T;
+    private migrate;
+    private ensureLegacyQueueMigrated;
+    getQueueEntries(meshId: string, statuses?: MeshTaskStatus[]): MeshWorkQueueEntry[];
+    getQueueRevision(meshId: string): string;
+    replaceQueue(meshId: string, queue: MeshWorkQueueEntry[]): void;
+    deleteQueue(meshId: string): void;
+    private toRow;
+}

package/dist/mesh/mesh-work-queue.d.ts

@@ -66,6 +66,7 @@ export declare function enqueueTask(meshId: string, message: string, opts?: {
 export declare function getQueue(meshId: string, opts?: {
     status?: MeshTaskStatus[];
 }): MeshWorkQueueEntry[];
+export declare function getMeshQueueRevision(meshId: string): string;
 /**
  * Find the next pending task that this node is allowed to claim, and mark it as assigned.
  */
@@ -123,3 +124,6 @@ export interface MeshWorkQueueStats {
  * Return aggregate queue statistics for the given mesh.
  */
 export declare function getMeshQueueStats(meshId: string): MeshWorkQueueStats;
+export declare function __replaceMeshQueueForTests(meshId: string, queue: MeshWorkQueueEntry[]): void;
+export declare function __clearMeshQueueForTests(meshId: string): void;
+export declare function __resetBeadsDBForTests(): void;

package/dist/status/reporter.d.ts

@@ -46,6 +46,8 @@ export declare class DaemonStatusReporter {
     private lastStatusSentAt;
     private statusPendingThrottle;
     private lastP2PStatusHash;
+    private lastP2PStatusSentAt;
+    private p2pDebounceTimer;
     private lastServerStatusHash;
     private lastStatusSummary;
     private statusTimer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.65",
+  "version": "0.9.82-rc.67",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,6 +49,7 @@
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "@xterm/xterm": "^6.0.0",
+    "better-sqlite3": "^12.10.0",
     "chalk": "^5.3.0",
     "chokidar": "^4.0.3",
     "conf": "^13.0.0",
@@ -60,6 +61,7 @@
     "@adhdev/ghostty-vt-node": "*"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",

package/src/cli-adapters/provider-cli-shared.ts

@@ -484,17 +484,25 @@ export function findBinary(name: string): string {
         return path.isAbsolute(expanded) ? expanded : path.resolve(expanded);
     }
     const isWin = os.platform() === 'win32';
-    try {
-        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-        return execSync(cmd, {
-            encoding: 'utf-8',
-            timeout: 5000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            ...(isWin ? { windowsHide: true } : {}),
-        }).trim().split('\n')[0].trim();
-    } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+    const paths = (process.env.PATH || '').split(path.delimiter);
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                const fs = require('fs');
+                if (fs.existsSync(fullPath)) {
+                    const stat = fs.statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return isWin ? `${trimmed}.cmd` : trimmed;
 }
 
 export function isScriptBinary(binaryPath: string): boolean {

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
-  }
-}

package/src/commands/router.ts

@@ -53,6 +53,7 @@ import {
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
+import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
 import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
 import { homedir } from 'os';
 import { join as pathJoin, resolve as pathResolve } from 'path';
@@ -1084,6 +1085,24 @@ type MeshRefinePatchEquivalenceSummary = {
     stderr?: string;
 };
 
+type MeshRefineSubmoduleReachabilityEntry = {
+    path: string;
+    commit: string;
+    reachable: boolean;
+    checkedLocal?: boolean;
+    fetchedFromOrigin?: boolean;
+    error?: string;
+};
+
+type MeshRefineSubmoduleReachabilitySummary = {
+    status: MeshRefineStageStatus;
+    checked: number;
+    unreachable: MeshRefineSubmoduleReachabilityEntry[];
+    entries: MeshRefineSubmoduleReachabilityEntry[];
+    durationMs: number;
+    error?: string;
+};
+
 type MeshRefineAsyncJobStatus = 'accepted' | 'completed' | 'failed';
 
 type MeshRefineJobHandle = {
@@ -1216,6 +1235,95 @@ async function runMeshRefinePatchEquivalenceGate(
     }
 }
 
+async function runMeshRefineSubmoduleReachabilityGate(
+    repoRoot: string,
+    mergedTree: string,
+): Promise<MeshRefineSubmoduleReachabilitySummary> {
+    const startedAt = Date.now();
+    const entries: MeshRefineSubmoduleReachabilityEntry[] = [];
+    try {
+        const { execFile } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const execFileAsync = promisify(execFile);
+        const runGit = async (cwd: string, args: string[]): Promise<string> => {
+            const { stdout } = await execFileAsync('git', args, {
+                cwd,
+                encoding: 'utf8',
+                timeout: 30_000,
+                maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+                windowsHide: true,
+            });
+            return String(stdout || '');
+        };
+
+        const treeOutput = await runGit(repoRoot, ['ls-tree', '-r', '-z', mergedTree]);
+        const gitlinks = treeOutput
+            .split('\0')
+            .filter(Boolean)
+            .map(record => {
+                const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record);
+                return match ? { commit: match[1], path: match[2] } : null;
+            })
+            .filter((entry): entry is { commit: string; path: string } => !!entry);
+
+        for (const gitlink of gitlinks) {
+            const submodulePath = pathResolve(repoRoot, gitlink.path);
+            const entry: MeshRefineSubmoduleReachabilityEntry = {
+                path: gitlink.path,
+                commit: gitlink.commit,
+                reachable: false,
+            };
+            try {
+                if (!fs.existsSync(submodulePath)) {
+                    entry.error = `Submodule checkout missing at ${gitlink.path}`;
+                    entries.push(entry);
+                    continue;
+                }
+
+                entry.checkedLocal = true;
+                try {
+                    await runGit(submodulePath, ['cat-file', '-e', `${gitlink.commit}^{commit}`]);
+                    entry.reachable = true;
+                    entries.push(entry);
+                    continue;
+                } catch {
+                    // Probe the submodule remote before allowing cleanup/completion.
+                }
+
+                try {
+                    await runGit(submodulePath, ['fetch', 'origin', gitlink.commit]);
+                    entry.fetchedFromOrigin = true;
+                    await runGit(submodulePath, ['cat-file', '-e', `${gitlink.commit}^{commit}`]);
+                    entry.reachable = true;
+                } catch (e: any) {
+                    entry.error = truncateValidationOutput(e?.stderr || e?.message || String(e));
+                }
+            } catch (e: any) {
+                entry.error = truncateValidationOutput(e?.message || String(e));
+            }
+            entries.push(entry);
+        }
+
+        const unreachable = entries.filter(entry => !entry.reachable);
+        return {
+            status: unreachable.length ? 'failed' : 'passed',
+            checked: entries.length,
+            unreachable,
+            entries,
+            durationMs: Date.now() - startedAt,
+        };
+    } catch (e: any) {
+        return {
+            status: 'failed',
+            checked: entries.length,
+            unreachable: entries.filter(entry => !entry.reachable),
+            entries,
+            durationMs: Date.now() - startedAt,
+            error: truncateValidationOutput(e?.message || String(e)),
+        };
+    }
+}
+
 function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown> {
     const plan = resolveMeshRefineValidationPlan(mesh, workspace);
     return {
@@ -1599,7 +1707,7 @@ export class DaemonCommandRouter {
      *  the mesh doesn't exist in the local meshes.json file. */
     private inlineMeshCache = new Map<string, any>();
     /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
-    private aggregateMeshStatusCache = new Map<string, { builtAt: number; snapshot: any }>();
+    private aggregateMeshStatusCache = new Map<string, { builtAt: number; snapshot: any; queueRevision: string }>();
     /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
     private runningRefineJobs = new Map<string, MeshRefineJobHandle>();
     /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
@@ -1689,6 +1797,7 @@ export class DaemonCommandRouter {
     private getCachedAggregateMeshStatus(meshId: string, mesh?: any, options?: { requireDirectPeerTruth?: boolean }): any | null {
         const cached = this.aggregateMeshStatusCache.get(meshId);
         if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
+        if (cached.queueRevision !== getMeshQueueRevision(meshId)) return null;
         let snapshot = this.cloneJsonValue(cached.snapshot);
         snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
         if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
@@ -1733,7 +1842,7 @@ export class DaemonCommandRouter {
                 returnedAt: new Date(builtAt).toISOString(),
             },
         };
-        this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next) });
+        this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next), queueRevision: getMeshQueueRevision(meshId) });
         return next;
     }
 
@@ -2566,6 +2675,38 @@ export class DaemonCommandRouter {
                 };
             }
 
+            const submoduleReachabilityStarted = Date.now();
+            const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
+            recordMeshRefineStage(refineStages, 'submodule_reachability', submoduleReachability.status, submoduleReachabilityStarted, {
+                checked: submoduleReachability.checked,
+                unreachable: submoduleReachability.unreachable.map(entry => ({ path: entry.path, commit: entry.commit, error: entry.error })),
+                error: submoduleReachability.error,
+            });
+            if (submoduleReachability.status === 'failed') {
+                return {
+                    success: false,
+                    code: 'submodule_reachability_failed',
+                    convergenceStatus: 'blocked_review',
+                    error: 'Refinery submodule reachability preflight failed; merge/refine cleanup was not attempted.',
+                    branch,
+                    into: baseBranch,
+                    validationSummary,
+                    patchEquivalence,
+                    submoduleReachability,
+                    refineStages,
+                    finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: 'passed',
+                patchEquivalence: 'passed',
+                submoduleReachability: 'failed',
+                status: 'blocked_review',
+                    },
+                };
+            }
+
             let mergeResult: Record<string, unknown> | undefined;
             const mergeStarted = Date.now();
             try {
@@ -4962,7 +5103,7 @@ export class DaemonCommandRouter {
 
         // 3. Kill OS process if requested
         if (killProcess) {
-            const running = isIdeRunning(ideType);
+            const running = await isIdeRunning(ideType);
             if (running) {
                 LOG.info('StopIDE', `Killing IDE process: ${ideType}`);
                 const killed = await killIdeProcess(ideType);

package/src/detection/ide-detector.ts

@@ -7,8 +7,10 @@
  * Migrated from @adhdev/core — this is now the single source of truth.
  */
 
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+import { existsSync, statSync } from 'fs';
 import { platform, homedir } from 'os';
 import * as path from 'path';
 import type { ProviderLoader } from '../providers/provider-loader.js';
@@ -73,25 +75,33 @@ function findCliCommand(command: string): string | null {
         const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
         return existsSync(resolved) ? resolved : null;
     }
-    try {
-        const result = execSync(
-            platform() === 'win32' ? `where ${trimmed}` : `which ${trimmed}`,
-            { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }
-        ).trim();
-        return result.split('\n')[0] || null;
-    } catch {
-        return null;
+    const isWin = platform() === 'win32';
+    const paths = (process.env.PATH || '').split(isWin ? ';' : ':');
+    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+            const fullPath = path.join(p, trimmed + ext);
+            try {
+                if (existsSync(fullPath)) {
+                    const stat = statSync(fullPath);
+                    if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+                        return fullPath;
+                    }
+                }
+            } catch { }
+        }
     }
+    return null;
 }
 
-function getIdeVersion(cliCommand: string): string | null {
+async function getIdeVersion(cliCommand: string): Promise<string | null> {
     try {
-        const result = execSync(`"${cliCommand}" --version`, {
+        const { stdout } = await execAsync(`"${cliCommand}" --version`, {
             encoding: 'utf-8',
             timeout: 10000,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        return result.split('\n')[0] || null;
+        });
+        return stdout.trim().split('\n')[0] || null;
     } catch {
         return null;
     }
@@ -152,7 +162,7 @@ export async function detectIDEs(providerLoader?: ProviderLoader): Promise<IDEIn
         const installed = os === 'darwin'
             ? !!(resolvedCli || appPath)
             : !!resolvedCli;
-        const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
+        const version = resolvedCli ? await getIdeVersion(resolvedCli) : null;
 
         results.push({
             id: def.id,

package/src/index.ts

@@ -186,7 +186,7 @@ export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence }
 export type { MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, normalizeMeshTaskMode, validateMeshTaskModeRequest } from './mesh/mesh-work-queue.js';
+export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult } from './mesh/mesh-work-queue.js';
 export { buildMeshActiveWork, buildMeshActiveWorkSummary } from './mesh/mesh-active-work.js';
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource } from './mesh/mesh-active-work.js';

package/src/installer.d.ts

@@ -31,7 +31,7 @@ export interface InstallResult {
 /**
  * Check if an extension is already installed
  */
-export declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): boolean;
+export declare function isExtensionInstalled(ide: IDEInfo, marketplaceId: string): Promise<boolean>;
 /**
  * Install a single extension
  */