@adhdev/daemon-core 0.9.82-rc.262 → 0.9.82-rc.264

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

@@ -83,6 +83,24 @@ export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
     terminalDirectWork: MeshActiveWorkRecord[];
     summary: MeshActiveWorkSummary;
 };
+/**
+ * staleReason strings (produced by sessionStatusFromNodes above) that indicate the original
+ * node/session is GONE from the live mesh — i.e. the staleDirect record is an orphaned ledger
+ * artifact, not active or recoverable work. These are the only reasons safe to prune from the
+ * active staleDirect surface. The "no provider acknowledgement" reason is deliberately excluded:
+ * those entries have a still-live node/session (staleDispatchUnacknowledged) and represent
+ * recoverable dispatch failures, never orphans.
+ */
+export declare const PRUNABLE_ORPHAN_STALE_REASONS: ReadonlySet<string>;
+export type StaleDirectPruneClassification = 'prunable_orphan' | 'prunable_terminal' | 'preserve_unacknowledged' | 'preserve_active';
+/**
+ * Classify a direct-work record for the staleDirect prune path. Pure function — the prune tool
+ * uses this so the safety rules (never touch active work or recoverable unacknowledged dispatches)
+ * live next to the staleReason producers and are independently testable.
+ */
+export declare function classifyStaleDirectForPrune(record: Pick<MeshActiveWorkRecord, 'staleReason' | 'staleDispatchUnacknowledged' | 'terminal'>, opts?: {
+    includeTerminal?: boolean;
+}): StaleDirectPruneClassification;
 export declare function buildCompactStaleDirectWorkSummary(staleDirectWork: MeshActiveWorkRecord[], opts?: {
     sampleLimit?: number;
     detailHint?: string;

package/dist/mesh/mesh-fast-forward.d.ts

@@ -10,19 +10,50 @@ export interface MeshFastForwardNodeArgs {
     submoduleIgnorePaths?: string[];
     timeoutMs?: number;
     trigger?: 'manual' | 'idle_auto' | string;
+    /**
+     * Operation mode. 'merge' (default) absorbs upstream commits into the local
+     * branch via git merge --ff-only (requires ahead=0, behind>0). 'push' publishes
+     * local commits to origin via a strict ff-only push (requires HEAD to be a
+     * descendant of origin/<branch>); it never force-pushes, resets, or rebases.
+     */
+    mode?: 'merge' | 'push';
+    /**
+     * When mode='push', also fast-forward push submodule (e.g. oss) HEADs to their
+     * origin main branch. Gated by allowAutoPublishSubmoduleMainCommits — skipped
+     * unless that policy is true. Each submodule must still pass the descendant gate.
+     * Defaults false (root push only).
+     */
+    pushSubmodules?: boolean;
+    /**
+     * Mesh policy flag mirrored from RepoMeshPolicy.allowAutoPublishSubmoduleMainCommits.
+     * Submodule pushes are refused unless this is true.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
 }
 export interface MeshFastForwardPlannedStep {
-    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status';
+    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status' | 'verify_push_descendant' | 'push_ff_only' | 'push_submodules_ff_only';
     description: string;
     safe: true;
     willMutateWorktree: boolean;
 }
+export interface MeshFastForwardSubmodulePushResult {
+    path: string;
+    commit?: string;
+    remote: string;
+    remoteBranch: string;
+    pushed: boolean;
+    skipped: boolean;
+    code: string;
+    refspec?: string;
+    error?: string;
+}
 export interface MeshFastForwardResult {
     success: boolean;
     code: string;
     nodeId?: string;
     meshId?: string;
     workspace: string;
+    mode: 'merge' | 'push';
     allowed: boolean;
     dryRun: boolean;
     willRun: boolean;
@@ -33,9 +64,18 @@ export interface MeshFastForwardResult {
     current?: GitRepoStatus;
     preStatus?: GitRepoStatus;
     postStatus?: GitRepoStatus;
+    /** Push target derived from the tracked upstream (mode='push'). */
+    pushTarget?: {
+        remote: string;
+        remoteBranch: string;
+        refspec: string;
+    };
+    /** Submodule ff-only push outcomes (mode='push' with pushSubmodules). */
+    submodulePushes?: MeshFastForwardSubmodulePushResult[];
     finalBranchConvergenceState?: Record<string, unknown>;
     operationError?: string;
     ledgerError?: string;
+    nextStep?: string;
     trigger?: string;
 }
 export declare function fastForwardMeshNode(args: MeshFastForwardNodeArgs): Promise<MeshFastForwardResult>;

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';
+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';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

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

@@ -72,6 +72,12 @@ export declare class MeshRuntimeStore {
     updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
     cleanupTerminalDirectDispatches(olderThanMs: number): void;
     deleteDirectDispatches(meshId: string): void;
+    /**
+     * Delete specific direct dispatch rows by taskId for a mesh. Used by the staleDirect prune
+     * path to remove orphaned/terminal dispatch records whose node/session is no longer in the
+     * live mesh. Returns the number of rows actually deleted. No-op for an empty taskId list.
+     */
+    deleteDirectDispatchesByTaskId(meshId: string, taskIds: string[]): number;
     markStaleDirectDispatches(meshId: string, olderThanMs: number): void;
     setRemoteIdleSession(nodeId: string, sessionId: string, providerType: string, expiresAt: number, metadata?: any): void;
     getRemoteIdleSessions(): Array<{

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

@@ -243,6 +243,12 @@ export declare function getActiveDirectDispatches(meshId: string): DirectDispatc
 export declare function updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
 export declare function cleanupTerminalDirectDispatches(olderThanMs?: number): void;
 export declare function markStaleDirectDispatches(meshId: string, olderThanMs?: number): void;
+/**
+ * Delete specific direct dispatch rows by taskId. Returns the number of rows deleted.
+ * Used by the staleDirect prune path to evict orphaned/terminal dispatch records from the
+ * active staleDirect surface while leaving the append-only mesh ledger (audit history) intact.
+ */
+export declare function deleteDirectDispatchesByTaskId(meshId: string, taskIds: string[]): number;
 export type MeshToolCallRateResult = {
     rateLimitExceeded: boolean;
     callsInWindow: number;

package/package.json

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

package/src/build-info.ts

@@ -0,0 +1,73 @@
+/**
+ * Daemon build stamp — single runtime source for "which commit is this running
+ * daemon built from?".
+ *
+ * The values are injected at BUILD time via tsup `define` (esbuild global
+ * replacement). Every build config that bundles daemon-core into a shippable
+ * daemon (daemon-core's own dist, daemon-standalone, daemon-cloud) replaces
+ * these `__DAEMON_BUILD_*` identifiers with the literal git commit/version that
+ * was current when the bundle was produced. See:
+ *   - oss/packages/daemon-core/tsup.config.ts      (standalone consumes this dist)
+ *   - packages/daemon-cloud/tsup.config.ts         (re-bundles daemon-core from source)
+ *
+ * If a bundle is produced WITHOUT the define (e.g. running src directly through
+ * tsx in dev, or a build env without git), the identifiers stay undefined and
+ * we fall back to `"unknown"` — never a ReferenceError, never a build failure.
+ *
+ * IMPORTANT (live-reflection caveat): a fresh local `daemon-core dist` rebuild +
+ * daemon restart is NOT enough to make a *cloud* daemon report a new commit —
+ * daemon-cloud ships its own re-bundle of daemon-core, so the build stamp only
+ * advances after the cloud daemon is rebuilt/redeployed and restarted. This is
+ * precisely the gap `mesh_status`'s `staleDaemonBuild` warning exists to surface.
+ */
+
+// These are replaced at build time by tsup `define`. `typeof` guards keep this
+// safe when the define is absent (the identifiers are simply not declared).
+declare const __DAEMON_BUILD_COMMIT__: string | undefined;
+declare const __DAEMON_BUILD_COMMIT_SHORT__: string | undefined;
+declare const __DAEMON_BUILD_VERSION__: string | undefined;
+declare const __DAEMON_BUILD_AT__: string | undefined;
+
+export interface DaemonBuildInfo {
+    /** Full 40-char git commit the daemon bundle was built from, or 'unknown'. */
+    commit: string;
+    /** Short (7-char) form of the same commit, or 'unknown'. */
+    commitShort: string;
+    /** package.json version baked in at build time, or 'unknown'. */
+    version: string;
+    /** ISO build timestamp if the build config injected one. */
+    builtAt?: string;
+}
+
+function readInjected(value: string | undefined): string | undefined {
+    if (typeof value !== 'string') return undefined;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === 'unknown') return undefined;
+    return trimmed;
+}
+
+let cached: DaemonBuildInfo | undefined;
+
+/**
+ * Resolve the build stamp baked into the running daemon bundle. Pure read of
+ * build-time constants — no I/O, safe to call from any runtime path. Cached.
+ */
+export function getDaemonBuildInfo(): DaemonBuildInfo {
+    if (cached) return cached;
+
+    const commit =
+        readInjected(typeof __DAEMON_BUILD_COMMIT__ !== 'undefined' ? __DAEMON_BUILD_COMMIT__ : undefined)
+        ?? 'unknown';
+    const commitShort =
+        readInjected(typeof __DAEMON_BUILD_COMMIT_SHORT__ !== 'undefined' ? __DAEMON_BUILD_COMMIT_SHORT__ : undefined)
+        ?? (commit !== 'unknown' ? commit.slice(0, 7) : 'unknown');
+    const version =
+        readInjected(typeof __DAEMON_BUILD_VERSION__ !== 'undefined' ? __DAEMON_BUILD_VERSION__ : undefined)
+        // Fall back to the runtime-injected package version env used elsewhere.
+        ?? readInjected(typeof process !== 'undefined' ? process.env?.ADHDEV_PKG_VERSION : undefined)
+        ?? 'unknown';
+    const builtAt = readInjected(typeof __DAEMON_BUILD_AT__ !== 'undefined' ? __DAEMON_BUILD_AT__ : undefined);
+
+    cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
+    return cached;
+}

package/src/commands/router.ts

@@ -64,6 +64,7 @@ import {
     type WorktreeBootstrapState,
 } from '../mesh/worktree-bootstrap-config.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
+import { getDaemonBuildInfo } from '../build-info.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import { getMeshQueueRevision } from '../mesh/mesh-work-queue.js';
@@ -3521,6 +3522,8 @@ export class DaemonCommandRouter {
         const skippedSessionIds: string[] = [];
         const skippedLiveSessionIds: string[] = [];
         const skippedCoordinatorSessionIds: string[] = [];
+        const skippedLiveSessionReasons: Array<{ sessionId: string; reason: string }> = [];
+        const actedLiveDelegateSessionIds: string[] = [];
         const deleteUnsupportedSessionIds: string[] = [];
         const recordsRemainSessionIds: string[] = [];
         const errors: Array<{ sessionId: string; error: string }> = [];
@@ -3556,16 +3559,49 @@ export class DaemonCommandRouter {
             const surfaceKind = getSessionHostSurfaceKind(record);
             const liveRuntime = surfaceKind === 'live_runtime';
             const coordinatorSession = readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId;
+            // A delegate session was launched by the coordinator specifically FOR this node
+            // (meta.meshNodeId === this node). It is 1:1 bound to the node, even when the node
+            // shares its daemon runtime with the main/other nodes. Removing the node should be
+            // able to stop its own delegate session — the shared-daemon concern only applies to
+            // sessions we matched by workspace alone (which could belong to the coordinator or to
+            // a sibling node that is still active).
+            const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+            const recordMeshNodeFor = readStringValue(record?.meta?.meshNodeFor);
+            const delegateBoundToThisNode = !!recordNodeId
+                && recordNodeId === args.nodeId
+                && (!recordMeshNodeFor || recordMeshNodeFor === args.meshId);
             if (!hasExplicitSessionIds && coordinatorSession) {
                 skippedSessionIds.push(sessionId);
                 skippedCoordinatorSessionIds.push(sessionId);
                 continue;
             }
-            if (!hasExplicitSessionIds && liveRuntime) {
+            // Only the conservative shared-daemon guard for live sessions that are NOT a delegate
+            // explicitly bound to this node. Delegate-bound live sessions fall through and are
+            // stopped/deleted by the mode handlers below (which already record an intentional stop).
+            if (!hasExplicitSessionIds && liveRuntime && !delegateBoundToThisNode) {
                 skippedSessionIds.push(sessionId);
                 skippedLiveSessionIds.push(sessionId);
+                const matchedByWorkspaceOnly = !recordNodeId;
+                const reason = recordNodeId && recordNodeId !== args.nodeId
+                    ? `live_delegate_bound_to_other_node:${recordNodeId}`
+                    : matchedByWorkspaceOnly
+                        ? 'live_session_matched_by_workspace_only_no_node_binding'
+                        : 'live_session_not_bound_to_this_node';
+                skippedLiveSessionReasons.push({ sessionId, reason });
                 continue;
             }
+            if (!hasExplicitSessionIds && liveRuntime && delegateBoundToThisNode && args.mode === 'delete_stopped') {
+                // delete_stopped never stops live runtimes by contract — even bound delegates.
+                // Surface a clear reason instead of an unexplained skip so callers know to use
+                // stop / stop_and_delete to release a still-running bound delegate.
+                skippedSessionIds.push(sessionId);
+                skippedLiveSessionIds.push(sessionId);
+                skippedLiveSessionReasons.push({ sessionId, reason: 'live_delegate_preserved_by_delete_stopped_mode_use_stop_or_stop_and_delete' });
+                continue;
+            }
+            if (!hasExplicitSessionIds && liveRuntime && delegateBoundToThisNode) {
+                actedLiveDelegateSessionIds.push(sessionId);
+            }
             try {
                 if (args.mode === 'stop') {
                     if (!completed) {
@@ -3631,6 +3667,8 @@ export class DaemonCommandRouter {
             skippedSessionIds,
             skippedLiveSessionIds,
             skippedCoordinatorSessionIds,
+            ...(actedLiveDelegateSessionIds.length ? { actedLiveDelegateSessionIds } : {}),
+            ...(skippedLiveSessionReasons.length ? { skippedLiveSessionReasons } : {}),
             ...(deleteUnsupported ? {
                 deleteUnsupported: true,
                 effectiveCleanup: args.mode === 'stop_and_delete'
@@ -4489,10 +4527,46 @@ export class DaemonCommandRouter {
             }
 
             const cleanupStarted = Date.now();
+            // Honor the mesh policy for delegated-session cleanup on the auto-removed
+            // worktree node (previously hardcoded to 'preserve', which orphaned the
+            // delegate session as an idle record on the coordinator daemon). Fall back
+            // to 'preserve' when no policy is set.
+            const refineSessionCleanupMode = this.normalizeMeshSessionCleanupMode(
+                mesh?.policy?.sessionCleanupOnNodeRemove,
+            );
+            // The delegate session launched for a clone worktree is frequently matched
+            // by workspace ONLY (no meta.meshNodeId binding), which remove_mesh_node's
+            // shared-daemon guard skips. Since refine knows exactly which workspace it
+            // just merged, collect that workspace's live session ids explicitly and pass
+            // them through — explicit sessionIds bypass the workspace-only-match guard so
+            // the policy-driven stop/delete actually runs.
+            let refineSessionIds: string[] | undefined;
+            if (refineSessionCleanupMode !== 'preserve' && this.deps.sessionHostControl) {
+                try {
+                    const liveSessions = await this.deps.sessionHostControl.listSessions();
+                    const workspace = typeof node.workspace === 'string' ? node.workspace : '';
+                    refineSessionIds = liveSessions
+                        .filter((record: any) => {
+                            const sid = typeof record?.sessionId === 'string' ? record.sessionId : '';
+                            if (!sid) return false;
+                            // Never sweep the coordinator's own session for this mesh.
+                            if (readStringValue(record?.meta?.meshCoordinatorFor) === meshId) return false;
+                            const boundToNode = readStringValue(record?.meta?.meshNodeId) === nodeId;
+                            const matchedByWorkspace = !!workspace && record?.workspace === workspace;
+                            return boundToNode || matchedByWorkspace;
+                        })
+                        .map((record: any) => String(record.sessionId));
+                } catch {
+                    // listSessions failure is non-fatal — fall back to the policy-mode
+                    // cleanup without explicit ids (still better than hardcoded preserve).
+                    refineSessionIds = undefined;
+                }
+            }
             const removeResult = await this.execute('remove_mesh_node', {
                 meshId,
                 nodeId,
-                sessionCleanupMode: 'preserve',
+                sessionCleanupMode: refineSessionCleanupMode,
+                ...(refineSessionIds && refineSessionIds.length > 0 ? { sessionIds: refineSessionIds } : {}),
                 inlineMesh: args?.inlineMesh,
             });
             recordMeshRefineStage(refineStages, 'cleanup', removeResult?.success === false ? 'failed' : 'passed', cleanupStarted, {
@@ -5783,7 +5857,11 @@ export class DaemonCommandRouter {
                     version: this.deps.statusVersion || 'unknown',
                     profile: 'metadata',
                 });
-                return { success: true, status: snapshot };
+                // Surface the daemon's build stamp so coordinators (mesh_status)
+                // can detect a running daemon that predates a just-merged fix and
+                // is awaiting deploy/restart. Sibling of `status` to avoid
+                // perturbing the dashboard status snapshot shape.
+                return { success: true, status: snapshot, daemonBuild: getDaemonBuildInfo() };
             }
 
             case 'get_machine_runtime_stats': {
@@ -6886,6 +6964,7 @@ export class DaemonCommandRouter {
                     ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
                     : undefined;
                 let nodeDaemonId: string | undefined;
+                let allowAutoPublishSubmoduleMainCommits = false;
                 if (meshId && nodeId) {
                     // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
                     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
@@ -6897,6 +6976,7 @@ export class DaemonCommandRouter {
                     if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
                         submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
                     }
+                    allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
                     nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
                 }
                 // If the target node belongs to a remote daemon, forward the command there.
@@ -6921,6 +7001,9 @@ export class DaemonCommandRouter {
                     dryRun: args?.dryRun === true,
                     updateSubmodules: args?.updateSubmodules === true,
                     submoduleIgnorePaths,
+                    mode: args?.mode === 'push' ? 'push' : 'merge',
+                    pushSubmodules: args?.pushSubmodules === true,
+                    allowAutoPublishSubmoduleMainCommits,
                 }) as Promise<unknown>);
                 return result as CommandRouterResult;
             }
@@ -6929,6 +7012,29 @@ export class DaemonCommandRouter {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
                 if (!meshId || !nodeId) return { success: false, error: 'meshId and nodeId required' };
+                // Dry-run (plan-only) is the default and stays synchronous: it does no
+                // validation/merge/push and returns the plan instantly. Only execute=true
+                // (and not dry_run) goes through the async refine job that actually
+                // validates → merges → pushes → cleans up. Mirrors the
+                // batch_refine_mesh_nodes / fast_forward_mesh_node dry_run/execute contract.
+                const isDryRun = args?.dryRun !== false && args?.execute !== true;
+                if (isDryRun) {
+                    // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
+                    const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+                    const mesh = meshRecord?.mesh;
+                    const node = mesh?.nodes?.find((n: any) => n.id === nodeId || n.nodeId === nodeId);
+                    if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+                    return {
+                        success: true,
+                        dryRun: true,
+                        nodeId,
+                        workspace: node.workspace,
+                        validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+                        mergeWillRun: false,
+                        cleanupWillRun: false,
+                        hint: 'Dry-run only — no merge/push/cleanup performed. Re-invoke with execute:true to converge this node.',
+                    };
+                }
                 return this.startMeshRefineJob(meshId, nodeId, args);
             }
 
@@ -6961,9 +7067,22 @@ export class DaemonCommandRouter {
                     const sessionCleanupMode = this.normalizeMeshSessionCleanupMode(
                         args?.sessionCleanupMode ?? args?.session_cleanup_mode ?? mesh?.policy?.sessionCleanupOnNodeRemove,
                     );
+                    // Explicit sessionIds (e.g. supplied by refine auto-cleanup) bypass the
+                    // workspace-only-match guard so a delegate session that lacks a
+                    // meta.meshNodeId binding can still be stopped/deleted.
+                    const explicitSessionIds = Array.isArray(args?.sessionIds)
+                        ? (args.sessionIds as unknown[]).filter((v): v is string => typeof v === 'string' && v.trim().length > 0).map(v => v.trim())
+                        : undefined;
                     let sessionCleanup: Record<string, unknown> | undefined;
                     if (node && sessionCleanupMode !== 'preserve') {
-                        sessionCleanup = await this.cleanupMeshSessions({ meshId, nodeId, node, mode: sessionCleanupMode, source: 'mesh_remove_node' });
+                        sessionCleanup = await this.cleanupMeshSessions({
+                            meshId,
+                            nodeId,
+                            node,
+                            mode: sessionCleanupMode,
+                            ...(explicitSessionIds && explicitSessionIds.length > 0 ? { sessionIds: explicitSessionIds } : {}),
+                            source: 'mesh_remove_node',
+                        });
                         if (sessionCleanup.success === false) return { success: false, removed: false, sessionCleanup };
                     }
 

package/src/git/git-status.ts

@@ -1,5 +1,6 @@
-import type { GitRepoStatus, GitSubmoduleStatus, GitUpstreamFreshness } from './git-types.js';
+import type { DaemonBuildBehind, GitRepoStatus, GitSubmoduleStatus, GitUpstreamFreshness } from './git-types.js';
 import { GitCommandError, resolveGitRepository, runGit } from './git-executor.js';
+import { getDaemonBuildInfo, type DaemonBuildInfo } from '../build-info.js';
 
 type ResolvedGitRepo = { workspace: string; repoRoot: string | null; isGitRepo: boolean };
 
@@ -14,6 +15,12 @@ export interface GitStatusOptions {
    * Callers should opt into this only for convergence-critical surfaces.
    */
   refreshUpstream?: boolean;
+  /**
+   * Test/override seam for the daemon build stamp used by the stale-build
+   * detector. Production callers omit this so the real baked-in build commit
+   * (getDaemonBuildInfo) is used.
+   */
+  daemonBuildInfo?: DaemonBuildInfo;
 }
 
 interface GitUpstreamProbe {
@@ -54,6 +61,8 @@ export async function getGitRepoStatus(
       || stashCount > 0
       || submoduleDirty;
 
+    const daemonBuildBehind = await detectDaemonBuildBehind(repo, submodules, options);
+
     return {
       workspace: repo.workspace,
       repoRoot: repo.repoRoot,
@@ -78,6 +87,7 @@ export async function getGitRepoStatus(
       stashCount,
       lastCheckedAt,
       submodules,
+      ...(daemonBuildBehind ? { daemonBuildBehind } : {}),
     };
   } catch (error) {
     if (error instanceof GitCommandError) {
@@ -91,6 +101,158 @@ export async function getGitRepoStatus(
   }
 }
 
+/**
+ * Detect whether the running daemon's build commit is a STRICT ancestor of this
+ * workspace's HEAD (root) or any of its submodules' HEAD. This surfaces the
+ * "merged a fix to main but the live daemon still ships the old bundle" gap:
+ * once the fix is committed, the workspace HEAD advances past the daemon's
+ * baked-in build commit, but the daemon keeps the old behavior until it is
+ * rebuilt/redeployed and restarted.
+ *
+ * Conservative by construction — returns undefined unless ancestry is provable:
+ *   - build commit unknown → undefined
+ *   - build commit not an object in this repo/submodule (different repo) → skip
+ *   - build commit === HEAD (daemon is current) → undefined
+ *   - build commit NOT an ancestor of HEAD (daemon ahead / diverged) → undefined
+ * Any git error is swallowed (no warning) so a flaky probe never over-warns.
+ */
+/**
+ * Package names that, when changed, mean the daemon runtime is stale and must be
+ * rebuilt/redeployed + restarted. Everything NOT in this set (web-core,
+ * web-standalone, web-devconsole, terminal-render-web) is web-only — a daemon
+ * restart is not required for those, only a web redeploy. mcp-server runs in the
+ * same process surface as the daemon tooling, so it is classified as
+ * daemon-affecting (conservative). Unknown package → daemon-affecting.
+ */
+const DAEMON_RUNTIME_PACKAGES = new Set([
+  'daemon-core',
+  'daemon-standalone',
+  'session-host-core',
+  'session-host-daemon',
+  'terminal-mux-core',
+  'terminal-mux-control',
+  'terminal-mux-cli',
+  'ghostty-vt-node',
+  'mcp-server',
+]);
+
+const WEB_ONLY_PACKAGES = new Set([
+  'web-core',
+  'web-standalone',
+  'web-devconsole',
+  'terminal-render-web',
+]);
+
+/**
+ * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
+ * package. Returns isDaemonAffecting:true conservatively when the changed-file set
+ * can't be obtained or any changed path is outside the known web-only package set
+ * (including root-level / non-package files).
+ */
+async function classifyDaemonBuildChange(
+  repoPath: string,
+  buildCommit: string,
+  options: GitStatusOptions,
+): Promise<{ isDaemonAffecting: boolean; affectedPackages: string[] }> {
+  try {
+    const diff = await runGit(repoPath, ['diff', '--name-only', `${buildCommit}..HEAD`], options);
+    const files = diff.stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    if (files.length === 0) {
+      // No file diff (e.g. only merge metadata) — nothing actionable, but stay
+      // conservative and treat as daemon-affecting so we don't suppress a real warning.
+      return { isDaemonAffecting: true, affectedPackages: [] };
+    }
+    const pkgs = new Set<string>();
+    let sawNonPackageOrUnknown = false;
+    for (const file of files) {
+      const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
+      if (!match) {
+        sawNonPackageOrUnknown = true;
+        continue;
+      }
+      pkgs.add(match[1]);
+    }
+    const affectedPackages = [...pkgs].sort();
+    // Daemon-affecting if: any non-package/root file changed, any unknown package
+    // changed, or any explicit daemon-runtime package changed. Only when EVERY
+    // changed file maps to a known web-only package is the daemon unaffected.
+    const allWebOnly =
+      !sawNonPackageOrUnknown &&
+      affectedPackages.length > 0 &&
+      affectedPackages.every((p) => WEB_ONLY_PACKAGES.has(p) && !DAEMON_RUNTIME_PACKAGES.has(p));
+    return { isDaemonAffecting: !allWebOnly, affectedPackages };
+  } catch {
+    // diff probe failed → can't prove web-only; stay conservative.
+    return { isDaemonAffecting: true, affectedPackages: [] };
+  }
+}
+
+async function detectDaemonBuildBehind(
+  repo: ResolvedGitRepo,
+  submodules: GitSubmoduleStatus[] | undefined,
+  options: GitStatusOptions,
+): Promise<DaemonBuildBehind | undefined> {
+  const build = options.daemonBuildInfo ?? getDaemonBuildInfo();
+  if (!build.commit || build.commit === 'unknown') return undefined;
+
+  // Check the root repo first, then each submodule. The daemon build commit is
+  // baked from the daemon-core (oss submodule) HEAD, so on an adhdev
+  // superproject worktree the match is expected on the `oss` submodule, not the
+  // root — checking both keeps the helper repo-agnostic.
+  const scopes: Array<{ scope: string; repoPath: string }> = [
+    { scope: 'root', repoPath: repo.repoRoot || repo.workspace },
+  ];
+  for (const sub of submodules || []) {
+    if (sub.repoPath && !sub.error) scopes.push({ scope: sub.path, repoPath: sub.repoPath });
+  }
+
+  for (const { scope, repoPath } of scopes) {
+    try {
+      // Build commit must be a real object in THIS repo, else it's a different repo.
+      await runGit(repoPath, ['cat-file', '-e', `${build.commit}^{commit}`], options);
+      const headResult = await runGit(repoPath, ['rev-parse', 'HEAD'], options);
+      const head = headResult.stdout.trim();
+      if (!head || head === build.commit) continue;
+      // Strict ancestor: build commit is reachable from HEAD but is not HEAD.
+      await runGit(repoPath, ['merge-base', '--is-ancestor', build.commit, 'HEAD'], options);
+      // No throw → build commit IS an ancestor of HEAD → daemon is behind.
+      // Inspect WHICH packages changed in buildCommit..HEAD. A daemon rebuild/restart
+      // is only actually required when a daemon-runtime package changed; if only web /
+      // render packages changed, the daemon is unaffected and just the web deploy is
+      // pending. Conservative: any probe failure → treat as daemon-affecting.
+      const { isDaemonAffecting, affectedPackages } = await classifyDaemonBuildChange(
+        repoPath,
+        build.commit,
+        options,
+      );
+      const scopeLabel = scope === 'root' ? 'workspace' : scope;
+      const warning = isDaemonAffecting
+        ? `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}. ` +
+          `Merged code is NOT live until the daemon is rebuilt/redeployed and restarted — a local dist rebuild alone does not update a cloud daemon.`
+        : `Live daemon was built from ${build.commitShort} which is behind ${scopeLabel} HEAD ${head.slice(0, 7)}, ` +
+          `but only web packages changed (${(affectedPackages || []).join(', ') || 'web'}). ` +
+          `Daemon restart NOT required — redeploy the web app to reflect the change.`;
+      return {
+        buildCommit: build.commit,
+        buildCommitShort: build.commitShort,
+        head,
+        scope,
+        isDaemonAffecting,
+        ...(affectedPackages && affectedPackages.length > 0 ? { affectedPackages } : {}),
+        warning,
+      };
+    } catch {
+      // cat-file / merge-base non-zero exit (commit absent or not an ancestor)
+      // or any git error → not a provable staleness for this scope; try next.
+      continue;
+    }
+  }
+  return undefined;
+}
+
 interface ParsedPorcelainStatus {
   branch: string | null;
   upstream: string | null;