@adhdev/daemon-core 0.9.82-rc.376 → 0.9.82-rc.378

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

@@ -0,0 +1,14 @@
+/**
+ * Chat Commands — get_chat_debug_bundle: sanitize, summarize and store a
+ * diagnostic snapshot of the current read_chat / provider / session state.
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+interface DebugSanitizeOptions {
+    maxDepth?: number;
+    maxArrayLength?: number;
+    maxObjectKeys?: number;
+    maxStringLength?: number;
+}
+export declare function sanitizeDebugBundleValue(value: unknown, options?: DebugSanitizeOptions, depth?: number, keyHint?: string): unknown;
+export declare function handleGetChatDebugBundle(h: CommandHelpers, args: any): Promise<CommandResult>;
+export {};

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

@@ -0,0 +1,7 @@
+/**
+ * Chat Commands — read side: handleReadChat, handleChatHistory and the
+ * native-history / source-resolution / normalization helpers they use.
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;

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

@@ -0,0 +1,39 @@
+/**
+ * Chat Commands — read_chat node workspace scope guard.
+ */
+import type { CommandHelpers } from './handler.js';
+/**
+ * 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;
+};
+/**
+ * Resolve the target session's ACTUAL workspace from the most authoritative source
+ * available on this daemon: the session registry record (stamped at register
+ * time), then the live CLI adapter's working directory, then the bound instance
+ * state. Returns '' when nothing knows the session's workspace — the caller treats
+ * that as "unknown" and does not block.
+ */
+export declare function resolveTargetSessionActualWorkspace(h: CommandHelpers, targetSessionId: string): string;

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

@@ -0,0 +1,33 @@
+/**
+ * Chat Commands — shared private helpers used by more than one handler group.
+ *
+ * These were module-local helpers/consts/interfaces in chat-commands.ts. They
+ * are exported here only so the split read/write/debug/scope sub-modules can
+ * import them; they are NOT part of the public chat-commands surface (except
+ * READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS and buildSendInputSignature, which the
+ * chat-commands barrel re-exports).
+ */
+import type { CommandHelpers } from './handler.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { type InputEnvelope, type ProviderModule } from '../providers/contracts.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
+import type { ChatMessage } from '../types.js';
+import type { SessionTransport } from '../shared-types.js';
+export declare const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25000;
+export interface ApprovalSelectableInstance extends ProviderInstance {
+    recordApprovalSelection?(buttonText: string): void;
+}
+export interface RuntimeChatMessageMerger extends ProviderInstance {
+    mergeRuntimeChatMessages?(messages: ChatMessage[]): ChatMessage[];
+    recordAcknowledgedUserInput?(input: InputEnvelope | string): void;
+}
+export declare function getCurrentProviderType(h: CommandHelpers, fallback?: string): string;
+export declare function getCurrentManagerKey(h: CommandHelpers): string;
+export declare function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string): CliAdapter | null;
+export declare function getTargetInstance(h: CommandHelpers, args: any): ApprovalSelectableInstance | null;
+export declare function getTargetTransport(h: CommandHelpers, provider?: ProviderModule): SessionTransport | null;
+export declare function isCliLikeTransport(transport: SessionTransport | null): boolean;
+export declare function isExtensionTransport(transport: SessionTransport | null): boolean;
+export declare function buildSendInputSignature(input: InputEnvelope): string;
+export declare function parseMaybeJson(value: any): any;
+export declare function getChatMessageSignature(message: ChatMessage | null | undefined): string;

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

@@ -0,0 +1,14 @@
+/**
+ * Chat Commands — write side: handleSendChat, handleListChats, handleNewChat,
+ * handleSwitchChat, handleSetMode, handleChangeModel, handleSetThoughtLevel,
+ * handleResolveAction and the send/mode/model helpers they use.
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleSetThoughtLevel(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult>;

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

@@ -1,54 +1,14 @@
 /**
  * Chat Commands — readChat, sendChat, listChats, newChat, switchChat,
  *                 setMode, changeModel, setThoughtLevel, resolveAction, chatHistory
- */
-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.
+ * This module is a re-export barrel. The implementation was split into focused
+ * sub-modules (chat-commands-shared / -scope / -debug-bundle / -read / -write)
+ * as a pure move; the public export surface here is unchanged. handler.ts does
+ * `import * as Chat from './chat-commands.js'` and keeps working unchanged.
  */
-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;
-    maxObjectKeys?: number;
-    maxStringLength?: number;
-}
-export declare function sanitizeDebugBundleValue(value: unknown, options?: DebugSanitizeOptions, depth?: number, keyHint?: string): unknown;
-export declare function handleGetChatDebugBundle(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleReadChat(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleListChats(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleNewChat(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleSwitchChat(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleSetMode(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleChangeModel(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleSetThoughtLevel(h: CommandHelpers, args: any): Promise<CommandResult>;
-export declare function handleResolveAction(h: CommandHelpers, args: any): Promise<CommandResult>;
-export {};
+export { READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, buildSendInputSignature } from './chat-commands-shared.js';
+export { evaluateReadChatNodeWorkspaceScope } from './chat-commands-scope.js';
+export { sanitizeDebugBundleValue, handleGetChatDebugBundle } from './chat-commands-debug-bundle.js';
+export { handleChatHistory, handleReadChat } from './chat-commands-read.js';
+export { handleSendChat, handleListChats, handleNewChat, handleSwitchChat, handleSetMode, handleChangeModel, handleSetThoughtLevel, handleResolveAction, } from './chat-commands-write.js';

package/dist/commands/router.d.ts

@@ -14,476 +14,9 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
-import { awaitWithWarmupDeadline } from '../mesh/mesh-warmup-deadline.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.
- * 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 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
- * dashboard fall back to the coordinator's own daemonId. Returns whichever of the
- * owning node's `daemonId` / display machine name could be read from the node's
- * (possibly multi-serialization-path) shape; both may be undefined for a node that
- * never carried machine identity.
- */
-export declare function resolveMeshNodeAttribution(node: unknown): {
-    daemonId?: string;
-    machineName?: string;
-};
-export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
-/**
- * Transient per-node marker the mesh_status render loop stamps onto a node
- * `status` at the two sites that obtain git truth from a FRESH probe this call
- * (a successful local `getGitRepoStatus`, or a successful P2P `git_status`
- * round-trip). finalizeMeshNodeStatus consumes and deletes it. Held/standing
- * truth (node.lastGit / cachedStatus / inline transit) is deliberately NOT
- * stamped — its absence is exactly how the freshness marker tells "live" apart
- * from "cached". Internal only; never serialized in the response.
- */
-export declare const MESH_NODE_LIVE_TRUTH_MARKER = "__liveTruthProbed";
-/**
- * Build the additive per-node `dataFreshness` marker. This NEVER mutates any
- * existing field — it only adds an explicit, machine-readable answer to the
- * question the legacy fields blurred: is this node's data live (just probed),
- * cached (held truth, maybe old), or absent because the peer was unreachable?
- *
- * The crucial separation: an UNREACHABLE peer (P2P probe failed / not connected)
- * is no longer indistinguishable from an idle/EMPTY node. Both used to render as
- * `health:'unknown'` with no sessions; now `dataFreshness.dataSource` and
- * `reachable` tell them apart so a coordinator never reads a dead peer as "online
- * but doing nothing".
- */
-export declare function buildMeshNodeDataFreshness(args: {
-    status: Record<string, unknown>;
-    node?: any;
-    isSelfNode: boolean;
-    daemonId?: string;
-    /** True when this node was stamped with a fresh live git probe this call. */
-    liveTruthProbed: boolean;
-    /** True when direct-peer-truth accounting classified this node unavailable. */
-    directTruthUnavailable?: boolean;
-    now?: () => number;
-}): Record<string, unknown>;
-/**
- * Canonical live-probe → freshness adapter. The coordinator-facing mesh_status
- * (mcp-server `meshStatus`) builds each node entry from a SINGLE fresh git_status
- * probe that either returns (live truth) or throws (peer unreachable). It used to
- * hand-reconstruct the freshness INPUT inline — a synthetic `{ git, connection }`
- * status plus the directTruthUnavailable/liveTruthProbed wiring — which is exactly
- * how a field added to `buildMeshNodeDataFreshness`'s input contract ends up "wired
- * on the daemon surface, null on the coordinator surface" (the rc.371
- * null-everywhere regression). Routing every live-probe surface through this one
- * adapter keeps the marker derivation canonical: there is a SINGLE place that turns
- * a probe outcome into freshness args, so the two mesh_status surfaces cannot drift.
- *
- * `liveTruthProbed` true → the probe returned (live/self truth); false → it threw,
- * so a configured peer is unreachable while an unconfigured node (no daemonId) falls
- * through to the classifier's `unconfigured` branch.
- */
-export declare function buildMeshNodeProbeFreshness(args: {
-    /** The git snapshot this probe stamped on the node entry (entry.git). */
-    git: unknown;
-    /** True when the fresh git_status probe RETURNED (live truth); false when it threw. */
-    liveTruthProbed: boolean;
-    isSelfNode: boolean;
-    /** The node's resolved daemonId; absent → unconfigured node. */
-    daemonId?: string;
-    /** The mesh node record, for held-git fallback when the probe did not return live. */
-    node?: any;
-    now?: () => number;
-}): Record<string, unknown>;
-export declare function finalizeMeshNodeStatus(args: {
-    status: Record<string, unknown>;
-    node: any;
-    daemonId?: string;
-    isSelfNode: boolean;
-    /** True when direct-peer-truth accounting classified this node unavailable. */
-    directTruthUnavailable?: 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
- * 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 { awaitWithWarmupDeadline };
-/**
- * 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';
-    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[];
-}>;
-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;
-    equivalent: boolean;
-    baseHead: string;
-    branchHead: string;
-    mergeBase?: string;
-    mergedTree?: string;
-    expectedPatchId?: string;
-    actualPatchId?: string;
-    durationMs: number;
-    error?: string;
-    stdout?: string;
-    stderr?: string;
-    actionableHint?: MeshRefineSubmoduleConflictHint;
-    /**
-     * Set when a `merge-tree` submodule conflict was reclassified as a trivial
-     * gitlink fast-forward and the gate passed via a synthesized merge tree.
-     */
-    gitlinkTrivialFastForward?: {
-        resolved: boolean;
-        gitlinks: Array<{
-            path: string;
-            baseCommit?: string;
-            branchCommit?: string;
-            fastForward: boolean;
-        }>;
-        reason?: string;
-    };
-};
-type MeshRefineEffectiveDiffSummary = {
-    status: MeshRefineStageStatus;
-    /** True when there is at least one root-tree change between base and branch (incl. gitlink bumps). */
-    hasEffectiveDiff: boolean;
-    baseHead: string;
-    branchHead: string;
-    /** Root-level paths that differ between base and branch (capped). */
-    changedPaths?: string[];
-    /** Submodule paths with uncommitted/divergent commits but NO committed gitlink bump in the root tree. */
-    submoduleHints?: Array<{
-        path: string;
-        reason: string;
-    }>;
-    durationMs: number;
-    error?: string;
-    stdout?: string;
-    stderr?: string;
-};
-type MeshRefineSubmoduleConflictHint = {
-    kind: 'submodule_conflict';
-    message: string;
-    conflicts: Array<{
-        path: string;
-        baseCommit?: string;
-        branchCommit?: string;
-    }>;
-    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
- * running and exiting non-zero. On win32 this is the .cmd-shim case: libuv's
- * spawn search appends only .com/.exe, so a bare `npm`/`npx`/`tsc` (which are
- * .cmd shims) ENOENTs even though it is installed. It carries no stderr, so it
- * must be detected by error.code/syscall, not by string-matching output.
- */
-export declare function isSpawnResolutionError(error: any): boolean;
-export declare function describeSpawnError(error: any, command: string, spawnResolutionFailed: boolean): string;
-export declare function runMeshRefinePatchEquivalenceGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefinePatchEquivalenceSummary>;
-export type MeshWorktreePatchContainmentSummary = {
-    /** True only when merging worktreeHead into ref introduces no new patch. */
-    contained: boolean;
-    ref: string;
-    worktreeHead: string;
-    mergeBase?: string;
-    mergedTree?: string;
-    /** patch-id of (ref -> synthesized merge tree); empty string when nothing new is added. */
-    residualPatchId?: string;
-    durationMs: number;
-    /** Set when the check could not run (treated conservatively as NOT contained). */
-    error?: string;
-};
-/**
- * Patch-equivalence containment check for the worktree force-cleanup convergence
- * guard. Answers a narrower question than {@link runMeshRefinePatchEquivalenceGate}:
- * "are the worktree branch's changes ALREADY present in `ref` (e.g. origin/main),
- * even though the worktree HEAD's commit SHA is not an ancestor of ref?"
- *
- * This is the cherry-pick / squash / rebase case: the same content landed on the
- * default ref under a different commit SHA, so `merge-base --is-ancestor` (the
- * primary cleanup guard) reports the worktree as un-converged and refuses to
- * remove it. Refinery already accepts patch-equivalent landings via merge-tree +
- * patch-id; this brings the same notion of "convergence" to the cleanup guard.
- *
- * Mechanism: synthesize the merge of `worktreeHead` into `ref` (reusing the same
- * trivial-gitlink-fast-forward handling as the refine gate) and compute the
- * patch-id of (ref -> mergedTree). If that residual diff is EMPTY, merging the
- * worktree adds nothing new on top of ref — its changes are already present there
- * and the worktree is safe to remove. A non-empty residual means the worktree
- * still carries content not in ref, so it is NOT contained and must stay blocked.
- *
- * Conservative by construction: any merge-tree / patch-id failure, a genuine
- * (non-trivial) submodule conflict, or any thrown error yields `contained: false`
- * so an exception can never widen the cleanup allow-list.
- */
-export declare function checkWorktreeChangesPatchEquivalentInRef(repoRoot: string, ref: string, worktreeHead: string): Promise<MeshWorktreePatchContainmentSummary>;
-/**
- * No-op guard: detect a "silent no-op" merge before the Refinery merge runs.
- *
- * A silent no-op occurs when the refine target branch's ROOT tree is byte-identical
- * to the merge base (origin/main). This is the trap where a submodule (e.g. oss) has
- * real commits but the root branch never committed the gitlink (oss-pointer) bump, so
- * the root diff Refinery would merge is empty. Merging that produces a merge commit with
- * no content change — reported as "success" while the actual work never reaches main.
- *
- * A committed gitlink bump (the legitimate oss-pointer bump) DOES show up in the root
- * tree diff (as a 160000-mode entry), so this guard does NOT block legitimate refines —
- * it only fires when the root tree diff vs base is COMPLETELY empty.
- *
- * Runs after the patch-equivalence gate; the "already merged via other path" case
- * (branch has real changes already present in base) is handled upstream and never
- * reaches here, so an empty root diff at this point is genuinely a no-op.
- */
-export declare function runMeshRefineEffectiveDiffGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefineEffectiveDiffSummary>;
-/**
- * Result of evaluating whether a `git merge-tree --write-tree` submodule
- * conflict is in fact a trivial gitlink fast-forward that should pass the
- * patch-equivalence gate.
- *
- * `git merge-tree` (and `git merge` with the default recursive strategy)
- * refuses to 3-way merge gitlinks unless the case is "trivial" — and it
- * treats *any* gitlink that differs across merge-base/base/branch as
- * non-trivial, even when the branch-side commit is a strict descendant of the
- * base-side commit (i.e. a real fast-forward). Refinery only ever wants to
- * accept the branch's recorded gitlink, so a fast-forwardable bump is safe to
- * resolve to the branch side without any conflict.
- */
-type GitlinkTrivialFastForwardEvaluation = {
-    /** True only when the merge-tree conflict is *fully* explained by trivial-ff gitlinks. */
-    trivial: boolean;
-    /** Why the evaluation declined to treat the conflict as trivial (set when trivial=false). */
-    reason?: string;
-    /** Per-path detail for the changed gitlinks that were inspected. */
-    gitlinks: Array<{
-        path: string;
-        baseCommit?: string;
-        branchCommit?: string;
-        fastForward: boolean;
-    }>;
-};
-/**
- * Return the changed gitlink paths between base and branch whose advance is a
- * strict fast-forward (the base-side commit is an ancestor of the branch-side
- * commit inside that submodule's repo). These are the paths whose patch-id hunk
- * may legitimately differ when base has advanced the same submodule, so they
- * are safe to exclude from the patch-equivalence comparison. A non-ff (genuinely
- * diverged) gitlink is deliberately excluded from this set so it still fails the
- * gate.
- */
-export declare function collectFastForwardGitlinkPaths(repoRoot: string, baseHead: string, branchHead: string): string[];
-/**
- * Decide whether a merge-tree submodule conflict between base and branch is a
- * trivial gitlink fast-forward (and nothing else).
- *
- * The conflict is treated as trivial ONLY when:
- *   1. at least one changed gitlink exists,
- *   2. every changed gitlink fast-forwards (base-commit is an ancestor of the
- *      branch-commit inside that submodule's repo), and
- *   3. the *only* paths that changed on both sides of the merge (i.e. the paths
- *      that could possibly produce a 3-way conflict — the intersection of
- *      mergeBase→base and mergeBase→branch changes) are gitlinks. Any
- *      overlapping non-gitlink path means a genuine content conflict could be
- *      hiding behind the submodule failure, so we keep the block.
- *
- * If any of these fail, the conflict is left as a genuine block. This never
- * 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 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 * from '../mesh/mesh-node-identity.js';
+export * from '../mesh/mesh-refine-gates.js';
+export * from '../mesh/mesh-coordinator-config.js';
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: {
         includeSessions?: boolean;