@adhdev/daemon-core 0.9.82-rc.44 → 0.9.82-rc.441

package/dist/cli-adapters/pty-write-chunking.d.ts

@@ -0,0 +1,34 @@
+export declare const WIN32_PTY_WRITE_CHUNK_CHARS = 1024;
+export declare const WIN32_PTY_WRITE_CHUNK_GAP_MS = 8;
+/** Split `text` into chunks of at most `size` UTF-16 units without ever cutting
+ *  between a high and low surrogate (which would corrupt an astral char — emoji,
+ *  etc. — on the UTF-8 PTY write). */
+export declare function chunkPreservingSurrogates(text: string, size: number): string[];
+/** True when a body of `length` UTF-16 units should be paced into multiple
+ *  chunks on win32 rather than written in a single PTY write. */
+export declare function shouldChunkWin32Write(length: number): boolean;
+/**
+ * Drive a paced, surrogate-safe chunked write of `text` over a `write(chunk)`
+ * sink, calling `onChunkWritten` after each chunk (e.g. to advance an input-
+ * activity timestamp) and `onDone` once the final chunk is out. The optional
+ * `setTimer` lets the caller own the timer handle (so it can be cleared on
+ * shutdown) and supply a custom scheduler in tests; it defaults to setTimeout.
+ *
+ * Bodies at or below the chunk threshold are written in a SINGLE write — the
+ * common case — so this is a no-op pacing wrapper for normal-sized prompts.
+ *
+ * Returns the chunks that will be written (useful for assertions/logging).
+ */
+export interface PacedWin32WriteOptions {
+    write: (chunk: string) => void;
+    onChunkWritten?: () => void;
+    onDone?: () => void;
+    /** Schedule the next chunk; must return a handle the caller can clear.
+     *  Defaults to setTimeout. */
+    setTimer?: (fn: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    /** Store the pending timer handle so the caller can clear it on shutdown. */
+    onTimer?: (handle: ReturnType<typeof setTimeout> | null) => void;
+    chunkChars?: number;
+    gapMs?: number;
+}
+export declare function writeWin32Paced(text: string, opts: PacedWin32WriteOptions): string[];

package/dist/cli-adapters/raw-terminal-io.d.ts

@@ -0,0 +1,37 @@
+import { type SessionHostEndpoint, type SessionHostRequest, type SessionHostResponse, type SessionTerminalSnapshot, type SessionTerminalState } from '@adhdev/session-host-core';
+type LowercaseLetter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type FunctionKey = 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12';
+type BaseNamedKey = 'enter' | 'escape' | 'tab' | 'backspace' | 'up' | 'down' | 'left' | 'right' | 'home' | 'end' | 'pageup' | 'pagedown' | 'space' | FunctionKey;
+type ShiftNamedKey = BaseNamedKey | LowercaseLetter | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}`;
+export type NamedKey = BaseNamedKey | `ctrl+${LowercaseLetter}` | `alt+${LowercaseLetter}` | `shift+${ShiftNamedKey}`;
+export declare function namedKeyToAnsi(key: NamedKey | string): string;
+export declare function namedKeysToAnsi(keys: readonly (NamedKey | string)[]): string;
+export interface RawTerminalSessionHostClient {
+    connect(): Promise<void>;
+    request<T = unknown>(request: SessionHostRequest): Promise<SessionHostResponse<T>>;
+    close(): Promise<void>;
+}
+export interface RawTerminalAttachmentOptions {
+    endpoint?: SessionHostEndpoint;
+    sessionId: string;
+    mode?: 'read' | 'write';
+    clientId?: string;
+    client?: RawTerminalSessionHostClient;
+}
+export declare class RawTerminalAttachment {
+    readonly sessionId: string;
+    private readonly clientId;
+    private readonly mode;
+    private readonly client;
+    private closed;
+    private constructor();
+    static attach(options: RawTerminalAttachmentOptions): Promise<RawTerminalAttachment>;
+    readSnapshot(): Promise<SessionTerminalSnapshot>;
+    readScreenText(): Promise<string>;
+    readState(): Promise<SessionTerminalState>;
+    writeInput(text: string): Promise<void>;
+    writeKeys(keys: readonly (NamedKey | string)[]): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function withRawTerminalAttachment<T>(options: RawTerminalAttachmentOptions, operation: (attachment: RawTerminalAttachment) => Promise<T>): Promise<T>;
+export {};

package/dist/cli-adapters/resolve-executable.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Pick the best launch target from `where`'s match list on win32.
+ *
+ * `where npm` on a typical install returns BOTH the extensionless Unix wrapper
+ * (e.g. `C:\Program Files\nodejs\npm`, a bash shell script) AND the `npm.cmd`
+ * shim. The extensionless wrapper is NOT a win32 executable — handing it to a
+ * spawn boundary ENOENTs (errno -4058). So:
+ *   1. Prefer a directly-launchable `.exe`/`.com`.
+ *   2. Otherwise take a `.cmd`/`.bat` shim (absolute → works for ConPTY, and for
+ *      execFile once wrapped via buildWin32ExecFileSpawn).
+ *   3. NEVER fall back to an extensionless match — return null so the caller can
+ *      try other resolution strategies (global-bin scan) rather than emit a
+ *      path that cannot be exec'd.
+ */
+export declare function selectWin32ExecutableMatch(matches: string[]): string | null;
+/**
+ * Resolve a launch command to an absolute executable path on Windows.
+ *
+ * node-pty's ConPTY backend resolves a bare/relative command against the
+ * *calling process's* `Path` env var and — critically — does NOT apply PATHEXT.
+ * So a provider command like `claude` never matches `claude.exe` and the native
+ * layer throws `File not found:` (empty), which crashes the daemon. We resolve
+ * it to an absolute `.exe` here (in the daemon process, which has the full PATH)
+ * before the command ever reaches node-pty.
+ *
+ * No-op on non-Windows and when the command is already an existing absolute path
+ * or cannot be resolved (caller keeps the original behaviour).
+ */
+export declare function resolveWin32Executable(command: string): string;
+/**
+ * Quote one argument for a cmd.exe command line using the standard
+ * CommandLineToArgvW rules (the same algorithm Node uses internally): wrap in
+ * double quotes only when needed, double up the backslashes that precede a
+ * quote, and escape embedded quotes. We do per-argument quoting ourselves
+ * (rather than `{ shell: true }`) because Node's shell mode joins argv with bare
+ * spaces and applies NO quoting — any argument containing a space (a path, a
+ * test name) would split. Inputs here are repo-mesh validation/bootstrap command
+ * tokens (trusted config, not network data), so argv-quoting for spaces/quotes
+ * is sufficient; we deliberately do not attempt full cmd.exe metacharacter
+ * (& | < > ^ %) escaping.
+ */
+export declare function quoteWin32CmdArg(arg: string): string;
+export interface Win32ExecFileSpawn {
+    file: string;
+    args: string[];
+    /** Set when the args are pre-quoted for cmd.exe and must not be re-quoted. */
+    windowsVerbatimArguments?: boolean;
+}
+/**
+ * Build child_process.execFile/spawn parameters for an already-resolved command.
+ *
+ * On win32 a `.cmd`/`.bat` shim (what `npm`/`npx`/`tsc`/`vitest` resolve to)
+ * cannot be launched by execFile directly — modern Node refuses it (CVE-2024-27980
+ * mitigation) and CreateProcess cannot exec a batch file. So wrap it in
+ * `cmd.exe /d /s /c "<quoted command line>"` with `windowsVerbatimArguments` so
+ * our own per-argument quoting is preserved. `.exe`/`.com` (and every non-win32
+ * platform, and any already-cmd.exe target) pass through unchanged — this is a
+ * strict no-op off win32, guarding against regressions on linux/macOS.
+ */
+export declare function buildWin32ExecFileSpawn(resolvedCommand: string, args: string[]): Win32ExecFileSpawn;
+/**
+ * Convenience: resolve a bare command to an absolute win32 path AND build the
+ * execFile spawn parameters (cmd.exe-wrapping a .cmd/.bat shim). Returns the
+ * resolved command alongside the spawn spec so callers can still surface the
+ * resolved path in diagnostics.
+ */
+export declare function resolveWin32ExecFileSpawn(command: string, args: string[]): Win32ExecFileSpawn & {
+    resolvedCommand: string;
+};

package/dist/cli-adapters/terminal-backends/ghostty-vt-backend.d.ts

@@ -1,13 +1,16 @@
-import type { TerminalViewportBackend, TerminalViewportBackendOptions, TerminalViewportBackendPreference } from './types.js';
-export declare function resolveTerminalBackendPreference(): TerminalViewportBackendPreference;
-export declare function isGhosttyVtBackendAvailable(): boolean;
+import type { TerminalViewportBackend, TerminalViewportBackendOptions } from './types.js';
 export declare class GhosttyVtTerminalBackend implements TerminalViewportBackend {
     readonly kind: "ghostty-vt";
     private terminal;
+    private rows;
+    private disposed;
     constructor(options: TerminalViewportBackendOptions);
     resize(rows: number, cols: number): void;
     write(data: string): void;
+    private formatLines;
+    private static trimBlankEnds;
     getText(): string;
+    getTextWithScrollback(): string;
     getCursorPosition(): {
         col: number;
         row: number;

package/dist/cli-adapters/terminal-backends/types.d.ts

@@ -1,5 +1,4 @@
-export type TerminalViewportBackendKind = 'xterm' | 'ghostty-vt';
-export type TerminalViewportBackendPreference = TerminalViewportBackendKind | 'auto';
+export type TerminalViewportBackendKind = 'ghostty-vt';
 export type TerminalViewportBackendOptions = {
     rows: number;
     cols: number;
@@ -10,6 +9,15 @@ export interface TerminalViewportBackend {
     resize(rows: number, cols: number): void;
     write(data: string): void;
     getText(): string;
+    /**
+     * Like getText() but includes scrollback history (the lines that have
+     * scrolled above the visible viewport). Used by content-pattern matching
+     * (e.g. approval/modal button extraction) that must stay correct when a
+     * tall prompt — a big diff or long explanation — pushes part of the
+     * prompt box above the viewport. NOT for cursor-relative / stable_ms
+     * conditions, whose row indices are viewport-relative.
+     */
+    getTextWithScrollback(): string;
     getCursorPosition(): {
         col: number;
         row: number;

package/dist/cli-adapters/terminal-screen.d.ts

@@ -1,29 +1,22 @@
 /**
- * PTY screen snapshot abstraction.
- *
- * Terminal viewport backend selection.
- *
- * Runtime preference is backend-agnostic:
- * - prefer ghostty-vt when available (or when explicitly requested)
- * - fall back to xterm when ghostty-vt is unavailable
+ * PTY screen snapshot abstraction — ghostty-vt backend.
  */
-import type { TerminalViewportBackendKind, TerminalViewportBackendPreference } from './terminal-backends/types.js';
+import type { TerminalViewportBackendKind } from './terminal-backends/types.js';
 export declare function getTerminalBackendRuntimeStatus(): {
     backend: TerminalViewportBackendKind;
-    preference: TerminalViewportBackendPreference;
-    ghosttyAvailable: boolean;
 };
 export declare class TerminalScreen {
     readonly backendKind: TerminalViewportBackendKind;
     private rows;
     private cols;
-    private readonly preference;
     private terminal;
     constructor(rows?: number, cols?: number);
     reset(rows?: number, cols?: number): void;
     resize(rows: number, cols: number): void;
     write(data: string): void;
     getText(): string;
+    /** Full buffer including scrollback history (see backend doc). */
+    getTextWithScrollback(): string;
     getCursorPosition(): {
         col: number;
         row: number;

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,27 +1,14 @@
 /**
  * Chat Commands — readChat, sendChat, listChats, newChat, switchChat,
  *                 setMode, changeModel, setThoughtLevel, resolveAction, chatHistory
+ *
+ * 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.
  */
-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;
-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/cli-manager.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
-import { type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
+import { type MeshCoordinatorDelegatedWorkerIsolation, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { SessionRegistry } from '../sessions/registry.js';
@@ -68,6 +68,7 @@ export interface CoordinatorDelegatedCliLaunchOptionsInput {
     workspace: string;
     cliArgs?: string[];
     env?: Record<string, string>;
+    isolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
 export interface CoordinatorDelegatedCliLaunchOptions {
     cliArgs: string[];
@@ -112,6 +113,19 @@ export declare class DaemonCliManager {
         key: string;
     } | null;
     private findAdapterBySessionId;
+    /**
+     * WTCLAIM (B): resolve the adapter for a mesh dispatch that named a node
+     * (meshContext.nodeId) but carried no explicit session. Matches by the
+     * instance's bound mesh node id (settings.meshNodeId, falling back to the
+     * sticky meshLastNodeId) first, then by the node workspace (workingDir).
+     *
+     * Unlike findAdapter's step-2 fuzzy fallback, this NEVER degrades to a
+     * provider-only first-match: on a daemon hosting BOTH a base node and a
+     * cloned worktree node (same daemonId), that fuzzy match could land a
+     * worktree-targeted task on the base session. Returns null when no session
+     * is bound to this node so the caller fails closed.
+     */
+    private findMeshNodeAdapter;
     handleCliCommand(cmd: string, args: any): Promise<CommandResult | null>;
 }
 export {};

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