@adhdev/daemon-core 0.9.82-rc.332 → 0.9.82-rc.334

package/dist/mesh/mesh-runtime-store.d.ts

@@ -82,7 +82,24 @@ export declare class MeshRuntimeStore {
         sessionId?: string;
         message: string;
     }>;
-    findAssignedBySession(meshId: string, sessionId: string, occurredAtIso?: string): MeshWorkQueueEntry | null;
+    /**
+     * Resolve the `assigned` queue row a completion event belongs to.
+     *
+     * Clock-skew safety (C2): a completion event's `occurredAtIso` carries the
+     * REMOTE WORKER's clock, while `updated_at` carries the COORDINATOR's clock
+     * (set at assignment and re-bumped on every mutation). For a remote node,
+     * coordinator-clock > worker-clock skew used to make an `updated_at <= occurredAt`
+     * filter return nothing, stranding the finished task as `assigned` forever.
+     *
+     * We therefore NEVER filter completion-matching on the mutable `updated_at`:
+     *  1. If `taskId` is given, match the exact `assigned` row by id (no time filter).
+     *  2. Otherwise a session holds at most one `assigned` task — match it without a
+     *     time filter. If several exist (shouldn't normally), disambiguate by the
+     *     IMMUTABLE `dispatchTimestamp`: latest `dispatchTimestamp <= occurredAt`,
+     *     and if skew makes ALL of them later than `occurredAt`, fall back to the
+     *     most-recent `dispatchTimestamp` rather than returning null.
+     */
+    findAssignedBySession(meshId: string, sessionId: string, occurredAtIso?: string, taskId?: string): MeshWorkQueueEntry | null;
     private toRow;
     insertDirectDispatch(entry: {
         taskId: string;

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

@@ -225,6 +225,7 @@ export declare function requeueTask(meshId: string, taskId: string, opts?: {
  */
 export declare function updateSessionTaskStatus(meshId: string, sessionId: string, status: MeshTaskStatus, opts?: {
     occurredAt?: string;
+    taskId?: string;
 }): MeshWorkQueueEntry | null;
 /**
  * M1-3: true when at least one pending task is waiting on the given task.

package/dist/mesh/refine-config.d.ts

@@ -194,6 +194,7 @@ export declare const MESH_REFINE_CONFIG_SCHEMA: {
     };
 };
 export declare function isMeshConfigRecord(value: unknown): value is Record<string, unknown>;
+export declare function tokenizeCommandString(command: string): string[] | null;
 export declare function normalizeMeshCommandConfig(entry: unknown, source: string): {
     command?: MeshRefineValidationCommandPlan;
     rejected?: Record<string, unknown>;

package/dist/system/load-better-sqlite3.d.ts

@@ -0,0 +1,21 @@
+import type BetterSqlite3 from 'better-sqlite3';
+/**
+ * Load the `better-sqlite3` constructor in a way that survives every runtime the
+ * daemon ships in.
+ *
+ * The naive `typeof require === 'function' ? require : createRequire(import.meta.url)`
+ * is unsafe inside the daemon-cloud bundle: esbuild emits CJS output but, for any
+ * chunk that touches `import.meta.url`, it shims the local `require` with a stub
+ * that THROWS `Dynamic require of "..." is not supported`. That stub is still
+ * `typeof === 'function'`, so the ternary picks it and the call throws — it never
+ * reaches the `createRequire` fallback. The failure surfaced as `mesh_send_task`
+ * crashing the whole tool call instead of gracefully degrading.
+ *
+ * The robust approach is to ATTEMPT the real `require` and CATCH the esbuild stub's
+ * throw, then fall back to `createRequire`. We try multiple resolution bases so the
+ * load works whether the code runs as:
+ *   - a genuine CJS module (bare `require` works),
+ *   - an esbuild CJS bundle with the throwing `require` shim (createRequire(import.meta.url)),
+ *   - a pure ESM module where `require` is undefined (createRequire(import.meta.url)).
+ */
+export declare function loadBetterSqlite3(): typeof BetterSqlite3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.332",
+  "version": "0.9.82-rc.334",
   "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.332",
+    "@adhdev/mesh-shared": "0.9.82-rc.334",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -93,6 +93,7 @@ import * as fs from 'fs';
 import { execFileSync } from 'node:child_process';
 import { normalizeInteractivePromptResponse } from '../providers/types/interactive-prompt.js';
 import { workingDirBasename } from '../providers/working-dir.js';
+import { resolveWin32Executable } from '../cli-adapters/resolve-executable.js';
 
 type ReleaseChannel = 'stable' | 'preview';
 const CHANNEL_NPM_TAG: Record<ReleaseChannel, 'latest' | 'next'> = { stable: 'latest', preview: 'next' };
@@ -1675,6 +1676,8 @@ type MeshRefineValidationSummary = {
     skippedReason?: string;
     failureKind?: string;
     failureCode?: string;
+    /** Human-readable cause when failureKind === 'spawn_resolution_failed' (win32 .cmd shim, etc). */
+    spawnResolutionError?: string;
     timeoutMs: number;
     outputLimitBytes: number;
     configSource?: string;
@@ -1895,6 +1898,32 @@ function truncateValidationOutput(value: unknown): string {
     return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}\n[truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
 }
 
+/**
+ * A spawn-resolution failure is when the executable itself could not be found by
+ * the OS spawn boundary — `spawn <cmd> ENOENT` — as opposed to the command
+ * running and exiting non-zero. On win32 this is the .cmd-shim case: libuv's
+ * spawn search appends only .com/.exe, so a bare `npm`/`npx`/`tsc` (which are
+ * .cmd shims) ENOENTs even though it is installed. It carries no stderr, so it
+ * must be detected by error.code/syscall, not by string-matching output.
+ */
+export function isSpawnResolutionError(error: any): boolean {
+    if (!error) return false;
+    if (error.code === 'ENOENT' && typeof error.syscall === 'string' && error.syscall.startsWith('spawn')) return true;
+    // Fall back to code alone: execFile sets syscall on the spawn boundary error,
+    // but guard for environments/mocks that only surface the code.
+    return error.code === 'ENOENT' && (error.syscall === undefined || String(error.syscall).startsWith('spawn'));
+}
+
+export function describeSpawnError(error: any, command: string, spawnResolutionFailed: boolean): string {
+    if (spawnResolutionFailed) {
+        const hint = process.platform === 'win32'
+            ? ' On Windows, npm-family commands (npm/npx/tsc/vitest) are .cmd shims that the bare-command spawn search does not resolve; configure an absolute path or ensure the command is on PATH.'
+            : '';
+        return `Could not resolve executable "${command}" (spawn ENOENT).${hint}`;
+    }
+    return String(error?.message || error);
+}
+
 function recordMeshRefineStage(
     stages: Array<Record<string, unknown>>,
     stage: string,
@@ -3119,8 +3148,13 @@ async function runMeshRefineValidationGate(
             const startedAt = Date.now();
             const cwd = candidate.cwd ? pathResolve(workspace, candidate.cwd) : workspace;
             const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
+            // On win32, libuv's spawn search only appends .com/.exe (not .cmd/.bat),
+            // so a bare `npm`/`npx`/`tsc` (which are .cmd shims) throws spawn ENOENT.
+            // Resolve to an absolute path via the same helper the PTY path uses
+            // (no-op on non-win32 and when the command is already absolute).
+            const resolvedCommand = resolveWin32Executable(candidate.command);
             try {
-                const result = await execFileAsync(candidate.command, candidate.args, {
+                const result = await execFileAsync(resolvedCommand, candidate.args, {
                     cwd,
                     encoding: 'utf8',
                     timeout,
@@ -3129,16 +3163,19 @@ async function runMeshRefineValidationGate(
                 });
                 summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
             } catch (error: any) {
+                const spawnResolutionFailed = isSpawnResolutionError(error);
                 summary.bootstrapCommandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
                     exitCode: typeof error?.code === 'number' ? error.code : null,
                     signal: typeof error?.signal === 'string' ? error.signal : null,
                     timedOut: error?.killed === true || /timed out/i.test(String(error?.message || '')),
-                    failureKind: 'dependency_bootstrap_failed',
+                    ...(spawnResolutionFailed
+                        ? { failureKind: 'spawn_resolution_failed', resolvedCommand }
+                        : { failureKind: 'dependency_bootstrap_failed' }),
                 }));
-                summary.bootstrap = { stage: 'failed', error: String(error?.message || error) };
+                summary.bootstrap = { stage: 'failed', error: describeSpawnError(error, candidate.command, spawnResolutionFailed) };
                 summary.status = 'failed';
-                summary.failureKind = 'dependency_bootstrap_failed';
-                summary.failureCode = 'dependency_bootstrap_failed';
+                summary.failureKind = spawnResolutionFailed ? 'spawn_resolution_failed' : 'dependency_bootstrap_failed';
+                summary.failureCode = spawnResolutionFailed ? 'spawn_resolution_failed' : 'dependency_bootstrap_failed';
                 return summary;
             }
         }
@@ -3162,8 +3199,11 @@ async function runMeshRefineValidationGate(
             summary.failureCode = 'missing_dependencies';
             return summary;
         }
+        // See the bootstrap loop above: resolve the win32 .cmd shim to an
+        // absolute path before handing it to the spawn boundary.
+        const resolvedCommand = resolveWin32Executable(candidate.command);
         try {
-            const result = await execFileAsync(candidate.command, candidate.args, {
+            const result = await execFileAsync(resolvedCommand, candidate.args, {
                 cwd,
                 encoding: 'utf8',
                 timeout,
@@ -3172,16 +3212,28 @@ async function runMeshRefineValidationGate(
             });
             summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, result, true, { exitCode: 0 }));
         } catch (error: any) {
+            // ENOENT check first: a spawn-resolution failure ("spawn npm ENOENT")
+            // carries no stderr and would otherwise fall through to an
+            // unclassified generic failure. Classify it distinctly so the
+            // coordinator surfaces the real cause (win32 .cmd resolution).
+            const spawnResolutionFailed = isSpawnResolutionError(error);
             const stderr = truncateValidationOutput(error?.stderr || error?.message);
-            const missingDependencyFailure = /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
+            const missingDependencyFailure = !spawnResolutionFailed
+                && /Cannot find module|MODULE_NOT_FOUND|node_modules|command not found|not found/i.test(stderr);
             summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, error, false, {
                 exitCode: typeof error?.code === 'number' ? error.code : null,
                 signal: typeof error?.signal === 'string' ? error.signal : null,
                 timedOut: error?.killed === true || /timed out/i.test(String(error?.message || '')),
-                ...(missingDependencyFailure ? { failureKind: 'missing_dependencies' } : {}),
+                ...(spawnResolutionFailed
+                    ? { failureKind: 'spawn_resolution_failed', resolvedCommand }
+                    : missingDependencyFailure ? { failureKind: 'missing_dependencies' } : {}),
             }));
             summary.status = 'failed';
-            if (missingDependencyFailure) {
+            if (spawnResolutionFailed) {
+                summary.failureKind = 'spawn_resolution_failed';
+                summary.failureCode = 'spawn_resolution_failed';
+                summary.spawnResolutionError = describeSpawnError(error, candidate.command, true);
+            } else if (missingDependencyFailure) {
                 summary.failureKind = 'missing_dependencies';
                 summary.failureCode = 'missing_dependencies';
             }
@@ -4776,7 +4828,10 @@ export class DaemonCommandRouter {
                         ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
                         : validationSummary.failureCode === 'dependency_bootstrap_failed'
                             ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
-                            : 'Refinery validation gate failed; merge/refine was not attempted.';
+                            : validationSummary.failureCode === 'spawn_resolution_failed'
+                                ? (validationSummary.spawnResolutionError
+                                    || 'Refinery validation command could not be spawned (executable not found); merge/refine was not attempted.')
+                                : 'Refinery validation gate failed; merge/refine was not attempted.';
                     if (!firstFailedCmd) return base;
                     const cmdName = typeof firstFailedCmd.displayCommand === 'string' ? firstFailedCmd.displayCommand
                         : typeof firstFailedCmd.command === 'string'

package/src/mesh/mesh-events-coordinator.ts

@@ -1534,8 +1534,12 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     }
 
     function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null): { id?: string } | null {
+        // C2: prefer an exact taskId match when the completion event carries one —
+        // it's immune to coordinator↔worker clock skew that can hide the assigned row.
+        const eventTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
         const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
             occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
+            taskId: eventTaskId,
         });
         updateDirectDispatchStatus(args.meshId, sessionId, outcome);
         markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);

package/src/mesh/mesh-runtime-store.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'fs';
 import { dirname, join } from 'path';
-import { createRequire } from 'module';
+import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags } from './mesh-work-queue.js';
 import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
@@ -11,10 +11,7 @@ let DatabaseCtor: typeof BetterSqlite3 | undefined;
 
 function loadDatabaseCtor(): typeof BetterSqlite3 {
     if (DatabaseCtor) return DatabaseCtor;
-    const runtimeRequire = typeof require === 'function'
-        ? require
-        : createRequire(import.meta.url);
-    DatabaseCtor = runtimeRequire('better-sqlite3') as typeof BetterSqlite3;
+    DatabaseCtor = loadBetterSqlite3() as typeof BetterSqlite3;
     return DatabaseCtor;
 }
 
@@ -701,15 +698,66 @@ export class MeshRuntimeStore {
         });
     }
 
-    findAssignedBySession(meshId: string, sessionId: string, occurredAtIso?: string): MeshWorkQueueEntry | null {
+    /**
+     * Resolve the `assigned` queue row a completion event belongs to.
+     *
+     * Clock-skew safety (C2): a completion event's `occurredAtIso` carries the
+     * REMOTE WORKER's clock, while `updated_at` carries the COORDINATOR's clock
+     * (set at assignment and re-bumped on every mutation). For a remote node,
+     * coordinator-clock > worker-clock skew used to make an `updated_at <= occurredAt`
+     * filter return nothing, stranding the finished task as `assigned` forever.
+     *
+     * We therefore NEVER filter completion-matching on the mutable `updated_at`:
+     *  1. If `taskId` is given, match the exact `assigned` row by id (no time filter).
+     *  2. Otherwise a session holds at most one `assigned` task — match it without a
+     *     time filter. If several exist (shouldn't normally), disambiguate by the
+     *     IMMUTABLE `dispatchTimestamp`: latest `dispatchTimestamp <= occurredAt`,
+     *     and if skew makes ALL of them later than `occurredAt`, fall back to the
+     *     most-recent `dispatchTimestamp` rather than returning null.
+     */
+    findAssignedBySession(
+        meshId: string,
+        sessionId: string,
+        occurredAtIso?: string,
+        taskId?: string,
+    ): MeshWorkQueueEntry | null {
         this.ensureLegacyQueueMigrated(meshId);
-        // Use updated_at (≈ dispatchTimestamp when status='assigned') for the occurredAt filter.
-        const sql = occurredAtIso
-            ? `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' AND updated_at <= ? ORDER BY updated_at DESC LIMIT 1`
-            : `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' ORDER BY updated_at DESC LIMIT 1`;
-        const args: string[] = occurredAtIso ? [meshId, sessionId, occurredAtIso] : [meshId, sessionId];
-        const row = this.db.prepare(sql).get(...args as [string, string, string?]) as { payload: string } | undefined;
-        return row ? JSON.parse(row.payload) as MeshWorkQueueEntry : null;
+
+        // 1. Exact taskId match — robust against clock skew and stale rows.
+        if (taskId) {
+            const row = this.db.prepare(
+                `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned' AND id = ? LIMIT 1`
+            ).get(meshId, sessionId, taskId) as { payload: string } | undefined;
+            if (row) return JSON.parse(row.payload) as MeshWorkQueueEntry;
+            // Fall through to session-based matching if the id didn't line up
+            // (e.g. event carried a stale/foreign taskId).
+        }
+
+        // 2. Session-based match WITHOUT the mutable updated_at filter.
+        const rows = this.db.prepare(
+            `SELECT payload FROM mesh_queue WHERE mesh_id = ? AND assigned_session_id = ? AND status = 'assigned'`
+        ).all(meshId, sessionId) as Array<{ payload: string }>;
+        if (rows.length === 0) return null;
+
+        const entries = rows
+            .map(r => { try { return JSON.parse(r.payload) as MeshWorkQueueEntry; } catch { return null; } })
+            .filter((e): e is MeshWorkQueueEntry => e !== null);
+        if (entries.length === 0) return null;
+        if (entries.length === 1) return entries[0];
+
+        // Multiple assigned rows for one session: disambiguate by the immutable
+        // dispatchTimestamp (falling back to updated_at only for legacy rows that
+        // predate dispatchTimestamp). We use these to ORDER, never to FILTER —
+        // so a skewed occurredAt can never drop the live row to null.
+        const orderKey = (e: MeshWorkQueueEntry) => e.dispatchTimestamp ?? e.updatedAt ?? '';
+        const byDispatchDesc = [...entries].sort((a, b) => orderKey(b).localeCompare(orderKey(a)));
+        if (occurredAtIso) {
+            const atOrBefore = byDispatchDesc.find(e => orderKey(e) <= occurredAtIso);
+            if (atOrBefore) return atOrBefore;
+        }
+        // Skew made every dispatch later than occurredAt — fall back to the
+        // most-recently dispatched row rather than stranding the completion.
+        return byDispatchDesc[0];
     }
 
     private toRow(entry: MeshWorkQueueEntry): Record<string, unknown> {

package/src/mesh/mesh-work-queue.ts

@@ -4,6 +4,7 @@ import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
 import { MESH_CONVERGE_REFINE_TAG, resolveAutoConvergeCodeChange } from '../repo-mesh-types.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { getMesh } from '../config/mesh-config.js';
+import { LOG } from '../logging/logger.js';
 
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
@@ -880,14 +881,27 @@ export function updateSessionTaskStatus(
     meshId: string,
     sessionId: string,
     status: MeshTaskStatus,
-    opts?: { occurredAt?: string },
+    opts?: { occurredAt?: string; taskId?: string },
 ): MeshWorkQueueEntry | null {
     return withQueueLock(meshId, () => {
+        const store = MeshRuntimeStore.getInstance();
         const occurredAtIso = opts?.occurredAt ? new Date(opts.occurredAt).toISOString() : undefined;
-        const entry = MeshRuntimeStore.getInstance().findAssignedBySession(meshId, sessionId, occurredAtIso);
-        if (!entry) return null;
+        const entry = store.findAssignedBySession(meshId, sessionId, occurredAtIso, opts?.taskId);
+        if (!entry) {
+            // C2: the silent null here is exactly what stranded a finished task as
+            // `assigned` for 19 minutes. If the session still has an assigned row we
+            // failed to resolve, surface it loudly instead of dropping the completion.
+            const assignedRows = store.getActiveAssignmentDetails(meshId)
+                .filter(r => r.sessionId === sessionId);
+            if (assignedRows.length > 0) {
+                LOG.warn('MeshQueue', `No assigned queue row matched completion for mesh ${meshId} session ${sessionId} `
+                    + `(taskId=${opts?.taskId ?? 'none'}, occurredAt=${occurredAtIso ?? 'none'}); `
+                    + `${assignedRows.length} assigned row(s) exist: ${assignedRows.map(r => r.id).join(',')}`);
+            }
+            return null;
+        }
         entry.status = status;
-        MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        store.updateQueueEntry(entry);
         if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, entry.id);
         return entry;
     });

package/src/mesh/refine-config.ts

@@ -164,15 +164,35 @@ export function isMeshConfigRecord(value: unknown): value is Record<string, unkn
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
-function tokenizeCommandString(command: string): string[] | null {
+// True shell metacharacters — never allowed anywhere in a config command, on
+// any platform. Note: backslash is deliberately NOT in this set; it is handled
+// separately (allowed only in the win32 executable token).
+const SHELL_METACHAR_RE = /[;&|<>`$\n\r'"]/;
+// Per-token allowlist for argument tokens and non-win32 executable tokens.
+const SAFE_TOKEN_RE = /^[A-Za-z0-9_@./:=+-]+$/;
+// Executable token on win32: same as SAFE_TOKEN_RE but also permits backslash so
+// an absolute path like C:\Users\me\AppData\Roaming\npm\npm.cmd is accepted.
+const SAFE_WIN32_EXEC_TOKEN_RE = /^[A-Za-z0-9_@./:=+\\-]+$/;
+
+export function tokenizeCommandString(command: string): string[] | null {
     const trimmed = command.trim();
     if (!trimmed) return null;
     // Explicit config may name any executable, but the Refinery never invokes a shell.
     // Reject shell syntax, quotes and substitutions so config cannot smuggle a compound command.
-    if (/[;&|<>`$\\\n\r'\"]/.test(trimmed)) return null;
+    // Backslash is the one exception (handled per-token below): rejecting it here
+    // would block legitimate win32 absolute .cmd paths, but it is never a shell
+    // metacharacter in the no-shell execFile boundary we run under.
+    if (SHELL_METACHAR_RE.test(trimmed)) return null;
     const tokens = trimmed.split(/\s+/).filter(Boolean);
     if (!tokens.length) return null;
-    if (tokens.some(token => !/^[A-Za-z0-9_@./:=+-]+$/.test(token))) return null;
+    const isWin32 = process.platform === 'win32';
+    for (let i = 0; i < tokens.length; i++) {
+        // Backslash is permitted ONLY in the executable (first) token, ONLY on
+        // win32. Every other token (and all tokens off win32) uses the strict
+        // allowlist with no backslash.
+        const re = (isWin32 && i === 0) ? SAFE_WIN32_EXEC_TOKEN_RE : SAFE_TOKEN_RE;
+        if (!re.test(tokens[i])) return null;
+    }
     return tokens;
 }
 

package/src/mesh/worktree-bootstrap-config.ts

@@ -4,6 +4,7 @@ import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { promisify } from 'node:util';
 import * as yaml from 'js-yaml';
+import { resolveWin32Executable } from '../cli-adapters/resolve-executable.js';
 import {
     isMeshConfigRecord,
     normalizeMeshCommandConfig,
@@ -268,8 +269,12 @@ export async function runMeshWorktreeBootstrap(mesh: any, workspace: string): Pr
         const cwd = command.cwd ? pathResolve(workspace, command.cwd) : workspace;
         const startedAt = Date.now();
         state.lastCommand = command.displayCommand;
+        // On win32 a bare npm/npx/tsc is a .cmd shim that libuv's spawn search
+        // (which appends only .com/.exe) cannot resolve → spawn ENOENT. Resolve
+        // to an absolute path first (no-op on non-win32 / already-absolute).
+        const resolvedCommand = resolveWin32Executable(command.command);
         try {
-            const result = await execFileAsync(command.command, command.args, {
+            const result = await execFileAsync(resolvedCommand, command.args, {
                 cwd,
                 encoding: 'utf8',
                 timeout: command.timeoutMs || DEFAULT_TIMEOUT_MS,

package/src/providers/native-history/hermes-cli-transcript.ts

@@ -19,6 +19,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { loadBetterSqlite3 } from '../../system/load-better-sqlite3.js';
 
 export interface NativeHistoryMessage {
     id: string;
@@ -61,8 +62,7 @@ function statMtimeMs(p: string): number {
 function openDb(): any | null {
     if (!fs.existsSync(HERMES_STATE_DB)) return null;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const Database = require('better-sqlite3');
+        const Database = loadBetterSqlite3();
         return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
     } catch {
         return null;

package/src/providers/spec/native-history-executor.ts

@@ -22,6 +22,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { LOG } from '../../logging/logger.js';
+import { loadBetterSqlite3 } from '../../system/load-better-sqlite3.js';
 import type {
     NativeHistoryConfig,
     NativeHistoryJsonlSource,
@@ -253,8 +254,7 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
 
     let Database: any;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        Database = require('better-sqlite3');
+        Database = loadBetterSqlite3();
     } catch { return null; }
 
     let db: any;

package/src/system/load-better-sqlite3.ts

@@ -0,0 +1,68 @@
+import { createRequire } from 'module';
+import type BetterSqlite3 from 'better-sqlite3';
+
+let cached: typeof BetterSqlite3 | undefined;
+
+/**
+ * Load the `better-sqlite3` constructor in a way that survives every runtime the
+ * daemon ships in.
+ *
+ * The naive `typeof require === 'function' ? require : createRequire(import.meta.url)`
+ * is unsafe inside the daemon-cloud bundle: esbuild emits CJS output but, for any
+ * chunk that touches `import.meta.url`, it shims the local `require` with a stub
+ * that THROWS `Dynamic require of "..." is not supported`. That stub is still
+ * `typeof === 'function'`, so the ternary picks it and the call throws — it never
+ * reaches the `createRequire` fallback. The failure surfaced as `mesh_send_task`
+ * crashing the whole tool call instead of gracefully degrading.
+ *
+ * The robust approach is to ATTEMPT the real `require` and CATCH the esbuild stub's
+ * throw, then fall back to `createRequire`. We try multiple resolution bases so the
+ * load works whether the code runs as:
+ *   - a genuine CJS module (bare `require` works),
+ *   - an esbuild CJS bundle with the throwing `require` shim (createRequire(import.meta.url)),
+ *   - a pure ESM module where `require` is undefined (createRequire(import.meta.url)).
+ */
+export function loadBetterSqlite3(): typeof BetterSqlite3 {
+    if (cached) return cached;
+
+    const errors: unknown[] = [];
+
+    // 1) Real CJS require, when present and not the esbuild throwing shim.
+    if (typeof require === 'function') {
+        try {
+            cached = require('better-sqlite3') as typeof BetterSqlite3;
+            return cached;
+        } catch (e) {
+            // Either the esbuild "Dynamic require is not supported" shim, or a
+            // genuine resolution failure. Fall through to createRequire.
+            errors.push(e);
+        }
+    }
+
+    // 2) createRequire anchored at this module's URL (works in ESM and in esbuild
+    //    CJS bundles, where import.meta.url is rewritten to a usable value).
+    try {
+        const metaUrl = typeof import.meta?.url === 'string' ? import.meta.url : undefined;
+        if (metaUrl) {
+            cached = createRequire(metaUrl)('better-sqlite3') as typeof BetterSqlite3;
+            return cached;
+        }
+    } catch (e) {
+        errors.push(e);
+    }
+
+    // 3) Last resort: createRequire anchored at the current working directory.
+    try {
+        cached = createRequire(`${process.cwd()}/__adhdev_better_sqlite3_loader__.js`)(
+            'better-sqlite3',
+        ) as typeof BetterSqlite3;
+        return cached;
+    } catch (e) {
+        errors.push(e);
+    }
+
+    const detail = errors
+        .map((e) => (e instanceof Error ? e.message : String(e)))
+        .join('; ');
+    throw new Error(`Failed to load better-sqlite3: ${detail}`);
+}