@adhdev/daemon-core 0.9.82-rc.351 → 0.9.82-rc.353

package/dist/logging/logger.d.ts

@@ -7,7 +7,7 @@
  * 1. daemonLog(category, msg, level) — explicit per-category logging
  * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
  * 3. Recent log ring buffer — for remote transmission via P2P/WS
- * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ * 4. File logging — ~/.adhdev/logs/daemon-YYYY-MM-DD.log (date-based rolling)
  *
  * use:
  * import { daemonLog, LOG } from './daemon-logger';

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

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

@@ -191,6 +191,15 @@ export declare class MeshRuntimeStore {
         createdAt: string;
         updatedAt: string;
     }>;
+    /**
+     * Bug B watchdog support: true when at least one delivery record for the task has
+     * reached a confirmed-handed-off status (delivered / acked / completed). The
+     * assigned-stranded watchdog uses this to distinguish a dispatch that was never
+     * confirmed (reclaimable) from one that WAS handed to the worker (a genuinely
+     * in-flight or completion-lost task, which is PHASE 4's responsibility, not this
+     * watchdog's). Indexed by (mesh_id, task_id).
+     */
+    taskHasConfirmedDelivery(meshId: string, taskId: string): boolean;
     expireStaleSessionDeliveries(meshId: string): void;
     deleteSessionDeliveries(meshId: string): void;
     recordCompletionConflict(entry: {

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

@@ -60,6 +60,14 @@ export interface MeshWorkQueueEntry {
     requeueCount?: number;
     /** Max automatic requeue attempts. When requeueCount reaches this, task is auto-failed. */
     maxRetries?: number;
+    /**
+     * Bug B: number of times the reconcile assigned-stranded watchdog has reclaimed this
+     * row from 'assigned' back to 'pending' because its dispatch was never confirmed
+     * delivered. Separate from requeueCount (operator/execution retries) and bounded by
+     * MAX_STRANDED_RECLAIMS so a permanently-undeliverable target auto-fails rather than
+     * cycling reclaim→re-dispatch→strand forever.
+     */
+    strandedReclaimCount?: number;
     /** Last automatic queue session spin-up attempt, for mesh_view_queue/debug visibility. */
     autoLaunch?: {
         status: 'skipped' | 'started' | 'failed' | 'completed';
@@ -230,6 +238,26 @@ export declare function requeueTask(meshId: string, taskId: string, opts?: {
     /** Per-task retry cap override. Falls back to mesh policy maxTaskRetries (default 1). */
     maxRetries?: number;
 } & MeshQueueMutationOptions): MeshWorkQueueEntry | null;
+/**
+ * Bug B: reclaim a task stuck in 'assigned' because its dispatch was never confirmed.
+ *
+ * claimNextTask atomically marks a row 'assigned' BEFORE the fire-and-forget dispatch
+ * runs. If that dispatch neither rejects (→ no .catch requeue) nor is confirmed
+ * delivered — a relay that hangs without acking, or a confirm timer lost across a
+ * daemon restart — the row stays 'assigned' forever, contributing 0 pending so PHASE 3
+ * reconcile never re-examines it. This returns such a row to 'pending' and clears its
+ * dead assignment ownership (node / session / provider / dispatchTimestamp) — the same
+ * ownership-clear requeueTask applies — so PHASE 3 can re-dispatch it onto a fresh idle
+ * session.
+ *
+ * Guarded to 'assigned' rows only (a completion/cancel that already moved the row off
+ * 'assigned' must never be resurrected) and bounded by MAX_STRANDED_RECLAIMS (beyond
+ * which the task is failed so dependents unblock).
+ */
+export declare function reclaimStrandedAssignedTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+    ageMs?: number;
+} & MeshQueueMutationOptions): MeshWorkQueueEntry | null;
 /**
  * Update the status of the task currently assigned to a specific session.
  */

package/dist/providers/approval-utils.d.ts

@@ -1,4 +1,11 @@
 import type { ProviderModule } from './contracts.js';
+/**
+ * True when any of the given button labels reads as a decline/negative option
+ * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal
+ * structural anchor: a real approval modal offers BOTH an affirmative and a
+ * decline, which distinguishes it from a generic numbered menu or prose list.
+ */
+export declare function hasNegativeApprovalOption(buttons: string[] | null | undefined): boolean;
 export declare function getApprovalPositiveHints(provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): string[];
 export declare function pickApprovalButton(buttons: string[] | null | undefined, provider?: Pick<ProviderModule, 'approvalPositiveHints'> | null): {
     index: number;

package/dist/providers/cli-provider-instance.d.ts

@@ -48,6 +48,20 @@ export declare class CliProviderInstance implements ProviderInstance {
      * keystroke until the modal *content* has settled.
      */
     private static readonly AUTO_APPROVE_SETTLE_MS;
+    /**
+     * Busy-side hysteresis for the settle gate. A momentary `generating` flip
+     * while the SAME approval modal's button block is still on screen (its
+     * question line scrolled out of the captured frame, only the buttons + a
+     * residual `esc to interrupt` spinner remain) briefly reports
+     * status!=waiting_approval. Without hysteresis that flip wipes the settle
+     * clock, and the modal→generating→modal flap restarts the 600ms window
+     * every time so auto-approve never fires. We keep the in-progress settle
+     * gate warm across an inactive blip up to this bound; only once the modal
+     * has genuinely stayed gone this long (a real resolution → idle) is the
+     * gate cleared. Bounded so a genuinely new, later approval still re-settles
+     * from scratch rather than firing on a stale timestamp.
+     */
+    private static readonly AUTO_APPROVE_GATE_HYSTERESIS_MS;
     private adapter;
     private context;
     private events;
@@ -64,6 +78,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pendingAutoApprovalSignature;
     private pendingAutoApprovalSince;
     private autoApproveSettleTimer;
+    private autoApproveInactiveSince;
     private controlValues;
     private summaryMetadata;
     private appliedEffectKeys;

package/dist/providers/sdk/v1/builders/cli/detect-status.d.ts

@@ -57,6 +57,7 @@ interface ModalSpec {
     }>;
     buttonPattern: string;
     buttonFlags?: string;
+    buttonLabelGroup?: number;
 }
 export type DispatchGroup = 'spinner' | 'modal' | 'settled-prompt' | 'cue-ordering' | 'error-detection' | 'approval-stitching';
 export interface DispatchOrderSpec {

package/package.json

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

package/src/commands/cli-manager.ts

@@ -1097,10 +1097,19 @@ export class DaemonCliManager {
                 }
             }
         }
- // 2. Fuzzy match (returns first of multiple sessions — may be inaccurate)
-        for (const [k, a] of this.adapters) {
-            if (a.cliType === agentType) {
-                return { adapter: a, key: k };
+ // 2. Fuzzy match (returns first of multiple sessions — may be inaccurate).
+ //    FAIL-CLOSED: only when NO explicit instanceKey/targetSessionId was requested.
+ //    When a specific session WAS named (step 0) but is not hosted on this daemon,
+ //    falling back to the first same-cliType adapter silently redirects the command
+ //    into an UNRELATED session — e.g. a relayed/misrouted mesh send_chat lands in the
+ //    coordinator's own CLI session, echoing the dispatched task body back to the
+ //    coordinator (TASKECHO self-inject). Returning null instead makes the caller
+ //    surface an explicit "not running" error rather than mis-delivering the message.
+        if (!opts?.instanceKey) {
+            for (const [k, a] of this.adapters) {
+                if (a.cliType === agentType) {
+                    return { adapter: a, key: k };
+                }
             }
         }
         return null;

package/src/commands/router.ts

@@ -40,6 +40,7 @@ import {
     summarizeGitShape as sharedSummarizeGitShape,
     normalizeMeshNodeId,
     meshNodeIdMatches,
+    daemonIdsEquivalent,
 } from '@adhdev/mesh-shared';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
@@ -3462,6 +3463,13 @@ const MESH_FORWARDABLE_SESSION_COMMANDS = new Set([
     'set_mode',
     'change_model',
     'set_thought_level',
+    // agent_command (send_chat / clear_history / stop) is session-scoped too: a command
+    // explicitly naming a targetSessionId MUST reach that session wherever it lives, never a
+    // different local session. Without forwarding, a misrouted/relayed send_chat for a REMOTE
+    // worker session that reaches the wrong daemon used to fuzzy-inject the task body into that
+    // daemon's own CLI session (TASKECHO coordinator self-echo). Forwarding to the owning daemon
+    // delivers it to the real worker instead. (findAdapter is also fail-closed as the backstop.)
+    'agent_command',
 ]);
 const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
@@ -3901,7 +3909,10 @@ export class DaemonCommandRouter {
             if (!nodeDaemonId) continue;
             // Only forward to a genuinely remote daemon. When the owning node is this
             // coordinator itself (locally hosted worker), fall through to local handling.
-            if (selfDaemonId && nodeDaemonId === selfDaemonId) return undefined;
+            // id-form robust: the node daemonId and selfDaemonId may be stored in different
+            // forms of the same machine — a strict `===` would miss the self-match and forward
+            // a local session to a remote form of THIS daemon (loopback).
+            if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return undefined;
             return nodeDaemonId;
         }
         return undefined;
@@ -4090,12 +4101,52 @@ export class DaemonCommandRouter {
         return false;
     }
 
+    /**
+     * Best-effort recursive removal of a managed worktree directory.
+     *
+     * The git-registry de-registration is the safety-critical step of worktree
+     * teardown; a leftover directory must never gate dropping the node from the
+     * mesh. On Windows, `fs.rmSync` can throw EINVAL/EPERM/EBUSY on submodule
+     * gitlink (`.git`) files, long paths, junctions, or while a just-stopped
+     * delegate session is still releasing a handle/cwd on the directory. This
+     * helper absorbs those errors (never throws), with bounded retries + backoff
+     * to give handles time to release, and reports whether residue remains.
+     */
+    private async bestEffortRemoveWorktreeDir(dir: string): Promise<{ removed: boolean; residue: boolean; error?: string }> {
+        if (!dir || !fs.existsSync(dir)) return { removed: true, residue: false };
+        const sleep = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms));
+        // EINVAL is the Windows symptom for submodule gitlink residue; the rest are
+        // transient lock/permission classes. None should escape as a throw here.
+        const ABSORB = new Set(['EINVAL', 'EPERM', 'EBUSY', 'ENOTEMPTY', 'EACCES', 'EMFILE', 'ENFILE']);
+        let lastErr: any;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            try {
+                // maxRetries/retryDelay give fs.rmSync its own internal backoff for
+                // EBUSY/EPERM/ENOTEMPTY; the outer loop extends tolerance to EINVAL.
+                fs.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+                if (!fs.existsSync(dir)) return { removed: true, residue: false };
+                lastErr = new Error('directory still present after rmSync');
+            } catch (e: any) {
+                lastErr = e;
+                const code = typeof e?.code === 'string' ? e.code : '';
+                if (code && !ABSORB.has(code)) {
+                    // Unexpected error class — stay best-effort (no throw) but stop retrying.
+                    break;
+                }
+            }
+            await sleep(150 * (attempt + 1));
+        }
+        return fs.existsSync(dir)
+            ? { removed: false, residue: true, error: String(lastErr?.message || lastErr || 'unknown rm error') }
+            : { removed: true, residue: false };
+    }
+
     private async cleanupLocalWorktreeNode(args: {
         mesh: any;
         node: any;
         nodeId: string;
         force?: boolean;
-    }): Promise<{ success: true; skipped?: boolean; removedPath?: string; repoRoot?: string; reason?: string; fallback?: string; forced?: boolean; convergence?: Record<string, unknown> } | { success: false; code: string; error: string; recoveryHint: string; convergence?: Record<string, unknown> }> {
+    }): Promise<{ success: true; skipped?: boolean; removedPath?: string; repoRoot?: string; reason?: string; fallback?: string; forced?: boolean; convergence?: Record<string, unknown>; recovered?: boolean; residue?: boolean; residueWarning?: string; residueError?: string } | { success: false; code: string; error: string; recoveryHint: string; convergence?: Record<string, unknown> }> {
         const workspace = typeof args.node?.workspace === 'string' ? args.node.workspace.trim() : '';
         if (!workspace) {
             return {
@@ -4155,11 +4206,35 @@ export class DaemonCommandRouter {
         const entries = await listWorktrees(repoRoot);
         const managedEntry = entries.find(entry => normalizePath(entry.path) === actualPath);
         if (!managedEntry) {
+            // Idempotent residue recovery (NOT a refusal). By this point the path is
+            // already proven ADHDev-managed: worktreeBranch metadata is present and
+            // actualPath === expectedPath. Git nonetheless no longer lists it as a
+            // worktree. This is the post-force-fallback re-entry state — an earlier
+            // removal de-registered the worktree from git but left the directory
+            // behind (commonly Windows EINVAL on submodule gitlink files). Refusing
+            // here would strand the node in mesh membership forever, so prune any
+            // stale registration, best-effort remove the leftover directory, and
+            // report success so the caller drops the node from the mesh registry.
+            try {
+                const { execFile } = await import('node:child_process');
+                const { promisify } = await import('node:util');
+                const execFileAsync = promisify(execFile);
+                await execFileAsync('git', ['worktree', 'prune'], {
+                    cwd: repoRoot, encoding: 'utf8', timeout: 30_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
+                });
+            } catch { /* prune is best-effort */ }
+            const rm = await this.bestEffortRemoveWorktreeDir(workspace);
             return {
-                success: false,
-                code: 'mesh_worktree_cleanup_not_registered',
-                error: `Refusing to remove '${workspace}' because it is not registered in git worktree list for '${repoRoot}'`,
-                recoveryHint: 'Inspect git worktree list --porcelain from the source repo. If the path was already removed, prune git worktrees before retrying.',
+                success: true,
+                removedPath: workspace,
+                repoRoot,
+                reason: 'worktree_unregistered_residue_recovered',
+                recovered: true,
+                ...(rm.residue ? {
+                    residue: true,
+                    residueWarning: `Worktree was already de-registered from git but the directory could not be fully removed (leftover residue at '${workspace}'): ${rm.error || 'unknown error'}. The node will be dropped from the mesh; remove the directory manually if needed.`,
+                    residueError: rm.error,
+                } : {}),
             };
         }
         if (managedEntry.branch && managedEntry.branch !== args.node.worktreeBranch) {
@@ -4221,29 +4296,31 @@ export class DaemonCommandRouter {
                         convergence: forceFallbackConvergence,
                     };
                 } catch (deinitError: any) {
-                    // Fallback 2: deinit+remove still failed — rmSync + prune
+                    // Fallback 2: deinit+remove still failed — best-effort directory
+                    // removal + prune. The path is already proven managed/converged
+                    // here, and a leftover directory must NOT gate dropping the node
+                    // from the mesh, so absorb Windows EINVAL/EPERM and report success
+                    // with a residue warning instead of failing the whole removal.
+                    const rm = await this.bestEffortRemoveWorktreeDir(workspace);
                     try {
-                        fs.rmSync(workspace, { recursive: true, force: true });
                         await execFileAsync('git', ['worktree', 'prune'], {
                             cwd: repoRoot, encoding: 'utf8', timeout: GIT_TIMEOUT_CLEANUP, maxBuffer: GIT_MAX_BUFFER_CLEANUP, windowsHide: true,
                         });
-                        return {
-                            success: true,
-                            removedPath: workspace,
-                            repoRoot,
-                            fallback: 'fs_rm_worktree_prune' as const,
-                            forced: true,
-                            reason: 'working_trees_containing_submodules' as const,
-                            convergence: forceFallbackConvergence,
-                        };
-                    } catch (rmError: any) {
-                        return {
-                            success: false,
-                            code: 'mesh_worktree_cleanup_failed',
-                            error: `All removal fallbacks exhausted. deinit+remove: ${deinitError?.message || deinitError}; rmSync+prune: ${rmError?.message || rmError}`,
-                            recoveryHint: 'Manually remove the worktree directory and run git worktree prune from the source repo.',
-                        };
-                    }
+                    } catch { /* prune is best-effort */ }
+                    return {
+                        success: true,
+                        removedPath: workspace,
+                        repoRoot,
+                        fallback: 'fs_rm_worktree_prune' as const,
+                        forced: true,
+                        reason: 'working_trees_containing_submodules' as const,
+                        convergence: forceFallbackConvergence,
+                        ...(rm.residue ? {
+                            residue: true,
+                            residueWarning: `Worktree was de-registered from git but the directory could not be fully removed (leftover residue at '${workspace}'): ${rm.error || 'unknown error'}; deinit+remove first failed with: ${deinitError?.message || deinitError}. The node will be dropped from the mesh; remove the directory manually if needed.`,
+                            residueError: rm.error,
+                        } : {}),
+                    };
                 }
             }
 
@@ -6260,14 +6337,17 @@ export class DaemonCommandRouter {
         // Session-scoped commands issued from the dashboard (the controlbar Model/Mode
         // selectors → invoke_provider_script, and modal approval → resolve_action, plus the
         // direct set_mode/change_model/set_thought_level mutations) target a session by
-        // targetSessionId. When that session is a mesh worker hosted on a REMOTE daemon, this
+        // targetSessionId. agent_command (send_chat / clear_history / stop) is included for the
+        // same reason: a command naming a session must reach THAT session, never a different
+        // local one. When that session is a mesh worker hosted on a REMOTE daemon, this
         // coordinator never holds its live instance, so the CommandHandler delegation would
-        // fail with "Live session not found". Forward to the owning worker daemon — the same
-        // daemon that already executes send_chat for that session — so the controlbar acts on
-        // the real worker. _meshDirectDispatch prevents re-forwarding once the call lands on
-        // the owning daemon (it then handles the session locally). A locally-hosted worker (or
-        // any session this coordinator owns) resolves to undefined below and falls through to
-        // normal local handling — no regression.
+        // fail with "Live session not found" — or, for agent_command, findAdapter would have
+        // fuzzy-injected the message into the coordinator's own CLI session (TASKECHO). Forward
+        // to the owning worker daemon — the same daemon that already executes send_chat for that
+        // session — so the command acts on the real worker. _meshDirectDispatch prevents
+        // re-forwarding once the call lands on the owning daemon (it then handles the session
+        // locally). A locally-hosted worker (or any session this coordinator owns) resolves to
+        // undefined below and falls through to normal local handling — no regression.
         if (MESH_FORWARDABLE_SESSION_COMMANDS.has(cmd) && this.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
             const targetSessionId = readStringValue(args?.targetSessionId, args?.sessionId, args?.instanceId);
             if (targetSessionId) {
@@ -8279,6 +8359,14 @@ export class DaemonCommandRouter {
                             return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
                         }
                         const cleanupResult = await this.cleanupLocalWorktreeNode({ mesh, node, nodeId, force: args?.force === true });
+                        // De-gating: membership removal is NOT gated on the worktree
+                        // directory actually being deleted. cleanupLocalWorktreeNode now
+                        // returns success:true (with a residue flag) whenever the path is
+                        // proven managed and the only remaining problem is leftover
+                        // directory bytes (e.g. Windows EINVAL). A success:false here means
+                        // a genuinely-unsafe condition — missing metadata, a non-managed /
+                        // unexpected path, a branch mismatch, a dirty worktree, or an
+                        // unverified force fallback — and those still block removal.
                         if (cleanupResult.success === false) {
                             return {
                                 success: false,
@@ -8335,7 +8423,19 @@ export class DaemonCommandRouter {
                         } catch { /* ledger append is best-effort */ }
                     }
 
-                    return { success: true, removed, ...(sessionCleanup ? { sessionCleanup } : {}), ...(worktreeCleanup ? { worktreeCleanup } : {}) };
+                    // Surface leftover-directory residue at the top level so callers
+                    // see the node was dropped from the mesh even though the worktree
+                    // directory could not be fully removed (best-effort, non-gating).
+                    const residueWarning = worktreeCleanup?.residue === true && typeof worktreeCleanup?.residueWarning === 'string'
+                        ? worktreeCleanup.residueWarning
+                        : undefined;
+                    return {
+                        success: true,
+                        removed,
+                        ...(residueWarning ? { residueWarning } : {}),
+                        ...(sessionCleanup ? { sessionCleanup } : {}),
+                        ...(worktreeCleanup ? { worktreeCleanup } : {}),
+                    };
                 } catch (e: any) {
                     return { success: false, error: e.message };
                 }

package/src/commands/upgrade-helper.ts

@@ -292,13 +292,14 @@ async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
   }
 }
 
-export function stopSessionHostProcesses(appName: string): void {
+export async function stopSessionHostProcesses(appName: string): Promise<void> {
   const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
+  let killedPid: number | null = null;
   try {
     if (fs.existsSync(pidFile)) {
       const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
-        killPid(pid);
+        if (killPid(pid)) killedPid = pid;
       }
     }
   } catch {
@@ -310,6 +311,31 @@ export function stopSessionHostProcesses(appName: string): void {
       // noop
     }
   }
+
+  // The session-host process keeps node-pty's `conpty.node` memory-mapped. On
+  // Windows a mapped native addon stays EXCLUSIVELY locked until the process
+  // fully exits and tears down the mapping — and that teardown lags `taskkill`
+  // by an indeterminate interval. `taskkill` only *requests* termination, so
+  // returning immediately lets the caller run `npm install` while conpty.node
+  // is still locked, which makes npm's copy-to-staging fail with EBUSY (the
+  // intermittent Windows upgrade failure). Wait for the killed process to
+  // actually disappear — like we already do for the parent daemon pid — so the
+  // file handle is released before the install runs. (POSIX can replace an open
+  // file freely, so the wait is harmless there.)
+  if (killedPid !== null) {
+    await waitForPidExit(killedPid, 15000);
+  }
+}
+
+// npm copies the current install's files into a staging dir before swapping in
+// the new version. On Windows that copy of `conpty.node` can still race a
+// just-killed session-host whose mapping hasn't been released yet, surfacing as
+// EBUSY/EPERM. Treat those as transient and retry with backoff.
+function isRetriableInstallLockError(error: any): boolean {
+  const code = error?.code;
+  if (code === 'EBUSY' || code === 'EPERM') return true;
+  const text = `${error?.message || ''} ${error?.stderr || ''}`;
+  return /\bEBUSY\b|\bEPERM\b|resource busy or locked/i.test(text);
 }
 
 function removeDaemonPidFile(): void {
@@ -412,23 +438,40 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
     await waitForPidExit(payload.parentPid, 15000);
   }
 
-  stopSessionHostProcesses(sessionHostAppName);
+  await stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
 
   const spec = `${payload.packageName}@${payload.targetVersion || 'latest'}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync(
-    installCommand.command,
-    installCommand.args,
-    {
-      encoding: 'utf8',
-      stdio: 'pipe',
-      maxBuffer: 20 * 1024 * 1024,
-      env: buildInstallEnvWithNodeOnPath(),
-      ...installCommand.execOptions,
-    },
-  );
+  // Windows can still race a lingering conpty.node mapping even after the
+  // session-host exits, so retry the install on transient lock errors there.
+  const maxInstallAttempts = process.platform === 'win32' ? 3 : 1;
+  let installOutput = '';
+  for (let attempt = 1; attempt <= maxInstallAttempts; attempt++) {
+    try {
+      installOutput = String(execFileSync(
+        installCommand.command,
+        installCommand.args,
+        {
+          encoding: 'utf8',
+          stdio: 'pipe',
+          maxBuffer: 20 * 1024 * 1024,
+          env: buildInstallEnvWithNodeOnPath(),
+          ...installCommand.execOptions,
+        },
+      ));
+      break;
+    } catch (error: any) {
+      if (attempt < maxInstallAttempts && isRetriableInstallLockError(error)) {
+        appendUpgradeLog(`Install attempt ${attempt} hit a file lock (${error?.code || 'lock'}); cleaning staging and retrying after backoff`);
+        cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
+        await new Promise((resolve) => setTimeout(resolve, attempt * 1500));
+        continue;
+      }
+      throw error;
+    }
+  }
   if (installOutput.trim()) {
     appendUpgradeLog(installOutput.trim());
   }

package/src/index.ts

@@ -186,6 +186,11 @@ export {
 } from './config/mesh-config.js';
 export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './config/mesh-config.js';
 
+// ── Mesh shared daemon-id helpers (re-export so external tooling — e.g. the
+//    mcp-server, which depends only on @adhdev/daemon-core — can canonicalize
+//    daemon-id forms without taking a direct @adhdev/mesh-shared dependency). ──
+export { expandDaemonIdForms, daemonIdsEquivalent, machineCoreFromDaemonId } from '@adhdev/mesh-shared';
+
 // ── Mesh Coordinator ──
 export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
 export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';

package/src/logging/command-log.ts

@@ -15,11 +15,13 @@ import * as path from 'path';
 import * as os from 'os';
 
 // ─── Config ──────────────────────────────────
-const LOG_DIR = process.platform === 'win32'
-    ? path.join(process.env.LOCALAPPDATA || process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'adhdev', 'logs')
-    : process.platform === 'darwin'
-        ? path.join(os.homedir(), 'Library', 'Logs', 'adhdev')
-        : path.join(os.homedir(), '.local', 'share', 'adhdev', 'logs');
+// Command history lives under the unified ADHDev home (~/.adhdev/logs/) next to
+// the daemon log, on every platform. Honor ADHDEV_CONFIG_DIR for isolated homes.
+// Keep this in sync with logger.ts LOG_DIR.
+const ADHDEV_HOME = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim()
+    ? process.env.ADHDEV_CONFIG_DIR.trim()
+    : path.join(os.homedir(), '.adhdev');
+const LOG_DIR = path.join(ADHDEV_HOME, 'logs');
 
 const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
 const MAX_DAYS = 7;

package/src/logging/logger.ts

@@ -7,7 +7,7 @@
  * 1. daemonLog(category, msg, level) — explicit per-category logging
  * 2. installGlobalInterceptor() — Auto-intercept console.log (once on daemon start)
  * 3. Recent log ring buffer — for remote transmission via P2P/WS
- * 4. File logging — ~/Library/Logs/adhdev/daemon.log (10MB rolling)
+ * 4. File logging — ~/.adhdev/logs/daemon-YYYY-MM-DD.log (date-based rolling)
  * 
  * use:
  * import { daemonLog, LOG } from './daemon-logger';
@@ -37,11 +37,17 @@ export function setLogLevel(level: LogLevel): void {
 
 export function getLogLevel(): LogLevel { return currentLevel; }
 // ─── File logging (date-based rolling) ──────────────────────────────
-const LOG_DIR = process.platform === 'win32'
-    ? path.join(process.env.LOCALAPPDATA || process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'adhdev', 'logs')
-    : process.platform === 'darwin'
-        ? path.join(os.homedir(), 'Library', 'Logs', 'adhdev')
-        : path.join(os.homedir(), '.local', 'share', 'adhdev', 'logs');
+// Logs live under the unified ADHDev home (~/.adhdev/logs/) on every platform,
+// alongside config.json, providers/, history/, daemon.pid and session-host.log.
+// Earlier builds wrote to OS-specific dirs (~/Library/Logs/adhdev on macOS,
+// ~/.local/share/adhdev/logs on Linux, %LOCALAPPDATA%/adhdev/logs on Windows),
+// which made the daemon log undiscoverable next to everything else under
+// ~/.adhdev and inconsistent with session-host.log. Honor ADHDEV_CONFIG_DIR so
+// isolated/standalone namespaces keep their logs in their own home.
+const ADHDEV_HOME = process.env.ADHDEV_CONFIG_DIR && process.env.ADHDEV_CONFIG_DIR.trim()
+    ? process.env.ADHDEV_CONFIG_DIR.trim()
+    : path.join(os.homedir(), '.adhdev');
+const LOG_DIR = path.join(ADHDEV_HOME, 'logs');
 
 const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB per day
 const MAX_LOG_DAYS = 7; // 7-day retention