@adhdev/daemon-core 0.9.82-rc.363 → 0.9.82-rc.365

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,2 @@
+import type { MedFamilyHandler } from './types.js';
+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/types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 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>;
+};
+/**
+ * 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';
+    }) => Promise<{
+        success: boolean;
+        [key: string]: unknown;
+    }>;
+    /** Bound `DaemonCommandRouter.cleanupLocalWorktreeNode`. */
+    cleanupLocalWorktreeNode: (args: {
+        mesh: any;
+        node: any;
+        nodeId: string;
+        force?: boolean;
+    }) => Promise<CleanupLocalWorktreeNodeResult>;
+    /** 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/router.d.ts

@@ -14,7 +14,22 @@ 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';
+/**
+ * Normalize a providerRoles array (RepoMeshNodePolicy.providerRoles) from raw
+ * tool args. Each entry binds a providerType to an optional `maxParallel` cap.
+ * Entries without a usable providerType are dropped; the last entry wins on
+ * duplicate providerType. Returns [] when no valid entries — callers then omit
+ * the field entirely (full backward compat). Routing is governed by required_tags;
+ * any legacy `role` field on the input is ignored.
+ */
+export declare function normalizeProviderRoles(value: unknown): Array<{
+    providerType: string;
+    maxParallel?: number;
+}>;
+export declare function readObjectRecord(value: unknown): Record<string, any>;
+export declare function readStringValue(...values: unknown[]): string | undefined;
 export declare function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string;
+export declare function readMeshNodeMachineId(node: Record<string, unknown>): string | undefined;
 /**
  * Resolve the owning-node attribution for a mesh node record so a coordinator can
  * stamp the TRUE owner onto a synthetic session entry instead of letting the
@@ -28,6 +43,54 @@ export declare function resolveMeshNodeAttribution(node: unknown): {
     machineName?: string;
 };
 export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+/**
+ * De-duplicates and rate-limits per-peer git_status probes so a single mesh
+ * refresh — or a burst of refreshes from the dashboard auto-retry loop — cannot
+ * launch a storm of concurrent/back-to-back `refreshUpstream:true` commands to
+ * the same slow peer.
+ *
+ * Two gates, both keyed by `daemonId::workspace`:
+ *  - In-flight dedup: a second probe for a key with a probe already running
+ *    shares (awaits) the in-flight promise instead of issuing a second command.
+ *  - Recently-probed reuse: a successful probe younger than `reuseMs` is reused
+ *    verbatim instead of issuing a fresh probe. Failures are NOT cached (so a
+ *    transient timeout doesn't pin a peer to "no truth" for the whole window).
+ *
+ * Lives on the router instance so the gate spans separate mesh_status calls,
+ * which is exactly where the refresh storm happens.
+ */
+export declare class MeshGitProbeCache {
+    private readonly reuseMs;
+    private readonly now;
+    private inflight;
+    private recent;
+    constructor(reuseMs: number, now?: () => number);
+    private key;
+    /**
+     * Run `probe` for this peer, but reuse a fresh recent result or an in-flight
+     * probe for the same key when one is available. `probe` is only invoked when
+     * neither gate is satisfied.
+     */
+    probe(daemonId: string, workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
+}
+export declare function hydrateInlineMeshDirectTruth(args: {
+    mesh: any;
+    meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config';
+    dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
+    statusInstanceId?: string;
+    localMachineId?: string;
+    probeRemotePeers: boolean;
+    probeCache?: MeshGitProbeCache;
+}): Promise<{
+    directEvidenceCount: number;
+    localConfirmedCount: number;
+    peerAttemptedCount: number;
+    peerConfirmedCount: number;
+    standingEvidenceCount: number;
+    unavailableNodeIds: string[];
+    deadNodeIds: string[];
+}>;
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
 type MeshRefinePatchEquivalenceSummary = {
     status: MeshRefineStageStatus;
@@ -206,6 +269,7 @@ export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHea
  * passes a regular-file conflict or a diverged (non-ff) gitlink.
  */
 export declare function evaluateGitlinkTrivialFastForward(repoRoot: string, baseHead: string, branchHead: string): GitlinkTrivialFastForwardEvaluation;
+export declare function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown>;
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: {
         includeSessions?: boolean;
@@ -275,6 +339,15 @@ export interface CommandRouterResult {
     success: boolean;
     [key: string]: unknown;
 }
+/**
+ * Confine a spec path to ~/.adhdev/providers, defeating both prefix-bypass
+ * (e.g. ".../providers-evil") and symlink escape. Resolves the real path of
+ * the *parent* directory (the file may not exist yet for writes), requires the
+ * basename to be a literal `*.json`, and re-joins under the verified parent so
+ * the returned path can't point outside the tree. Used by get/write_spec_source.
+ */
+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;
     /** In-memory cache for cloud-originating meshes passed via inlineMesh.
@@ -349,6 +422,16 @@ export declare class DaemonCommandRouter {
     private warmInlineMeshCache;
     private getMeshForCommand;
     private invalidateAggregateMeshStatus;
+    /**
+     * Build the MedFamilyContext handed to RF-ROUTER MED family handlers. Binds the
+     * router-private collaborators those handlers need (mesh resolution, owner
+     * gating, inline-cache mutation, worktree / session cleanup, refine job
+     * starters, IDE stop/launch) plus the inline-mesh and git-probe caches. The
+     * `launchIde` field closes over the freshly-built context so restart_session /
+     * restart_ide invoke the IDE launch directly instead of recursing through
+     * executeDaemonCommand('launch_ide').
+     */
+    private buildMedFamilyContext;
     private requireMeshHostMutationOwner;
     private updateInlineMeshNode;
     private removeInlineMeshNode;