@adhdev/daemon-core 0.9.82-rc.46 → 0.9.82-rc.461

package/dist/commands/low-family/coordinator-prompt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RF-ROUTER LOW family — coordinator-prompt override/append file commands.
+ *
+ * Extracted verbatim from DaemonCommandRouter.executeDaemonCommand. Both handlers
+ * read/write only the on-disk ~/.adhdev/coordinator-prompts directory (no router
+ * instance state) and return the same CommandRouterResult the inlined cases did.
+ */
+import type { LowFamilyHandler } from './types.js';
+export declare const coordinatorPromptHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/daemon-lifecycle.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const daemonLifecycleHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const diagnosticsHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/index.d.ts

@@ -0,0 +1,3 @@
+import type { LowFamilyRegistry } from './types.js';
+export type { LowFamilyContext, LowFamilyHandler, LowFamilyRegistry } from './types.js';
+export declare const lowFamilyRegistry: LowFamilyRegistry;

package/dist/commands/low-family/mesh-ledger.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RF-ROUTER LOW family — mesh ledger read / slice / import commands.
+ *
+ * Extracted verbatim from DaemonCommandRouter.executeDaemonCommand. Each handler
+ * touches only the on-disk mesh ledger (dynamically imported mesh-ledger module)
+ * keyed by meshId — no router instance state — and returns the same
+ * CommandRouterResult the inlined cases did.
+ */
+import type { LowFamilyHandler } from './types.js';
+export declare const meshLedgerHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/mesh-node-logs.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const meshNodeLogsHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/notification.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const notificationHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/refine-config.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const refineConfigHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/session-host.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const sessionHostHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/spec-providerdev.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RF-ROUTER LOW family — provider-dev / spec debug commands.
+ *
+ * Powers the dev console's spec editor: read/write a session's spec.json, validate
+ * an in-progress spec, and preview condition/section resolution against a live
+ * session's screen. Extracted verbatim from executeDaemonCommand; reads only
+ * ctx.deps.sessionRegistry + ctx.deps.cliManager. resolveSpecPathInProviders (a
+ * `this`-free module helper) is relocated here unchanged.
+ */
+import type { LowFamilyHandler } from './types.js';
+export declare const specProviderDevHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/status-meta.d.ts

@@ -0,0 +1,2 @@
+import type { LowFamilyHandler } from './types.js';
+export declare const statusMetaHandlers: Record<string, LowFamilyHandler>;

package/dist/commands/low-family/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * RF-ROUTER LOW family — shared types for the extracted low-coupling command
+ * handlers. Each handler is a pure function of (context, args): it reads only the
+ * router deps it needs and returns the exact CommandRouterResult the original
+ * `executeDaemonCommand` switch case returned, so the router facade is unchanged.
+ *
+ * Registry dispatch: DaemonCommandRouter.executeDaemonCommand looks up the cmd in
+ * lowFamilyRegistry BEFORE its switch; a hit returns the handler result, a miss
+ * falls through to the remaining switch (and ultimately CommandHandler delegation).
+ */
+import type { CommandRouterDeps, CommandRouterResult } from '../router.js';
+/** Mesh record resolved from the router's inline-mesh cache + local config. */
+export type ResolvedMeshForCommand = {
+    mesh: any;
+    inline: boolean;
+    source: 'inline_cache' | 'inline_bootstrap' | 'local_config';
+} | null;
+export interface LowFamilyContext {
+    deps: CommandRouterDeps;
+    /**
+     * Bound `DaemonCommandRouter.getMeshForCommand`. A handful of LOW handlers
+     * (mesh-node-logs) must resolve a mesh node's owning daemonId from the
+     * router's inline-mesh cache, which is router instance state not present in
+     * `deps`. The router injects it at dispatch; handlers that don't need it
+     * ignore it. Optional so unit tests can omit it (and assert the guarded
+     * fallback) without constructing a full router.
+     */
+    getMeshForCommand?: (meshId: string, inlineMesh?: unknown, options?: {
+        preferInline?: boolean;
+    }) => Promise<ResolvedMeshForCommand>;
+}
+export type LowFamilyHandler = (ctx: LowFamilyContext, args: any) => Promise<CommandRouterResult>;
+export type LowFamilyRegistry = Map<string, LowFamilyHandler>;

package/dist/commands/med-family/cli-agent.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const cliAgentHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/fast-forward.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const fastForwardHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/ide.d.ts

@@ -0,0 +1,10 @@
+import type { CommandRouterResult } from '../router.js';
+import type { MedFamilyContext, MedFamilyHandler } from './types.js';
+/**
+ * IDE launch + CDP connect. Lifted verbatim from the original `launch_ide` switch
+ * case so restart_session / restart_ide can call it directly instead of recursing
+ * through executeDaemonCommand. Reads the router's CDP managers and detection
+ * caches via ctx.deps.
+ */
+export declare function launchIde(ctx: MedFamilyContext, args: any): Promise<CommandRouterResult>;
+export declare const ideHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/index.d.ts

@@ -0,0 +1,3 @@
+import type { MedFamilyRegistry } from './types.js';
+export type { MedFamilyContext, MedFamilyHandler, MedFamilyRegistry } from './types.js';
+export declare const medFamilyRegistry: MedFamilyRegistry;

package/dist/commands/med-family/mesh-crud.d.ts

@@ -0,0 +1,48 @@
+import type { GitRepoIdentity } from '../../git/git-types.js';
+import type { MedFamilyHandler } from './types.js';
+/**
+ * Decision for syncing a freshly-cloned worktree's `oss` submodule to its clone
+ * source node, applying resolveWorktreeBaseStartPoint's origin-tip-priority
+ * policy to the submodule.
+ *
+ * On clone, `submodule update --init` checks the worktree's `oss` out at the
+ * gitlink recorded in the FRESH root base — which the root base-stale fix
+ * branches from origin/main, so it is the up-to-date origin tip. The clone
+ * source node's *working* `oss` SHA can lag that tip. The original sync blindly
+ * checked out the source SHA whenever it merely differed, which REWINDS the
+ * submodule back onto the stale source and re-introduces staleness.
+ *
+ * Guard policy (never rewind, mirror the base-start-point resolver):
+ *   - source SHA == worktree SHA            → `noop`
+ *   - source SHA is an ancestor of worktree → `skip_rewind`  (source is behind; keep fresh tip)
+ *   - worktree SHA is an ancestor of source → `advance`      (source strictly newer; safe fast-forward)
+ *   - neither is an ancestor (diverged)     → `skip_diverged` (keep fresh tip; coordinator reconciles)
+ *
+ * Both SHAs must already be resolvable in `ossCtx` (the caller fetches the
+ * source SHA first). A non-1 git exit (unresolvable SHA / real failure) is
+ * rethrown so the caller can fall back to keeping the fresh worktree HEAD.
+ */
+export type OssCloneSyncAction = 'noop' | 'advance' | 'skip_rewind' | 'skip_diverged';
+export declare function decideOssCloneSync(ossCtx: GitRepoIdentity, worktreeOssSha: string, sourceSha: string, rg: (ctx: GitRepoIdentity, argv: string[], opts?: {
+    timeoutMs?: number;
+}) => Promise<unknown>): Promise<OssCloneSyncAction>;
+/**
+ * Sync every registered submodule of a freshly-cloned worktree to its clone source
+ * node's working submodule HEAD, applying decideOssCloneSync's origin-tip-priority
+ * rewind guard per submodule.
+ *
+ * Generic over the submodule set: the paths come from `.gitmodules` via
+ * getRegisteredSubmodulePaths, so this operates identically over EVERY registered
+ * submodule (oss, adhdev-providers, …) instead of a hardcoded 'oss' literal. In a
+ * repo whose only synced submodule is `oss` the emitted git commands are byte-identical
+ * to the original oss-only path.
+ *
+ * Best-effort by design: a failure on one submodule is logged and skipped; it never
+ * blocks the other submodules or the clone. A submodule is only ever advanced to a
+ * STRICTLY-NEWER source SHA — the fresh (origin/main-derived) worktree tip is never
+ * rewound onto a behind/diverged source.
+ */
+export declare function syncClonedWorktreeSubmodules(worktreePath: string, sourceWorkspace: string, rg: (ctx: GitRepoIdentity, argv: string[], opts?: {
+    timeoutMs?: number;
+}) => Promise<unknown>): Promise<void>;
+export declare const meshCrudHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/mesh-host-pairing.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const meshHostPairingHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/mesh-queue.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const meshQueueHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/mesh-restart.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const meshRestartHandlers: Record<string, MedFamilyHandler>;

package/dist/commands/med-family/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * RF-ROUTER MED family — shared types for the extracted medium-coupling command
+ * handlers. Like the LOW family, each handler is a function of (context, args)
+ * that returns the exact CommandRouterResult the original `executeDaemonCommand`
+ * switch case returned, so the router facade is unchanged.
+ *
+ * Unlike the LOW family, MED handlers need a handful of router-private
+ * collaborators (mesh resolution, owner gating, inline-cache mutation, worktree /
+ * session cleanup, refine job starters, IDE launch). The router binds these onto
+ * MedFamilyContext at dispatch; they are NOT reachable from `deps`. The IDE family
+ * also needs `launchIde` to break the original `launch_ide`/`restart_*`
+ * self-recursion through executeDaemonCommand.
+ *
+ * Registry dispatch: DaemonCommandRouter.executeDaemonCommand looks up the cmd in
+ * medFamilyRegistry BEFORE its switch; a hit returns the handler result, a miss
+ * falls through to the remaining switch (and ultimately CommandHandler delegation).
+ */
+import type { CommandRouterDeps, CommandRouterResult, MeshGitProbeCache } from '../router.js';
+import type { RepoMeshSessionCleanupMode } from '../../repo-mesh-types.js';
+import type { WorktreeBootstrapState } from '../../mesh/worktree-bootstrap-config.js';
+/** Mesh record resolved from the router's inline-mesh cache + local config. */
+export type ResolvedMeshForCommand = {
+    mesh: any;
+    inline: boolean;
+    source: 'inline_cache' | 'inline_bootstrap' | 'local_config';
+} | null;
+/** Result of the router's local worktree-node cleanup. */
+export type CleanupLocalWorktreeNodeResult = {
+    success: true;
+    skipped?: boolean;
+    removedPath?: string;
+    repoRoot?: string;
+    reason?: string;
+    fallback?: string;
+    forced?: boolean;
+    convergence?: Record<string, unknown>;
+    recovered?: boolean;
+    residue?: boolean;
+    residueWarning?: string;
+    residueError?: string;
+} | {
+    success: false;
+    code: string;
+    error: string;
+    recoveryHint: string;
+    convergence?: Record<string, unknown>;
+};
+/**
+ * Result of the non-destructive local-worktree removability precheck. `ok:false`
+ * carries the same refusal `code`/`error`/`recoveryHint` that the destructive
+ * cleanup would have returned, so callers can refuse a removal BEFORE performing
+ * any irreversible step (e.g. stopping/deleting delegated sessions).
+ */
+export type WorktreeRemovalPrecheckResult = {
+    ok: true;
+} | {
+    ok: false;
+    code: string;
+    error: string;
+    recoveryHint: string;
+};
+/**
+ * Router-private collaborators injected at dispatch. Each is a bound method or
+ * field of DaemonCommandRouter; handlers that don't need a given collaborator
+ * simply ignore it. The router owns this instance state (inline-mesh cache,
+ * aggregate-status cache, session/worktree cleanup, refine jobs), so it cannot be
+ * read from `deps` — the registry receives bound references instead.
+ */
+export interface MedFamilyContext {
+    deps: CommandRouterDeps;
+    /** Bound `DaemonCommandRouter.getMeshForCommand`. */
+    getMeshForCommand: (meshId: string, inlineMesh?: unknown, options?: {
+        preferInline?: boolean;
+    }) => Promise<ResolvedMeshForCommand>;
+    /** Bound `DaemonCommandRouter.getCachedInlineMesh`. */
+    getCachedInlineMesh: (meshId: string, inlineMesh?: unknown) => any | undefined;
+    /** Bound `DaemonCommandRouter.requireMeshHostMutationOwner` (owner gate). */
+    requireMeshHostMutationOwner: (meshId: string, inlineMesh: unknown, operation: string) => Promise<CommandRouterResult | null>;
+    /** Bound `DaemonCommandRouter.invalidateAggregateMeshStatus`. */
+    invalidateAggregateMeshStatus: (meshId: string) => void;
+    /** Bound `DaemonCommandRouter.updateInlineMeshNode`. */
+    updateInlineMeshNode: (meshId: string, mesh: any, node: any) => void;
+    /** Bound `DaemonCommandRouter.removeInlineMeshNode`. */
+    removeInlineMeshNode: (meshId: string, mesh: any, nodeId: string) => boolean;
+    /** Bound `DaemonCommandRouter.normalizeMeshSessionCleanupMode`. */
+    normalizeMeshSessionCleanupMode: (value: unknown) => RepoMeshSessionCleanupMode;
+    /** Bound `DaemonCommandRouter.cleanupMeshSessions`. */
+    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>;
+        /**
+         * Opt-in orphan reclaim (default false). When true, a workspace-only live
+         * session (no node binding) OR a session bound to a node that no longer
+         * exists in `liveMeshNodeIds` is stopped instead of skipped — reclaims the
+         * SESSION-ACCUMULATION-LEAK orphans. `liveMeshNodeIds` is the current mesh's
+         * node id set; a session whose meshNodeId is still present is treated as an
+         * active sibling and left alone.
+         */
+        reclaimOrphans?: boolean;
+        liveMeshNodeIds?: string[];
+    }) => Promise<{
+        success: boolean;
+        [key: string]: unknown;
+    }>;
+    /** Bound `DaemonCommandRouter.cleanupLocalWorktreeNode`. */
+    cleanupLocalWorktreeNode: (args: {
+        mesh: any;
+        node: any;
+        nodeId: string;
+        force?: boolean;
+    }) => Promise<CleanupLocalWorktreeNodeResult>;
+    /**
+     * Bound `DaemonCommandRouter.precheckLocalWorktreeRemovable` — purely
+     * non-destructive validation of whether a local worktree node can be removed.
+     * Called BEFORE session cleanup so a refusal does not orphan the session.
+     */
+    precheckLocalWorktreeRemovable: (args: {
+        mesh: any;
+        node: any;
+        nodeId: string;
+        force?: boolean;
+    }) => Promise<WorktreeRemovalPrecheckResult>;
+    /** Bound `DaemonCommandRouter.startMeshRefineJob` (async execute path). */
+    startMeshRefineJob: (meshId: string, nodeId: string, args: any) => Promise<CommandRouterResult>;
+    /** Bound `DaemonCommandRouter.batchRefineMeshNodes` (dry-run batch plan). */
+    batchRefineMeshNodes: (meshId: string, requestedNodeIds: string[] | undefined, args: any) => Promise<CommandRouterResult>;
+    /** Bound `DaemonCommandRouter.startMeshRefineBatchJob` (async batch execute). */
+    startMeshRefineBatchJob: (meshId: string, requestedNodeIds: string[] | undefined, args: any) => Promise<CommandRouterResult>;
+    /** Bound `DaemonCommandRouter.stopIde` (CDP disconnect + cleanup + optional kill). */
+    stopIde: (ideType: string, killProcess?: boolean) => Promise<void>;
+    /**
+     * Module-level `launchIde` helper bound to this context. The original
+     * `launch_ide` case body, lifted into a free function so `restart_session` /
+     * `restart_ide` can invoke the IDE launch directly instead of recursing
+     * through `executeDaemonCommand('launch_ide')` (which would re-enter the
+     * registry). Byte-identical to the original case body.
+     */
+    launchIde: (args: any) => Promise<CommandRouterResult>;
+    /** Router's inline-mesh cache (read/write of resolved mesh records). */
+    inlineMeshCache: Map<string, any>;
+    /** Router's mesh git-probe cache (reused direct-truth probes for get_mesh). */
+    meshGitProbeCache: MeshGitProbeCache;
+}
+export type MedFamilyHandler = (ctx: MedFamilyContext, args: any) => Promise<CommandRouterResult | null>;
+export type MedFamilyRegistry = Map<string, MedFamilyHandler>;
+export type { WorktreeBootstrapState };

package/dist/commands/mesh-coordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js';
+import type { MeshCoordinatorMcpConfigFormat, MeshCoordinatorSystemPromptInjection, ProviderModule } from '../providers/contracts.js';
 export interface MeshCoordinatorMcpServerLaunch {
     command: string;
     args: string[];
@@ -25,6 +25,7 @@ export type MeshCoordinatorSetup = {
     command: string;
     requiresRestart: boolean;
     instructions: string;
+    mcpServer: MeshCoordinatorMcpServerLaunch;
 } | {
     kind: 'unsupported';
     reason: string;
@@ -42,3 +43,86 @@ export interface ResolveMeshCoordinatorSetupOptions {
 }
 export declare function createHermesManualMeshCoordinatorSetup(meshId: string, workspace: string): MeshCoordinatorSetup;
 export declare function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup;
+/**
+ * Apply a provider's declared system-prompt injection rule, mutating `cliArgs`
+ * and `launchEnv` in place and writing any required workspace context file.
+ *
+ * Replaces the previous hard-coded `if (cliType === 'claude-cli') ... else if
+ * (cliType === 'hermes-cli') ...` branches in router.ts. Adding a new CLI is
+ * now provider.v1.json data, not a router edit.
+ *
+ * Failures are non-fatal: log and continue with whatever was applied so the
+ * coordinator session still launches, just without the prompt for that
+ * provider. A missing/unknown rule means "skip injection" — safe by default
+ * (the previous fallback unconditionally pushed --append-system-prompt onto
+ * every non-Claude CLI, which crashed agy on launch).
+ */
+export interface CoordinatorInjectionEffect {
+    /** Absolute path the daemon wrote a wrapper-blocked file to. Only set for
+     *  context_file injection. R48 schedules a strip after launch so workers
+     *  don't see the wrapper on disk; R47's unregister cleanup uses it as a
+     *  fallback if the timer never fires (process crash, etc). */
+    contextFilePath?: string;
+}
+export declare function applyMeshCoordinatorSystemPromptInjection(systemPrompt: string, injection: MeshCoordinatorSystemPromptInjection | undefined, ctx: {
+    cliArgs: string[];
+    launchEnv: Record<string, string>;
+    workspace: string;
+    cliType: string;
+}): CoordinatorInjectionEffect;
+/**
+ * Strip the daemon's wrapper block from a context_file we previously wrote.
+ *
+ * Used in two places:
+ *   1. R48 inject-then-remove: ~5s after spawn, after agy/gemini have read
+ *      the file into their in-memory system-prompt cache. Removing it from
+ *      disk at that point doesn't affect the running coordinator but keeps
+ *      worker sessions (or fresh non-coordinator launches) in the same
+ *      workspace from picking up our wrapper.
+ *   2. R47 unregister fallback: if the timer never fires (process crash,
+ *      kill -9), coordinator-registry.unregisterMeshCoordinator runs the
+ *      same logic when its entry is dropped.
+ *
+ * Idempotent: missing file is fine, missing sentinels are fine, returns
+ * silently. Leaves user-authored content outside the sentinels intact.
+ * Deletes the file outright if our wrapper was the only content.
+ */
+export declare function stripCoordinatorWrapperFile(filePath: string): void;
+export interface PtyExecResult {
+    exitCode: number | null;
+    signal: number | null;
+    output: string;
+    timedOut: boolean;
+}
+export interface MeshCoordinatorRegistrationStep {
+    command: string;
+    args: string[];
+    required: boolean;
+    label: 'remove_existing' | 'register';
+}
+/**
+ * Codex rejects `mcp add` when a server with the same name already exists.
+ * Replace that entry before registering so transport/mesh changes do not leave
+ * a fresh coordinator attached to stale MCP launch arguments.
+ */
+export declare function buildMeshCoordinatorRegistrationPlan(cliType: string, serverName: string, registrationCommand: string): MeshCoordinatorRegistrationStep[];
+/**
+ * Run a one-shot CLI command under a real PTY and collect its output.
+ *
+ * Some provider mcp-registration commands (`agy mcp add`, future bubbletea
+ * TUIs) refuse to run without `/dev/tty`. Daemon-side `execFileSync` runs
+ * pipe-only, so those commands fail with errors like
+ *   `bubbletea: error opening TTY: open /dev/tty: device not configured`
+ * and silently skip the registration, leaving the launched session
+ * without the adhdev-mesh MCP tools — which is exactly what we saw with
+ * agy coordinators.
+ *
+ * Wrapping the registration through node-pty gives the child a real PTY,
+ * so the bubbletea check passes. We close stdin immediately and just
+ * collect stdout until the process exits or the timeout fires.
+ */
+export declare function execUnderPty(command: string, args: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}): Promise<PtyExecResult>;

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>;