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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.263",
+  "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/commands/router.ts

@@ -4527,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, {
@@ -6976,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);
             }
 
@@ -7008,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

@@ -116,6 +116,80 @@ export async function getGitRepoStatus(
  *   - 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,
@@ -145,14 +219,30 @@ async function detectDaemonBuildBehind(
       // 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,
-        warning:
-          `Live daemon was built from ${build.commitShort} which is behind ${scope === 'root' ? 'workspace' : scope} 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.`,
+        isDaemonAffecting,
+        ...(affectedPackages && affectedPackages.length > 0 ? { affectedPackages } : {}),
+        warning,
       };
     } catch {
       // cat-file / merge-base non-zero exit (commit absent or not an ancestor)

package/src/git/git-types.ts

@@ -89,6 +89,16 @@ export interface DaemonBuildBehind {
   head: string;
   /** Where the comparison matched: 'root' or the submodule path. */
   scope: string;
+  /**
+   * Whether any package changed between buildCommit..HEAD affects the daemon
+   * runtime (daemon-core, standalone, session-host, terminal-mux, ghostty,
+   * mcp-server). When false, only web/render packages changed — the daemon does
+   * NOT need a rebuild/restart; only the web deploy is pending. Conservative:
+   * when the changed-package set can't be determined it defaults to true.
+   */
+  isDaemonAffecting: boolean;
+  /** Distinct package names changed between buildCommit..HEAD (best-effort). */
+  affectedPackages?: string[];
   warning: string;
 }