@adhdev/daemon-core 1.0.18-rc.20 → 1.0.18-rc.3

package/src/commands/med-family/mesh-queue.ts

@@ -9,67 +9,6 @@
  */
 import { readStringValue } from '../router.js';
 import type { MedFamilyContext, MedFamilyHandler } from './types.js';
-import { LOG } from '../../logging/logger.js';
-import type { CancelledTaskAssignment } from '../../mesh/mesh-work-queue.js';
-
-/**
- * CANCEL-STICKY-TERMINAL (authoritative cancel): stop the worker a just-cancelled task was
- * bound to. Mirrors the transport-aware stop mesh-event-forwarding's stopStaleMeshWorker
- * performs for reclaimed workers, but runs from the command layer using ctx.deps (which the
- * pure queue-store module lacks): local adapter → stop_cli directly; otherwise resolve the
- * worker node's daemon id from mesh config and dispatch stop_cli over P2P/relay. Fully
- * best-effort — a failed stop only loses the belt-and-suspenders; the cancelled row is already
- * terminal and cannot be resurrected (updateTaskStatus terminal guard).
- */
-async function stopCancelledTaskWorker(
-    ctx: MedFamilyContext,
-    meshId: string,
-    prior: CancelledTaskAssignment,
-): Promise<void> {
-    const { sessionId, nodeId, providerType } = prior;
-    const stopArgs: Record<string, unknown> = {
-        targetSessionId: sessionId,
-        ...(providerType ? { cliType: providerType } : {}),
-        mode: 'hard',
-        reason: 'mesh_task_cancelled',
-    };
-    try {
-        const cliManager = ctx.deps.cliManager as any;
-        const isLocal = cliManager?.adapters?.has?.(sessionId) === true;
-        if (isLocal) {
-            if (!stopArgs.cliType) {
-                const localType = cliManager?.adapters?.get?.(sessionId)?.cliType;
-                if (localType) stopArgs.cliType = localType;
-            }
-            await Promise.resolve(cliManager?.handleCliCommand?.('stop_cli', stopArgs))
-                .catch((e: any) => LOG.warn('MeshQueue', `Local stop of cancelled worker ${sessionId} failed: ${e?.message || e}`));
-            return;
-        }
-        // Remote: resolve the worker node's daemon id from mesh config, then dispatch stop_cli.
-        const dispatch = ctx.deps.dispatchMeshCommand;
-        let daemonId: string | undefined;
-        if (nodeId) {
-            try {
-                const [{ getMesh }, { meshNodeIdMatches }, { readMeshNodeDaemonId }] = await Promise.all([
-                    import('../../config/mesh-config.js'),
-                    import('@adhdev/mesh-shared'),
-                    import('../../mesh/mesh-node-identity.js'),
-                ]);
-                const mesh = getMesh(meshId) as { nodes?: any[] } | undefined;
-                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
-                daemonId = node ? readMeshNodeDaemonId(node) || undefined : undefined;
-            } catch { /* best-effort resolution */ }
-        }
-        if (daemonId && dispatch) {
-            await Promise.resolve(dispatch(daemonId, 'stop_cli', stopArgs))
-                .catch((e: any) => LOG.warn('MeshQueue', `Remote stop of cancelled worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
-        } else {
-            LOG.warn('MeshQueue', `Cannot stop cancelled worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${nodeId ?? '?'}). Row is already terminal; if the worker completes it strand-fails harmlessly.`);
-        }
-    } catch (e: any) {
-        LOG.warn('MeshQueue', `stopCancelledTaskWorker error for ${sessionId}: ${e?.message || e}`);
-    }
-}
 
 export const meshQueueHandlers: Record<string, MedFamilyHandler> = {
     get_mesh_queue: async (_ctx: MedFamilyContext, args: any) => {
@@ -111,22 +50,10 @@ export const meshQueueHandlers: Record<string, MedFamilyHandler> = {
         const ownerFailure = await ctx.requireMeshHostMutationOwner(meshId, args?.inlineMesh, 'queue cancellation');
         if (ownerFailure) return ownerFailure;
         try {
-            const { cancelTask, takeCancelledTaskAssignment } = await import('../../mesh/mesh-work-queue.js');
+            const { cancelTask } = await import('../../mesh/mesh-work-queue.js');
             const reason = typeof args?.reason === 'string' ? args.reason : undefined;
             const task = cancelTask(meshId, taskId, { reason });
             if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
-            // CANCEL-STICKY-TERMINAL (authoritative cancel): stop the worker that was bound to the
-            // now-cancelled task. cancelTask already cleared the queue's assignment fields (so the
-            // reclaim watchdog no longer sees it as a live assignment), but a still-running worker
-            // keeps emitting delivery/turn signals that re-ignite reclaim. cancelTask runs in the
-            // pure queue-store module (no DaemonComponents), so the transport-aware stop is done
-            // here where ctx.deps holds cliManager / dispatchMeshCommand. Best-effort: a failed
-            // stop only loses the belt-and-suspenders — the row is already terminal and un-revivable
-            // thanks to the updateTaskStatus terminal guard.
-            const prior = takeCancelledTaskAssignment(meshId, taskId);
-            if (prior?.sessionId) {
-                void stopCancelledTaskWorker(ctx, meshId, prior);
-            }
             return { success: true, task };
         } catch (e: any) {
             return { success: false, error: e.message };

package/src/commands/router-refine.ts

@@ -36,10 +36,8 @@ import {
     RefineExecFileAsync,
     RefineStageOutcome,
     classifyPatchEquivalenceFailure,
-    convergeDivergedSubmoduleGitlinks,
     recordMeshRefineStage,
     resolveRefineryAutoPublishSubmoduleMainCommits,
-    rootRebaseResolvingGitlinks,
     runMeshRefineEffectiveDiffGate,
     runMeshRefinePatchEquivalenceGate,
     runMeshRefineSubmoduleReachabilityGate,
@@ -541,9 +539,6 @@ async function computeBranchBaseDivergence(
 export async function refineSyncBaseStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome> {
             const { repoRoot, baseHead, node, branch, baseBranch, refineStages, execFileAsync } = ctx;
             let branchHead = ctx.branchHead;
-            // Converged submodule gitlink resolutions (path → rebased commit) from STEP 1;
-            // consumed by the gitlink-aware root rebase (STEP 2) to resolve gitlink conflicts.
-            let gitlinkResolutions: Array<{ path: string; rebasedCommit: string }> = [];
             const syncStarted = Date.now();
             const divergence = await computeBranchBaseDivergence(execFileAsync, node.workspace, baseHead, branchHead);
 
@@ -576,87 +571,25 @@ export async function refineSyncBaseStage(self: DaemonCommandRouter, ctx: Refine
                 const preRebasePe = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
                 const alreadyMerged = !preRebasePe.actualPatchId && !!preRebasePe.expectedPatchId;
                 const submoduleConflict = preRebasePe.actionableHint?.kind === 'submodule_conflict';
-                if (alreadyMerged) {
+                if (alreadyMerged || submoduleConflict) {
                     recordMeshRefineStage(refineStages, 'sync_base', 'passed', syncStarted, {
                         ahead: divergence.ahead,
                         behind: divergence.behind,
                         rebased: false,
-                        reason: 'already_merged_via_other_path_skip_rebase',
+                        reason: alreadyMerged ? 'already_merged_via_other_path_skip_rebase' : 'submodule_conflict_defer_to_patch_equivalence',
                     });
                     return { kind: 'continue', ctx };
                 }
-                if (submoduleConflict) {
-                    // DS3: a "submodule conflict" here means base and branch advanced the
-                    // SAME submodule to DIVERGED sibling commits (neither an ancestor of the
-                    // other), so the gitlink stays in the diff and patch-equivalence fails.
-                    // Attempt to auto-converge it (STEP 1): rebase the branch-side submodule
-                    // commit onto the base-side commit INSIDE the worktree submodule, so the
-                    // base-side commit becomes a strict ancestor of the rebased tip. The root
-                    // rebase below (STEP 2) then resolves the gitlink conflict to that rebased
-                    // commit. Together this automates the documented manual strict-ff bypass
-                    // and keeps the landed oss history linear. On any real submodule content
-                    // conflict it backs out cleanly → we FALL BACK to the historical
-                    // defer→patch_equivalence path below.
-                    const converge = convergeDivergedSubmoduleGitlinks(node.workspace, repoRoot, baseHead, branchHead);
-                    if (converge.converged) {
-                        gitlinkResolutions = converge.resolutions;
-                        recordMeshRefineStage(refineStages, 'submodule_gitlink_converge', 'passed', syncStarted, {
-                            reason: 'submodule_diverged_auto_rebased',
-                            gitlinks: converge.gitlinks,
-                        });
-                        LOG.info('Mesh', `[Refinery] Auto-converged diverged submodule gitlink(s) onto base for node ${node.id}: `
-                            + converge.resolutions.map(r => `${r.path}→${r.rebasedCommit.slice(0, 12)}`).join(', '));
-                        // Fall through (do NOT return) → the gitlink-aware root rebase below runs.
-                    } else {
-                        // Fail-safe: convergence declined (conflict / unreachable / not a real
-                        // divergence) → preserve the historical defer→blocked_review behavior.
-                        recordMeshRefineStage(refineStages, 'submodule_gitlink_converge', 'skipped', syncStarted, {
-                            reason: 'submodule_conflict_defer_to_patch_equivalence',
-                            convergeReason: converge.reason,
-                            gitlinks: converge.gitlinks,
-                        });
-                        recordMeshRefineStage(refineStages, 'sync_base', 'passed', syncStarted, {
-                            ahead: divergence.ahead,
-                            behind: divergence.behind,
-                            rebased: false,
-                            reason: 'submodule_conflict_defer_to_patch_equivalence',
-                        });
-                        return { kind: 'continue', ctx };
-                    }
-                }
             } catch { /* fail-open: on gate error, fall through to the rebase */ }
 
             // behind>0: strictly-behind OR diverged. Rebase the branch onto the pinned
             // baseHead. A conflict aborts and terminates blocked_review (retryable=false —
             // a real content conflict needs human resolution, not a base-movement retry).
-            //
-            // When STEP 1 converged a diverged submodule gitlink, use the gitlink-aware
-            // root rebase (STEP 2): git's recursive merge refuses to auto-merge the still-
-            // diverged intermediate gitlink, so we drive the rebase and resolve each
-            // submodule-gitlink conflict to the converged commit. A non-gitlink conflict
-            // aborts and falls through to the same blocked_review handling as a plain
-            // rebase conflict below (via the thrown gitlinkRebaseError).
             const rebaseStarted = Date.now();
             try {
-                if (gitlinkResolutions.length > 0) {
-                    const gitlinkRebase = rootRebaseResolvingGitlinks(node.workspace, baseHead, gitlinkResolutions);
-                    if (!gitlinkRebase.ok) {
-                        // Surface as a rebase failure so the shared blocked_review handling
-                        // (submodule-hint recovery included) runs — nothing was left mid-rebase
-                        // (rootRebaseResolvingGitlinks aborts on failure).
-                        const err: any = new Error(`gitlink-aware rebase aborted: ${gitlinkRebase.reason || 'unknown'}`);
-                        err.gitlinkRebaseReason = gitlinkRebase.reason;
-                        err.gitlinkRebaseConflicts = gitlinkRebase.conflictPaths;
-                        err.alreadyAborted = true;
-                        throw err;
-                    }
-                } else {
-                    execFileSync('git', ['rebase', baseHead], { cwd: node.workspace, stdio: ['ignore', 'pipe', 'pipe'] });
-                }
+                execFileSync('git', ['rebase', baseHead], { cwd: node.workspace, stdio: ['ignore', 'pipe', 'pipe'] });
             } catch (rebaseErr: any) {
-                if (!rebaseErr?.alreadyAborted) {
-                    try { execFileSync('git', ['rebase', '--abort'], { cwd: node.workspace, stdio: 'ignore' }); } catch { /* ignore */ }
-                }
+                try { execFileSync('git', ['rebase', '--abort'], { cwd: node.workspace, stdio: 'ignore' }); } catch { /* ignore */ }
                 // A rebase conflict on a submodule/gitlink divergence is a SPECIAL case the
                 // patch-equivalence gate describes with a rich actionable hint (which
                 // submodule, base vs branch commit, how to resolve). Run that gate against

package/src/commands/router.ts

@@ -227,14 +227,6 @@ const MESH_FORWARDABLE_SESSION_COMMANDS = new Set([
     // MUTATES the worker PTY, so forwarding to the real owner (not a wrong local session) is
     // doubly important. The daemon re-enforces the destructive-key confirm gate after the forward.
     'send_keys',
-    // interactive_prompt_response (mesh_answer_question, mission f1d25e11): the coordinator
-    // answers a REMOTE worker's AskUserQuestion (waiting_choice). The answer must reach the
-    // OWNING worker session's live instance — its activeInteractivePrompt (the authoritative
-    // prompt the labels/indexes resolve against) and its adapter.setInteractivePromptResponse
-    // live only there. Without forwarding, the coordinator's local high-family handler returns
-    // 'No running instance for session …' and the question is never answered — the exact
-    // remote-worker forwarding gap of mission 6938892f, now closed for questions too.
-    'interactive_prompt_response',
 ]);
 
 function normalizeCommandSource(source: string): CommandLogEntry['source'] {

package/src/commands/upgrade-helper.ts

@@ -144,68 +144,19 @@ function resolveInstallPrefixFromPackageRoot(packageRoot: string, packageName: s
   return maybeLibDir;
 }
 
-// True when `prefix` is the bin dir of a portable Node 22 the installer manages
-// under ~/.adhdev/tools/node22/<node-vX>/. A `npm i -g adhdev` run while that
-// portable node is the active `node` installs adhdev into node's own default
-// global prefix (= that dir) — a "legacy node22-prefix" install that lives at
-// the FRONT of PATH (Enable-NodePath prepends node22) and shadows the canonical
-// dispatcher shims in ~/.adhdev/npm-global. Because self-upgrade reuses the
-// running prefix, that install then re-installs into the same node22 dir forever
-// and never converts to the dispatcher. Detecting it lets us force convergence.
-function isPortableNode22Prefix(prefix: string | null, homeDir: string): boolean {
-  if (!prefix) return false;
-  const portableRoot = path.join(homeDir, '.adhdev', 'tools', 'node22');
-  const normalizedPrefix = path.resolve(prefix).replace(/[\\/]+$/, '').toLowerCase();
-  const normalizedRoot = path.resolve(portableRoot).replace(/[\\/]+$/, '').toLowerCase();
-  return normalizedPrefix === normalizedRoot || normalizedPrefix.startsWith(`${normalizedRoot}${path.sep.toLowerCase()}`);
-}
-
-// Redirect a legacy node22-prefix install to the canonical dispatcher install
-// root so resolveWindowsInstallerLayout accepts it and the atomic-upgrade
-// publishes the ~/.adhdev/npm-global pointer + shims. Prefer the version the
-// dispatcher pointer already names (so we sit on the real active dispatcher
-// prefix); otherwise synthesize a stable migration sentinel under npm-installs.
-// resolveWindowsInstallerLayout only requires a `npm-installs/version-*` path —
-// performWindowsAtomicUpgrade stages a fresh version- prefix of its own and uses
-// this only as the "old prefix" to stop/clean, so a non-existent path is a no-op.
-function canonicalDispatcherInstallPrefix(homeDir: string): string {
-  const installRoot = path.join(homeDir, '.adhdev', 'npm-installs');
-  const pointerPath = path.join(homeDir, '.adhdev', 'npm-global', '.adhdev-current');
-  try {
-    const activeVersion = fs.readFileSync(pointerPath, 'utf8').trim();
-    if (activeVersion.startsWith('version-')) return path.join(installRoot, activeVersion);
-  } catch {
-    // No dispatcher pointer yet (first migration off the legacy layout).
-  }
-  return path.join(installRoot, 'version-legacy-migrate');
-}
-
 export function resolveCurrentGlobalInstallSurface(options: {
   packageName: string;
   currentCliPath?: string;
   nodeExecutable?: string;
   platform?: NodeJS.Platform;
-  homeDir?: string;
 }): CurrentGlobalInstallSurface {
   const packageRoot = findCurrentPackageRoot(options.currentCliPath || process.argv[1], options.packageName);
   const npmInvocation = resolveSiblingNpmInvocation(options.nodeExecutable || process.execPath, options.platform);
-  const platform = options.platform || process.platform;
-  const homeDir = options.homeDir || os.homedir();
-  let installPrefix = packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null;
-  // FIX C: on Windows, never let a self-upgrade perpetuate the legacy
-  // node22-prefix install. If the running adhdev lives under ~/.adhdev/tools/
-  // node22, force the install onto the canonical dispatcher prefix so the update
-  // converges to the ~/.adhdev/npm-global pointer + shims. Scoped to win32 AND a
-  // tools/node22 prefix so npm-linked dev / standalone / real dispatcher installs
-  // are untouched.
-  if (platform === 'win32' && isPortableNode22Prefix(installPrefix, homeDir)) {
-    installPrefix = canonicalDispatcherInstallPrefix(homeDir);
-  }
   return {
     npmExecutable: npmInvocation.executable,
     npmArgsPrefix: npmInvocation.argsPrefix,
     packageRoot,
-    installPrefix,
+    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null,
     execOptions: npmInvocation.execOptions,
   };
 }
@@ -609,36 +560,22 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       );
     }
 
-    try {
-      await performWindowsAtomicUpgrade({
-        layout: windowsInstallerLayout,
+    await performWindowsAtomicUpgrade({
+      layout: windowsInstallerLayout,
+      packageName: payload.packageName,
+      targetVersion: payload.targetVersion,
+      portableNode,
+      excludePids: upgradePids,
+      hooks: createDefaultWindowsAtomicHooks({
         packageName: payload.packageName,
         targetVersion: payload.targetVersion,
-        portableNode,
-        excludePids: upgradePids,
-        hooks: createDefaultWindowsAtomicHooks({
-          packageName: payload.packageName,
-          targetVersion: payload.targetVersion,
-          npmCliPath,
-          restartArgv,
-          cwd: payload.cwd || process.cwd(),
-          env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== UPGRADE_HELPER_ENV)),
-          log: appendUpgradeLog,
-        }),
-      });
-    } catch (error: any) {
-      // performWindowsAtomicUpgrade already rolled the pointer/shims back to the
-      // prior version before rethrowing. Without a durable notice that rollback
-      // was silent — the daemon simply kept running the old version (the rc.6
-      // stuck-upgrade defect). Leave an actionable last-error file naming the
-      // target that failed its health/version gate.
-      emitUpgradeFailureNotice([
-        `adhdev ${payload.packageName}@${payload.targetVersion} upgrade failed and was rolled back: ${error?.message || String(error)}`,
-        `Previous version preserved (active prefix: ${windowsInstallerLayout.activePrefix}).`,
-        'See daemon-upgrade.log for the full install/health trace. The next daemon start will retry.',
-      ]);
-      throw error;
-    }
+        npmCliPath,
+        restartArgv,
+        cwd: payload.cwd || process.cwd(),
+        env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== UPGRADE_HELPER_ENV)),
+        log: appendUpgradeLog,
+      }),
+    });
     try { fs.unlinkSync(getUpgradeFailureNoticePath()); } catch { /* no previous failure notice */ }
     appendUpgradeLog('Installer-managed Windows atomic upgrade completed');
     return;