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

package/dist/commands/chat-commands.d.ts

@@ -6,6 +6,33 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import { type InputEnvelope } from '../providers/contracts.js';
 export declare const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25000;
 export declare function buildSendInputSignature(input: InputEnvelope): string;
+/**
+ * read_chat node scope verdict. One physical daemon hosts a base node plus several
+ * worktree nodes; mesh_read_chat always dispatches read_chat with the requested
+ * node's workspace (`args.workspace`). When the resolved target session actually
+ * lives in a DIFFERENT worktree, returning its transcript — or worse, letting the
+ * native-history-by-workspace fallback splice sibling worktree turns into the
+ * reply — makes the coordinator believe one session received every worktree's
+ * work. This guard refuses a CONFIRMED cross-workspace read instead of mixing.
+ *
+ * Conservative by design (mirrors the WTCLAIM fix-B "unknown → allow" rule): only
+ * a session id that resolves to a known workspace which is unequal to a known
+ * intended workspace blocks. When either side is unknown — no targetSessionId, no
+ * args.workspace, an unregistered session, the coordinator self-session, or a
+ * plain dashboard read that never passes a node workspace — the read proceeds
+ * untouched, so base-node and same-daemon coordinator reads never regress.
+ */
+export declare function evaluateReadChatNodeWorkspaceScope(args: {
+    targetSessionId?: string;
+    intendedWorkspace?: string;
+    sessionWorkspace?: string;
+}): {
+    scoped: false;
+} | {
+    scoped: true;
+    intended: string;
+    actual: string;
+};
 interface DebugSanitizeOptions {
     maxDepth?: number;
     maxArrayLength?: number;

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,60 @@
+/**
+ * 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;
+    }) => 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;
+    }>;
+    /** 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/router.d.ts

@@ -14,6 +14,7 @@ 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';
+export declare function readProviderPriorityFromPolicy(policy: unknown): string[];
 /**
  * Normalize a providerRoles array (RepoMeshNodePolicy.providerRoles) from raw
  * tool args. Each entry binds a providerType to an optional `maxParallel` cap.
@@ -28,8 +29,42 @@ export declare function normalizeProviderRoles(value: unknown): Array<{
 }>;
 export declare function readObjectRecord(value: unknown): Record<string, any>;
 export declare function readStringValue(...values: unknown[]): string | undefined;
+export declare function readBooleanValue(...values: unknown[]): boolean | undefined;
+export declare function summarizeRepoMeshStatusDebug(status: any): Record<string, unknown>;
+export declare function logRepoMeshStatusDebug(event: string, fields: Record<string, unknown>): void;
 export declare function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string;
 export declare function readMeshNodeMachineId(node: Record<string, unknown>): string | undefined;
+export declare function readMeshNodeHostname(node: Record<string, unknown>): string | undefined;
+export declare function buildMeshNodeMachineIdentity(node: Record<string, unknown>, opts: {
+    localMachineId?: string;
+    localDaemonId?: string;
+    coordinatorHostname?: string;
+    isSelfNode?: boolean;
+}): Record<string, unknown>;
+export declare function buildInlineMeshTransitGitStatus(node: any): Record<string, unknown> | undefined;
+export declare function buildLivePeerGitConnection(connection: Record<string, unknown>, timestamp?: string): Record<string, unknown>;
+export declare function recordInlineMeshDirectGitTruth(node: any, git: Record<string, unknown>, source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git'): {
+    reporterPlatform: string | null;
+    reporterArch: string | null;
+};
+/**
+ * Persist the live self-reported platform/arch onto the local meshes.json node
+ * record so capability-tag os=/arch= self-heals across coordinator restarts.
+ *
+ * The in-memory stamp done by recordInlineMeshDirectGitTruth lives on the
+ * mesh_status assembly object and is discarded after the response; only a
+ * `local_config` mesh has a backing meshes.json node to write through to. Inline
+ * cache/bootstrap meshes have no local node to update, so we no-op for them.
+ * Fire-and-forget (same pattern as the worktreeBootstrap writer) — a persistence
+ * failure must never block the status response.
+ */
+export declare function persistNodeReporterPlatform(meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config', mesh: any, nodeId: string | undefined, reporter: {
+    reporterPlatform: string | null;
+    reporterArch: string | null;
+}): void;
+export declare function deriveMeshNodeHealthFromGit(git: Record<string, unknown> | null | undefined): 'online' | 'dirty' | 'degraded';
+export declare function applyInlineMeshBranchConvergence(mesh: any, node: any, status: Record<string, unknown>): void;
+export declare function summarizeInlineMeshBranchConvergence(nodes: Array<Record<string, unknown>>): Record<string, unknown>;
 /**
  * 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
@@ -43,6 +78,15 @@ export declare function resolveMeshNodeAttribution(node: unknown): {
     machineName?: string;
 };
 export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+export declare function finalizeMeshNodeStatus(args: {
+    status: Record<string, unknown>;
+    node: any;
+    daemonId?: string;
+    isSelfNode: boolean;
+}): void;
+export declare const MESH_DIRECT_PROBE_TIMEOUT_MS: number;
+export declare const MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS: number;
+export declare const MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS: number;
 /**
  * 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
@@ -73,6 +117,62 @@ export declare class MeshGitProbeCache {
      */
     probe(daemonId: string, workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
 }
+/**
+ * Await `work` under a warmup-aware deadline so a cold-open DataChannel handshake
+ * is NOT charged against the command response budget — the root cause of the
+ * "first mesh probe to a cold peer false-times-out, the warm retry succeeds"
+ * signature. Two budgets, switched by the live peer connection state:
+ *
+ *  - While `isConnected()` returns false the peer's channel is still opening; the
+ *    cold-open `connectTimeoutMs` budget applies. This phase is deliberately
+ *    generous because a TURN-relayed cross-machine handshake legitimately needs
+ *    many seconds — but a genuine connect *failure* is surfaced by `work`
+ *    rejecting on its own (the mesh manager fails the peer the instant its
+ *    PeerConnection state goes terminal), so a real failure is never masked for
+ *    the whole window.
+ *  - The first time `isConnected()` returns true the channel is warm; from that
+ *    instant the tight `responseTimeoutMs` governs how long the handler may take.
+ *    Warm-channel callers therefore see behavior identical to the old single
+ *    `Promise.race(work, responseTimeoutMs)`.
+ *
+ * Rejects with `Error('timeout')` when either budget is exhausted, mirroring the
+ * previous single-race contract. Pure except for timers + the injected
+ * `isConnected` probe, so it is unit-testable under fake timers without any real
+ * WebRTC. When no connection getter is wired `isConnected` should be `() => true`
+ * (the caller's choice) so the response deadline governs from t0 — the legacy
+ * single-budget behavior, never a combined connect+response window.
+ */
+export declare function awaitWithWarmupDeadline<T>(work: Promise<T>, opts: {
+    isConnected: () => boolean;
+    connectTimeoutMs: number;
+    responseTimeoutMs: number;
+    pollIntervalMs?: number;
+}): Promise<T>;
+/**
+ * Probe a remote peer's git_status with a bounded retry budget, but only while
+ * the peer is reported `connected`. A single slow (often TURN-relayed) peer can
+ * exceed one probe window; retrying — with the connection re-checked before each
+ * attempt so we abandon a peer that dropped — recovers it without blocking the
+ * mesh forever. Shared by the bootstrap hydrate path and the per-node render
+ * path so both treat a connected-but-slow peer identically.
+ *
+ * Returns the git status on success, or null if every attempt failed/timed out
+ * (caller decides how to classify). `getConnection` is consulted before each
+ * attempt; a non-`connected` state short-circuits the retry loop (the very first
+ * attempt always runs so a missing connection getter still gets one try).
+ */
+export declare function probeRemoteMeshGitStatusWithRetry(args: {
+    dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
+    daemonId: string;
+    workspace: string;
+    timeoutMs: number;
+    /** Per-attempt timeout for retries (attempts > 0); defaults to timeoutMs. */
+    retryTimeoutMs?: number;
+    /** Cold-open warmup budget per attempt; defaults to MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS. */
+    connectTimeoutMs?: number;
+    getConnection?: (daemonId: string) => Record<string, unknown> | null;
+    onConnection?: (connection: Record<string, unknown>) => void;
+}): Promise<Record<string, unknown> | null>;
 export declare function hydrateInlineMeshDirectTruth(args: {
     mesh: any;
     meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config';
@@ -91,6 +191,44 @@ export declare function hydrateInlineMeshDirectTruth(args: {
     unavailableNodeIds: string[];
     deadNodeIds: string[];
 }>;
+export declare function summarizeMeshSessionRecord(record: any): Record<string, unknown>;
+export declare function readLiveMeshNodeWorkspace(args: {
+    meshId: string;
+    nodeId: string;
+    liveSessionRecords: any[];
+    allowCoordinatorSession?: boolean;
+}): string;
+export declare function collectLiveMeshSessionRecords(args: {
+    meshId: string;
+    node: any;
+    nodeId: string;
+    liveSessionRecords: any[];
+    allowCoordinatorSession?: boolean;
+}): any[];
+export declare function buildHistoricalMeshSessions(args: {
+    meshId: string;
+    nodes: any[];
+    liveSessionRecords: any[];
+}): {
+    count: number;
+    sessions: Record<string, unknown>[];
+    instruction: string;
+} | undefined;
+export declare function applyCachedInlineMeshNodeStatus(status: Record<string, unknown>, node: any, options?: {
+    skipGit?: boolean;
+    skipError?: boolean;
+    skipHealth?: boolean;
+}): boolean;
+export declare function resolveProviderTypeFromPriority(args: {
+    nodeId: string;
+    providerPriority: string[];
+    providerLoader: ProviderLoader;
+    onStatusChange?: () => void;
+}): Promise<{
+    providerType?: string;
+    error?: string;
+}>;
+export type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
 type MeshRefinePatchEquivalenceSummary = {
     status: MeshRefineStageStatus;
@@ -149,6 +287,38 @@ type MeshRefineSubmoduleConflictHint = {
     }>;
     nextSteps: string[];
 };
+type MeshRefineAsyncJobStatus = 'accepted' | 'completed' | 'failed';
+export type MeshRefineJobHandle = {
+    success: true;
+    async: true;
+    status: MeshRefineAsyncJobStatus;
+    jobId: string;
+    interactionId: string;
+    meshId: string;
+    nodeId: string;
+    targetNodeId: string;
+    targetDaemonId?: string;
+    workspace?: string;
+    startedAt: string;
+    completedAt?: string;
+    duplicate?: boolean;
+    retryOfJobId?: string;
+    /**
+     * The coordinator daemon ID that initiated this refine job.
+     * When set, events for this job are scoped to that coordinator's
+     * pending-events queue instead of the shared broadcast queue.
+     */
+    targetCoordinatorDaemonId?: string;
+    eventDelivery: {
+        pendingEvents: true;
+        ledger: true;
+    };
+    evidence: {
+        pendingEventsCommand: 'get_pending_mesh_events';
+        ledgerCommand: 'get_mesh_ledger_slice';
+        taskHistoryKind: 'task_dispatched' | 'task_completed' | 'task_failed';
+    };
+};
 /**
  * A spawn-resolution failure is when the executable itself could not be found by
  * the OS spawn boundary — `spawn <cmd> ENOENT` — as opposed to the command
@@ -270,6 +440,16 @@ export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHea
  */
 export declare function evaluateGitlinkTrivialFastForward(repoRoot: string, baseHead: string, branchHead: string): GitlinkTrivialFastForwardEvaluation;
 export declare function buildMeshRefineValidationPlan(mesh: any, workspace: string): Record<string, unknown>;
+export declare function getMcpServersKey(format: MeshCoordinatorConfigFormat): 'mcpServers' | 'mcp_servers';
+export declare function parseMeshCoordinatorMcpConfig(text: string, format: MeshCoordinatorConfigFormat): Record<string, any>;
+export declare function serializeMeshCoordinatorMcpConfig(config: Record<string, any>, format: MeshCoordinatorConfigFormat): string;
+export declare function loadHermesCoordinatorBaseConfig(targetConfigPath: string): {
+    config: Record<string, any>;
+    sourceHome: string;
+    sourceConfigPath: string;
+};
+export declare function stripHermesCoordinatorTempModelProviderOverrides(config: Record<string, any>): Record<string, any>;
+export declare function copyHermesCoordinatorCredentialFiles(sourceHome: string, targetHome: string): void;
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: {
         includeSessions?: boolean;
@@ -432,6 +612,17 @@ export declare class DaemonCommandRouter {
      * executeDaemonCommand('launch_ide').
      */
     private buildMedFamilyContext;
+    /**
+     * Build the HighFamilyContext handed to RF-ROUTER HIGH family handlers. Binds
+     * the router-private collaborators those handlers need (mesh resolution, the
+     * aggregate-status memory cache + its bound read/write helpers, the
+     * running-refine-job table, inline-mesh + git-probe caches, and the router's
+     * own `execute` for the get_mesh_review_inbox mesh_status re-entry). HIGH
+     * handlers reach more router-owned state than MED, but the binding shape is
+     * the same: bound methods + direct field references, none reachable from
+     * `deps`.
+     */
+    private buildHighFamilyContext;
     private requireMeshHostMutationOwner;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
@@ -482,7 +673,58 @@ export declare class DaemonCommandRouter {
      * 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