@adhdev/daemon-core 0.9.82-rc.454 → 0.9.82-rc.456

package/dist/commands/router-refine.d.ts

@@ -0,0 +1,137 @@
+import type { DaemonCommandRouter, CommandRouterResult } from './router.js';
+import { MeshRefineAsyncJobStatus, MeshRefineBatchJobHandle, MeshRefineBatchJobStatus, MeshRefineJobHandle, RefineContext, RefineStageOutcome } from '../mesh/mesh-refine-gates.js';
+export declare function buildRefineJobKey(self: DaemonCommandRouter, meshId: string, nodeId: string): string;
+export declare function buildRefineJobHandle(self: DaemonCommandRouter, args: {
+    meshId: string;
+    nodeId: string;
+    node?: any;
+    status?: MeshRefineAsyncJobStatus;
+    startedAt?: string;
+    completedAt?: string;
+    jobId?: string;
+    interactionId?: string;
+    retryOfJobId?: string;
+    coordinatorDaemonId?: string;
+}): MeshRefineJobHandle;
+export declare function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void;
+export declare function appendRefineJobLedger(self: DaemonCommandRouter, kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): Promise<void>;
+/**
+ * On daemon restart, scan all mesh ledgers for refine jobs that were dispatched
+ * but never completed/failed (i.e. the daemon died mid-job).  Re-queue each one
+ * so the job runs to completion automatically without coordinator intervention.
+ */
+export declare function resumePendingRefineJobsOnStartup(self: DaemonCommandRouter): Promise<void>;
+/**
+ * Synchronous refinery for a single worktree node — the gate pipeline that
+ * validates, preflights (patch-equivalence / submodule-reachability /
+ * no-op), merges, aligns submodules, cleans up the worktree node and
+ * (optionally) pushes. The body is a flat sequence of stage methods; each
+ * stage either returns a terminal CommandRouterResult (gate failure or a
+ * successful already-merged short-circuit) or `continue` with the extended
+ * context. Behavior — stage order, every early-exit, and every result shape —
+ * is identical to the previous single inlined body.
+ */
+export declare function executeMeshRefineNodeSynchronously(self: DaemonCommandRouter, meshId: string, nodeId: string, args: any): Promise<CommandRouterResult>;
+/**
+ * resolve_refs stage: resolve the mesh / worktree node / source node /
+ * repoRoot, then the worktree branch, base branch, fetched base head and
+ * branch head. Seeds the RefineContext consumed by every later stage.
+ */
+export declare function refineResolveRefsStage(self: DaemonCommandRouter, meshId: string, nodeId: string, args: any, refineStages: Array<Record<string, unknown>>): Promise<RefineStageOutcome>;
+/**
+ * validation stage: run the refinery validation gate (typecheck / test /
+ * lint / build per node config) and block on failure or when no allowlisted
+ * command was available. On pass, stores the summary on the context.
+ */
+export declare function refineValidationStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * patch_equivalence stage: preflight that the worktree branch's cumulative
+ * patch is equivalent to base+branch. On a "behind base" branch, auto-rebase
+ * once and re-check; on an empty merge-tree with real branch changes, treat as
+ * already-merged-via-another-path and short-circuit to cleanup. Mutates the
+ * context's branchHead (after rebase) and patchEquivalence (rebased gate).
+ */
+export declare function refinePatchEquivalenceStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * submodule_reachability stage: verify every submodule gitlink commit that
+ * would land via the merge is reachable from its configured remote main
+ * branch (optionally auto-publishing when policy allows). Blocks the merge
+ * when any commit is unreachable. Stores the result on the context.
+ */
+export declare function refineSubmoduleReachabilityStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * effective_diff stage (no-op guard): block a silent no-op merge where the
+ * branch produces no effective root-tree diff against base — typically a
+ * submodule that has commits but whose root-level gitlink (pointer) bump was
+ * never committed, so the merge would land nothing real on main.
+ */
+export declare function refineEffectiveDiffStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * merge + finalize stage: perform the --no-ff merge, align submodule
+ * checkouts after merge, clean up (remove) the worktree node per policy,
+ * append the refinery ledger entry, and (unless approval is required) push the
+ * base branch. Always terminal — produces the final CommandRouterResult.
+ */
+export declare function refineMergeAndFinalizeStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * Batch refinery: converge multiple sibling worktree nodes onto the base branch
+ * in one sequential pipeline, absorbing the rebase + patch-equivalence churn that
+ * arises when several siblings touch the same submodule.
+ *
+ * Reuses executeMeshRefineNodeSynchronously per node — every node goes through the
+ * exact same validation / patch-equivalence / submodule-reachability / merge / cleanup
+ * gates, including its built-in auto-rebase onto fresh origin/<base>. Because each
+ * node fetches origin/<base> at the start of its own refine, a node merged earlier in
+ * the batch advances the base, and the next node's refine auto-rebases onto it before
+ * re-running patch-equivalence. No force-push, no reset — conflicting nodes are
+ * isolated as blocked_review while the rest of the batch proceeds.
+ */
+export declare function batchRefineMeshNodes(self: DaemonCommandRouter, meshId: string, requestedNodeIds: string[] | undefined, args: any): Promise<CommandRouterResult>;
+/**
+ * Convergence core shared by the synchronous batch entry and the async batch job.
+ * Refines each node in order: the per-node refine pipeline fetches origin/<base>
+ * fresh, so each merged sibling advances the base before the next node's auto-rebase
+ * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
+ * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
+ * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
+ */
+export declare function runMeshRefineBatchConvergence(self: DaemonCommandRouter, meshId: string, orderedNodes: any[], ordering: {
+    order: string[];
+    rationale?: unknown;
+}, args: any): Promise<CommandRouterResult>;
+export declare function buildRefineBatchJobKey(self: DaemonCommandRouter, meshId: string): string;
+export declare function buildRefineBatchJobHandle(self: DaemonCommandRouter, args: {
+    meshId: string;
+    nodeIds: string[];
+    order: string[];
+    status?: MeshRefineBatchJobStatus;
+    startedAt?: string;
+    completedAt?: string;
+    jobId?: string;
+    interactionId?: string;
+    coordinatorDaemonId?: string;
+}): MeshRefineBatchJobHandle;
+/**
+ * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
+ * forward mechanism single-node refine uses (queueRefineJobEvent), so the
+ * coordinator's existing refine:accepted/completed/failed handling and message
+ * renderer apply unchanged. The aggregate per-node results ride along in `result`.
+ */
+export declare function queueRefineBatchJobEvent(self: DaemonCommandRouter, event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineBatchJobHandle, result?: Record<string, unknown>): void;
+export declare function appendRefineBatchJobLedger(self: DaemonCommandRouter, kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineBatchJobHandle, result?: Record<string, unknown>): Promise<void>;
+export declare function finishMeshRefineBatchJob(self: DaemonCommandRouter, handle: MeshRefineBatchJobHandle, orderedNodes: any[], ordering: {
+    order: string[];
+    rationale?: unknown;
+}, args: any): Promise<void>;
+/**
+ * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
+ * resolves the plan synchronously (so target/ordering errors and the dry-run shape
+ * stay synchronous), then for execute=true registers an in-flight batch job, returns
+ * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
+ * convergence loop in the background — emitting the same terminal refine event.
+ * Idempotent: a batch already in flight for this mesh returns the running handle
+ * with duplicate:true rather than spawning a second background job.
+ */
+export declare function startMeshRefineBatchJob(self: DaemonCommandRouter, meshId: string, requestedNodeIds: string[] | undefined, args: any): Promise<CommandRouterResult>;
+export declare function finishMeshRefineJob(self: DaemonCommandRouter, handle: MeshRefineJobHandle, args: any): Promise<void>;
+export declare function startMeshRefineJob(self: DaemonCommandRouter, meshId: string, nodeId: string, args: any): Promise<CommandRouterResult>;

package/dist/commands/router-worktree-cleanup.d.ts

@@ -0,0 +1,133 @@
+import type { DaemonCommandRouter } from './router.js';
+import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+export declare function sessionMatchesMeshNode(self: DaemonCommandRouter, record: any, node: any, nodeId: string, sessionIds?: Set<string>): boolean;
+/**
+ * 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.
+ */
+export declare function bestEffortRemoveWorktreeDir(self: DaemonCommandRouter, dir: string): Promise<{
+    removed: boolean;
+    residue: boolean;
+    error?: string;
+}>;
+/**
+ * Non-destructive precheck mirroring every REFUSAL condition in
+ * {@link cleanupLocalWorktreeNode} — missing workspace / source-repo / branch
+ * metadata, unexpected (non-managed) path, branch mismatch — PLUS the
+ * dirty-worktree guard that `removeWorktree(requireClean)` enforces
+ * (`git status --porcelain`). It performs ZERO destructive actions: no
+ * `git worktree remove`, no `git worktree prune`, no directory deletion.
+ *
+ * remove_mesh_node calls this BEFORE any session cleanup so that a refusal
+ * (the common one being a dirty worktree) does not first stop/delete the
+ * delegated session and orphan it — the original ordering bug. Success/skip
+ * cases that the real cleanup handles idempotently (worktree path already
+ * gone, git-de-registered residue) are NOT refusals and return `{ ok: true }`.
+ *
+ * `force:true` skips the dirty guard, preserving `removeWorktree`'s
+ * `requireClean: !force` semantics. This is a read-only superset check; the
+ * authoritative `requireClean` guard inside `removeWorktree` is intentionally
+ * kept as a second line of defense against a precheck→execute race.
+ */
+export declare function precheckLocalWorktreeRemovable(self: DaemonCommandRouter, args: {
+    mesh: any;
+    node: any;
+    nodeId: string;
+    force?: boolean;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    code: string;
+    error: string;
+    recoveryHint: string;
+}>;
+export declare function cleanupLocalWorktreeNode(self: DaemonCommandRouter, 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>;
+    recovered?: boolean;
+    residue?: boolean;
+    residueWarning?: string;
+    residueError?: string;
+    branchRefDeleted?: boolean;
+    branchRefReason?: string;
+    branchRefForced?: boolean;
+    branchRefWarning?: string;
+} | {
+    success: false;
+    code: string;
+    error: string;
+    recoveryHint: string;
+    convergence?: Record<string, unknown>;
+}>;
+export declare function getWorktreeForceCleanupConvergence(self: DaemonCommandRouter, args: {
+    repoRoot: string;
+    workspace: string;
+    node: any;
+}): Promise<{
+    allow: boolean;
+    status?: string;
+    source?: string;
+    ref?: string;
+    error?: string;
+}>;
+export declare function isCompletedHostedSession(self: DaemonCommandRouter, record: any): boolean;
+export declare function recordIntentionalMeshSessionStop(self: DaemonCommandRouter, args: {
+    meshId: string;
+    nodeId: string;
+    node: any;
+    sessionId: string;
+    mode: RepoMeshSessionCleanupMode;
+    source: 'mesh_cleanup_sessions' | 'mesh_remove_node' | 'magi_session_cleanup';
+    action: 'stop_session' | 'delete_session_force';
+}): Promise<void>;
+export declare function cleanupMeshSessions(self: DaemonCommandRouter, args: {
+    meshId: string;
+    nodeId: string;
+    node: any;
+    mode: RepoMeshSessionCleanupMode;
+    sessionIds?: string[];
+    dryRun?: boolean;
+    source?: 'mesh_cleanup_sessions' | 'mesh_remove_node' | 'magi_session_cleanup';
+    /**
+     * MAGI auto-cleanup safety gate: a map of sessionId → the queue task id that
+     * session must have been AUTO-LAUNCHED for (record meta autoLaunchedForQueueTaskId).
+     * When set, a matched explicit session is only acted on if its record carries that
+     * exact marker. A reused idle session (no marker), the coordinator session, a
+     * re-assigned session, or any session whose marker points at a DIFFERENT task is
+     * skipped (reason 'auto_launch_marker_mismatch') — so MAGI never kills a session it
+     * didn't itself spawn for this fan-out. Only consulted alongside explicit sessionIds.
+     */
+    requireAutoLaunchedForTaskIds?: Record<string, string>;
+    /**
+     * Opt-in orphan reclaim (default false). See SESSION-ACCUMULATION-LEAK.
+     * When true, a workspace-only live_runtime session (no node binding) OR a
+     * live_runtime session bound to a node absent from `liveMeshNodeIds` is
+     * stopped instead of skipped by the conservative shared-daemon guard. A
+     * session whose meshNodeId is STILL in `liveMeshNodeIds` (active sibling)
+     * is never reclaimed — that is the shared-daemon safety this preserves.
+     */
+    reclaimOrphans?: boolean;
+    liveMeshNodeIds?: string[];
+}): Promise<{
+    success: boolean;
+    [key: string]: unknown;
+}>;

package/dist/commands/router.d.ts

@@ -14,6 +14,8 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
+import type { RepoMeshSessionCleanupMode } from '../repo-mesh-types.js';
+import { MeshRefineBatchJobHandle, MeshRefineBatchTerminalJob, MeshRefineJobHandle, MeshRefineTerminalJob } from '../mesh/mesh-refine-gates.js';
 export * from '../mesh/mesh-node-identity.js';
 export * from '../mesh/mesh-refine-gates.js';
 export * from '../mesh/mesh-coordinator-config.js';
@@ -96,7 +98,8 @@ export interface CommandRouterResult {
 export declare function normalizeStandaloneHostCommandUrl(hostAddress: string): string;
 export declare function buildMemberJoinNode(mesh: any, args: any, fallbackDaemonId?: string): Record<string, unknown> | null;
 export declare class DaemonCommandRouter {
-    private deps;
+    /** Public (not private) so the extracted ./router-refine.ts orchestration can reach it via `self`. */
+    deps: CommandRouterDeps;
     /** In-memory cache for cloud-originating meshes passed via inlineMesh.
      *  Allows the MCP server to query mesh data via get_mesh even when
      *  the mesh doesn't exist in the local meshes.json file. */
@@ -120,14 +123,15 @@ export declare class DaemonCommandRouter {
      *  flight — so a burst of interactive detail-opens serves the cached snapshot
      *  and coalesces onto ONE background refresh instead of storming the peers. */
     private swrRefreshInFlight;
-    /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
-    private runningRefineJobs;
+    /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests.
+     *  Public (not private) so the extracted ./router-refine.ts orchestration can reach it via `self`. */
+    runningRefineJobs: Map<string, MeshRefineJobHandle>;
     /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
-    private terminalRefineJobs;
+    terminalRefineJobs: Map<string, MeshRefineTerminalJob>;
     /** In-memory async batch Refinery jobs keyed by meshId (one batch convergence per mesh at a time). */
-    private runningRefineBatchJobs;
+    runningRefineBatchJobs: Map<string, MeshRefineBatchJobHandle>;
     /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
-    private terminalRefineBatchJobs;
+    terminalRefineBatchJobs: Map<string, MeshRefineBatchTerminalJob>;
     constructor(deps: CommandRouterDeps);
     private cloneJsonValue;
     private hydrateCachedAggregateMeshStatusFromInline;
@@ -181,8 +185,14 @@ export declare class DaemonCommandRouter {
     private collectMeshSessionOwnerCandidateNodes;
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
     private warmInlineMeshCache;
-    private getMeshForCommand;
-    private invalidateAggregateMeshStatus;
+    getMeshForCommand(meshId: string, inlineMesh?: unknown, options?: {
+        preferInline?: boolean;
+    }): Promise<{
+        mesh: any;
+        inline: boolean;
+        source: 'inline_cache' | 'inline_bootstrap' | 'local_config';
+    } | null>;
+    invalidateAggregateMeshStatus(meshId: string): void;
     /**
      * Build the MedFamilyContext handed to RF-ROUTER MED family handlers. Binds the
      * router-private collaborators those handlers need (mesh resolution, owner
@@ -238,45 +248,91 @@ export declare class DaemonCommandRouter {
      *  workspace is still absent from disk; if the workspace is back (genuine
      *  re-registration), the tombstone is cleared and the node merges normally. */
     private applyInlineMeshNodeTombstones;
-    private normalizeMeshSessionCleanupMode;
-    private sessionMatchesMeshNode;
-    /**
-     * 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 bestEffortRemoveWorktreeDir;
-    /**
-     * Non-destructive precheck mirroring every REFUSAL condition in
-     * {@link cleanupLocalWorktreeNode} — missing workspace / source-repo / branch
-     * metadata, unexpected (non-managed) path, branch mismatch — PLUS the
-     * dirty-worktree guard that `removeWorktree(requireClean)` enforces
-     * (`git status --porcelain`). It performs ZERO destructive actions: no
-     * `git worktree remove`, no `git worktree prune`, no directory deletion.
-     *
-     * remove_mesh_node calls this BEFORE any session cleanup so that a refusal
-     * (the common one being a dirty worktree) does not first stop/delete the
-     * delegated session and orphan it — the original ordering bug. Success/skip
-     * cases that the real cleanup handles idempotently (worktree path already
-     * gone, git-de-registered residue) are NOT refusals and return `{ ok: true }`.
-     *
-     * `force:true` skips the dirty guard, preserving `removeWorktree`'s
-     * `requireClean: !force` semantics. This is a read-only superset check; the
-     * authoritative `requireClean` guard inside `removeWorktree` is intentionally
-     * kept as a second line of defense against a precheck→execute race.
-     */
-    private precheckLocalWorktreeRemovable;
-    private cleanupLocalWorktreeNode;
-    private getWorktreeForceCleanupConvergence;
-    private isCompletedHostedSession;
-    private recordIntentionalMeshSessionStop;
-    private cleanupMeshSessions;
+    normalizeMeshSessionCleanupMode(value: unknown): RepoMeshSessionCleanupMode;
+    sessionMatchesMeshNode(record: any, node: any, nodeId: string, sessionIds?: Set<string>): boolean;
+    bestEffortRemoveWorktreeDir(dir: string): Promise<{
+        removed: boolean;
+        residue: boolean;
+        error?: string;
+    }>;
+    precheckLocalWorktreeRemovable(args: {
+        mesh: any;
+        node: any;
+        nodeId: string;
+        force?: boolean;
+    }): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        code: string;
+        error: string;
+        recoveryHint: string;
+    }>;
+    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>;
+        recovered?: boolean;
+        residue?: boolean;
+        residueWarning?: string;
+        residueError?: string;
+        branchRefDeleted?: boolean;
+        branchRefReason?: string;
+        branchRefForced?: boolean;
+        branchRefWarning?: string;
+    } | {
+        success: false;
+        code: string;
+        error: string;
+        recoveryHint: string;
+        convergence?: Record<string, unknown>;
+    }>;
+    getWorktreeForceCleanupConvergence(args: {
+        repoRoot: string;
+        workspace: string;
+        node: any;
+    }): Promise<{
+        allow: boolean;
+        status?: string;
+        source?: string;
+        ref?: string;
+        error?: string;
+    }>;
+    isCompletedHostedSession(record: any): boolean;
+    recordIntentionalMeshSessionStop(args: {
+        meshId: string;
+        nodeId: string;
+        node: any;
+        sessionId: string;
+        mode: RepoMeshSessionCleanupMode;
+        source: 'mesh_cleanup_sessions' | 'mesh_remove_node' | 'magi_session_cleanup';
+        action: 'stop_session' | 'delete_session_force';
+    }): Promise<void>;
+    cleanupMeshSessions(args: {
+        meshId: string;
+        nodeId: string;
+        node: any;
+        mode: RepoMeshSessionCleanupMode;
+        sessionIds?: string[];
+        dryRun?: boolean;
+        source?: 'mesh_cleanup_sessions' | 'mesh_remove_node' | 'magi_session_cleanup';
+        requireAutoLaunchedForTaskIds?: Record<string, string>;
+        reclaimOrphans?: boolean;
+        liveMeshNodeIds?: string[];
+    }): Promise<{
+        success: boolean;
+        [key: string]: unknown;
+    }>;
     /**
      * Unified command routing.
      * Returns result for all commands:
@@ -289,113 +345,9 @@ export declare class DaemonCommandRouter {
      * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
      */
     execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
-    private buildRefineJobKey;
-    private buildRefineJobHandle;
-    private queueRefineJobEvent;
-    private appendRefineJobLedger;
-    /**
-     * On daemon restart, scan all mesh ledgers for refine jobs that were dispatched
-     * but never completed/failed (i.e. the daemon died mid-job).  Re-queue each one
-     * so the job runs to completion automatically without coordinator intervention.
-     */
     resumePendingRefineJobsOnStartup(): Promise<void>;
-    /**
-     * Synchronous refinery for a single worktree node — the gate pipeline that
-     * validates, preflights (patch-equivalence / submodule-reachability /
-     * no-op), merges, aligns submodules, cleans up the worktree node and
-     * (optionally) pushes. The body is a flat sequence of stage methods; each
-     * stage either returns a terminal CommandRouterResult (gate failure or a
-     * successful already-merged short-circuit) or `continue` with the extended
-     * context. Behavior — stage order, every early-exit, and every result shape —
-     * is identical to the previous single inlined body.
-     */
-    private executeMeshRefineNodeSynchronously;
-    /**
-     * resolve_refs stage: resolve the mesh / worktree node / source node /
-     * repoRoot, then the worktree branch, base branch, fetched base head and
-     * branch head. Seeds the RefineContext consumed by every later stage.
-     */
-    private refineResolveRefsStage;
-    /**
-     * validation stage: run the refinery validation gate (typecheck / test /
-     * lint / build per node config) and block on failure or when no allowlisted
-     * command was available. On pass, stores the summary on the context.
-     */
-    private refineValidationStage;
-    /**
-     * patch_equivalence stage: preflight that the worktree branch's cumulative
-     * patch is equivalent to base+branch. On a "behind base" branch, auto-rebase
-     * once and re-check; on an empty merge-tree with real branch changes, treat as
-     * already-merged-via-another-path and short-circuit to cleanup. Mutates the
-     * context's branchHead (after rebase) and patchEquivalence (rebased gate).
-     */
-    private refinePatchEquivalenceStage;
-    /**
-     * submodule_reachability stage: verify every submodule gitlink commit that
-     * would land via the merge is reachable from its configured remote main
-     * branch (optionally auto-publishing when policy allows). Blocks the merge
-     * when any commit is unreachable. Stores the result on the context.
-     */
-    private refineSubmoduleReachabilityStage;
-    /**
-     * effective_diff stage (no-op guard): block a silent no-op merge where the
-     * branch produces no effective root-tree diff against base — typically a
-     * submodule that has commits but whose root-level gitlink (pointer) bump was
-     * never committed, so the merge would land nothing real on main.
-     */
-    private refineEffectiveDiffStage;
-    /**
-     * merge + finalize stage: perform the --no-ff merge, align submodule
-     * checkouts after merge, clean up (remove) the worktree node per policy,
-     * append the refinery ledger entry, and (unless approval is required) push the
-     * base branch. Always terminal — produces the final CommandRouterResult.
-     */
-    private refineMergeAndFinalizeStage;
-    /**
-     * Batch refinery: converge multiple sibling worktree nodes onto the base branch
-     * in one sequential pipeline, absorbing the rebase + patch-equivalence churn that
-     * arises when several siblings touch the same submodule.
-     *
-     * Reuses executeMeshRefineNodeSynchronously per node — every node goes through the
-     * exact same validation / patch-equivalence / submodule-reachability / merge / cleanup
-     * gates, including its built-in auto-rebase onto fresh origin/<base>. Because each
-     * node fetches origin/<base> at the start of its own refine, a node merged earlier in
-     * the batch advances the base, and the next node's refine auto-rebases onto it before
-     * re-running patch-equivalence. No force-push, no reset — conflicting nodes are
-     * isolated as blocked_review while the rest of the batch proceeds.
-     */
     private batchRefineMeshNodes;
-    /**
-     * Convergence core shared by the synchronous batch entry and the async batch job.
-     * Refines each node in order: the per-node refine pipeline fetches origin/<base>
-     * fresh, so each merged sibling advances the base before the next node's auto-rebase
-     * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
-     * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
-     * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
-     */
-    private runMeshRefineBatchConvergence;
-    private buildRefineBatchJobKey;
-    private buildRefineBatchJobHandle;
-    /**
-     * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
-     * forward mechanism single-node refine uses (queueRefineJobEvent), so the
-     * coordinator's existing refine:accepted/completed/failed handling and message
-     * renderer apply unchanged. The aggregate per-node results ride along in `result`.
-     */
-    private queueRefineBatchJobEvent;
-    private appendRefineBatchJobLedger;
-    private finishMeshRefineBatchJob;
-    /**
-     * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
-     * resolves the plan synchronously (so target/ordering errors and the dry-run shape
-     * stay synchronous), then for execute=true registers an in-flight batch job, returns
-     * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
-     * convergence loop in the background — emitting the same terminal refine event.
-     * Idempotent: a batch already in flight for this mesh returns the running handle
-     * with duplicate:true rather than spawning a second background job.
-     */
     private startMeshRefineBatchJob;
-    private finishMeshRefineJob;
     private startMeshRefineJob;
     /**
      * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).