@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/dist/commands/handler.d.ts

@@ -102,9 +102,134 @@ export declare class DaemonCommandHandler implements CommandHelpers {
     private logCommandStart;
     private logCommandEnd;
     setAgentStreamManager(manager: DaemonAgentStreamManager): void;
+    /**
+     * When a command in the manual-attendance set arrives for a session this
+     * daemon hosts, stamp the live instance so auto-approve holds while the user
+     * drives the session by hand. Provider-common: the signal is the command
+     * (foreground select_session / open_panel, controlbar invoke_provider_script
+     * / set_mode / change_model / set_thought_level, manual resolve_action,
+     * pty_input), never any CLI-specific modal text — so it works identically for
+     * every CLI/ACP provider. send_chat is deliberately excluded because a
+     * coordinator delegating a task to a worker also uses send_chat; counting it
+     * would wrongly suppress the worker's delegated auto-approve. For a remote
+     * mesh worker session the controlbar commands are forwarded to the owning
+     * worker daemon, which runs this same hook there, so attendance is recorded
+     * on the daemon that actually hosts the instance.
+     */
+    private noteManualAttendanceIfApplicable;
     handle(cmd: string, args: any): Promise<CommandResult>;
     private dispatch;
+    /**
+     * Reload providers from disk. Does NOT pull from the registry — the user
+     * controls installs explicitly via install_provider_manifest. To upgrade
+     * an installed provider, call install_provider_manifest again with the
+     * desired version (or with no version to pick up the latest from
+     * registry), or use check_provider_updates to see what is out of date.
+     */
     private handleRefreshScripts;
+    /**
+     * Return per-provider availability so the dashboard's provider catalog
+     * can show "Installed" badges. Reuses the existing detection state from
+     * ProviderLoader.getMachineProviderStatus() — no probing is triggered.
+     */
+    private handleListProviderAvailability;
+    /**
+     * Compute the *upstream cache root*. install_provider_manifest writes
+     * official-registry manifests here so the daemon's standard upstream
+     * layer picks them up — no special handling needed at load time, and
+     * the manifests inherit the official-trust badge instead of the
+     * untrusted-external one.
+     *
+     * Path matches ProviderLoader.upstreamDir but we recompute it from
+     * homedir() so this method stays usable in dev where userDir can
+     * point at a sibling git checkout.
+     */
+    private getUpstreamInstallRoot;
+    /**
+     * Download a single provider manifest from the registry and write it to
+     * ~/.adhdev/providers/.upstream/{category}/{type}/provider.json.
+     *
+     * Used by standalone onboarding to seed the upstream cache with the
+     * default provider set on first launch. Verifies SHA-256 checksum
+     * against the registry meta before persisting. Refuses to write
+     * outside the upstream root.
+     *
+     * Args: { type: string, category?: string, version?: string }
+     * If category/version are omitted, looks up the latest from the registry.
+     */
+    private handleInstallProviderManifest;
+    /**
+     * If `manifest.source = { type:'github', repo, ref, subdir? }` is set,
+     * walk each script directory the manifest references and download every
+     * file from the public GitHub raw endpoint. Returns a small summary so
+     * the caller can report what was fetched.
+     *
+     * Best-effort: failures don't reject the install — the manifest itself is
+     * usable for declarative-only providers, and the user still gets a clear
+     * error string back if a needed script is missing.
+     */
+    private fetchProviderSources;
+    /**
+     * Remove a provider manifest from the upstream cache root
+     * (~/.adhdev/providers/.upstream/{category}/{type}/). Refuses to touch
+     * anything outside that root. Used by onboarding to opt out of a
+     * provider the user doesn't want; the dashboard no longer exposes a
+     * per-provider uninstall button (external sources are removed as a
+     * whole via remove_provider_source).
+     */
+    private handleUninstallProviderManifest;
+    /**
+     * Return everything currently installed in the upstream cache with its
+     * version. This is the "what does this daemon have" answer used both by
+     * the UI and by the update checker.
+     */
+    private handleListInstalledProviders;
+    /**
+     * For each installed provider, ask the registry for its current latest
+     * version and report whether an update is available. The user can then
+     * call install_provider_manifest to upgrade (it overwrites the file).
+     *
+     * Returns { providers: [{ type, category, installedVersion, latestVersion,
+     *   updateAvailable, error? }] }
+     */
+    private handleCheckProviderUpdates;
+    /**
+     * Register a new external provider source. The daemon clones the repo
+     * to ~/.adhdev/external/<name>/, walks it once to detect provided
+     * types, and surfaces any conflicts with already-installed types so
+     * the dashboard can ask the user how to resolve them.
+     *
+     * Args: { url: string, ref?: string, name?: string }
+     *   - url: https://, git@, or any git-cloneable URL
+     *   - ref: branch/tag/commit (default "main")
+     *   - name: short identifier (default derived from URL)
+     *
+     * Returns: { source, providers, conflicts }
+     *   - conflicts: list of types this new source provides that another
+     *     source already exposes. UI uses this to prompt for active-source
+     *     selection before the load takes effect.
+     */
+    private handleAddProviderSource;
+    /**
+     * Remove a registered external source. Deletes the clone directory and
+     * any active-source entry pointing to it.
+     *
+     * Args: { name: string }
+     */
+    private handleRemoveProviderSource;
+    /**
+     * List registered external sources + each source's currently installed
+     * providers + the active selection for any conflicting types. Used by
+     * the dashboard's "Sources" tab.
+     */
+    private handleListProviderSources;
+    /**
+     * Pick which source's copy of a conflicting provider type is active.
+     * Other sources' copies stay on disk but the loader ignores them.
+     *
+     * Args: { type: string, sourceName: string }
+     */
+    private handleSetActiveProviderSource;
     private proxyDevServerPost;
     private proxyDevServerGet;
     private proxyDevServerScaffold;

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

@@ -0,0 +1,3 @@
+import type { HighFamilyRegistry } from './types.js';
+export type { HighFamilyContext, HighFamilyHandler, HighFamilyRegistry } from './types.js';
+export declare const highFamilyRegistry: HighFamilyRegistry;

package/dist/commands/high-family/mesh-coordinator-launch.d.ts

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

package/dist/commands/high-family/mesh-events.d.ts

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

package/dist/commands/high-family/mesh-status.d.ts

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

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

@@ -0,0 +1,64 @@
+/**
+ * RF-ROUTER HIGH family — shared types for the extracted high-coupling command
+ * handlers. Like the LOW and MED families, 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.
+ *
+ * HIGH handlers are the most router-coupled of the three families: in addition to
+ * the MED collaborators (mesh resolution, owner gating, inline-cache), they reach
+ * the router's aggregate-status memory cache and running-refine-job table — state
+ * the router owns and the `mesh_status` aggregate render and `get_mesh_review_inbox`
+ * re-entry both depend on. The router binds those onto HighFamilyContext at
+ * dispatch; they are NOT reachable from `deps`.
+ *
+ * Registry dispatch: DaemonCommandRouter.executeDaemonCommand looks up the cmd in
+ * highFamilyRegistry AFTER the LOW and MED registries and BEFORE its remaining
+ * switch; a hit returns the handler result, a miss falls through to the switch
+ * (and ultimately CommandHandler delegation).
+ */
+import type { CommandRouterDeps, CommandRouterResult, MeshGitProbeCache, MeshRefineJobHandle } from '../router.js';
+import type { ResolvedMeshForCommand } from '../med-family/types.js';
+/**
+ * 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 memory cache, running-refine-job table, git-probe cache), so
+ * it cannot be read from `deps` — the registry receives bound references instead.
+ */
+export interface HighFamilyContext {
+    deps: CommandRouterDeps;
+    /** Bound `DaemonCommandRouter.getMeshForCommand`. */
+    getMeshForCommand: (meshId: string, inlineMesh?: unknown, options?: {
+        preferInline?: boolean;
+    }) => Promise<ResolvedMeshForCommand>;
+    /** Bound `DaemonCommandRouter.getCachedAggregateMeshStatus`. */
+    getCachedAggregateMeshStatus: (meshId: string, mesh?: any, options?: {
+        requireDirectPeerTruth?: boolean;
+        allowStalePending?: boolean;
+    }) => any | null;
+    /** Bound `DaemonCommandRouter.rememberAggregateMeshStatus`. */
+    rememberAggregateMeshStatus: (meshId: string, snapshot: any, refreshReason: string) => any;
+    /**
+     * Bound `DaemonCommandRouter.execute`. `get_mesh_review_inbox` re-enters the
+     * router with a `mesh_status` refresh to obtain computed node fields; this is
+     * the same self-call the inlined case made.
+     */
+    execute: (cmd: string, args: any, source?: string) => Promise<CommandRouterResult>;
+    /** Router's aggregate-status memory cache (`.has()` probe in mesh_status). */
+    aggregateMeshStatusCache: Map<string, {
+        builtAt: number;
+        snapshot: any;
+        queueRevision: string;
+    }>;
+    /** Meshes with a background SWR freshen already in flight — coalesces the
+     *  async refresh a stale-serve interactive open kicks off. */
+    swrRefreshInFlight: Set<string>;
+    /** Router's running-refine-job table (surfaced as activeRefineJobs in mesh_status). */
+    runningRefineJobs: Map<string, MeshRefineJobHandle>;
+    /** Router's inline-mesh cache (launch_mesh_coordinator caches cloud inline mesh). */
+    inlineMeshCache: Map<string, any>;
+    /** Router's mesh git-probe cache (shared probe dedup for mesh_status). */
+    meshGitProbeCache: MeshGitProbeCache;
+}
+export type HighFamilyHandler = (ctx: HighFamilyContext, args: any) => Promise<CommandRouterResult | null>;
+export type HighFamilyRegistry = Map<string, HighFamilyHandler>;

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