@adhdev/daemon-core 0.9.82-rc.17 → 0.9.82-rc.170

package/dist/cli-adapters/provider-cli-adapter.d.ts

@@ -14,29 +14,30 @@
  *   compatibility: [{ ideVersion, scriptDir }]  ← versioned scripts
  */
 import type { CliAdapter } from '../cli-adapter-types.js';
+import type { InteractivePromptResponse } from '../providers/types/interactive-prompt.js';
 import { type PtyRuntimeMetadata, type PtyTransportFactory } from './pty-transport.js';
-import { type CliProviderModule, type CliScripts, type CliSessionStatus } from './provider-cli-shared.js';
+import { type CliProviderModule, type CliScripts, type CliSessionStatus, type CliTraceEntry, type ParsedSession } from './provider-cli-shared.js';
+import { CliStateEngine, type CliBufferSnapshot } from './cli-state-engine.js';
+import { type TurnParseScope } from './provider-cli-parse.js';
 import { type ProviderResolutionMeta } from './provider-cli-config.js';
 export { normalizeCliProviderForRuntime, type CliApprovalInput, type CliChatMessage, type CliProviderModule, type CliScreenLine, type CliScreenSnapshot, type CliScriptInput, type CliScripts, type CliSessionStatus, type CliStatusInput, type CliTraceEntry, } from './provider-cli-shared.js';
 export declare function appendBoundedText(current: string, chunk: string, maxChars: number): string;
 export declare class ProviderCliAdapter implements CliAdapter {
     private extraArgs;
     private extraEnv;
-    readonly cliType: string;
+    cliType: string;
     readonly cliName: string;
     workingDir: string;
     private provider;
     private ptyProcess;
     private transportFactory;
-    private currentStatus;
     private onStatusChange;
+    readonly engine: CliStateEngine;
     private responseBuffer;
     private recentOutputBuffer;
-    private isWaitingForResponse;
-    private activeModal;
-    private parseErrorMessage;
+    private get parseErrorMessage();
+    private providerSessionId;
     private responseTimeout;
-    private idleTimeout;
     private ready;
     private startupBuffer;
     private startupParseGate;
@@ -57,28 +58,32 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private lastScreenSnapshotReadAt;
     private serverConn;
     private logBuffer;
-    private lastApprovalResolvedAt;
-    private approvalTransitionBuffer;
-    private approvalExitTimeout;
-    private pendingScriptStatus;
-    private pendingScriptStatusSince;
-    private pendingScriptStatusTimer;
-    private settleTimer;
-    private settledBuffer;
-    private submitPendingUntil;
-    private responseSettleIgnoreUntil;
-    private responseEpoch;
+    private pendingOutboundQueue;
+    private pendingOutboundFlushTimer;
+    private pendingOutboundFlushInFlight;
     private submitRetryTimer;
-    private submitRetryUsed;
-    private submitRetryPromptSnippet;
-    private idleFinishCandidate;
-    private finishRetryTimer;
-    private finishRetryCount;
     private resizeSuppressUntil;
-    private statusHistory;
-    private cliScripts;
-    /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
-    private scriptState;
+    private readonly runner;
+    /** @deprecated use runner.cliScripts for direct script access */
+    get cliScripts(): CliScripts;
+    /**
+     * Recent script invocations (oldest → newest). Exposed via the
+     * `get_chat_debug_bundle` daemon command so anyone debugging a
+     * stuck-status regression can read what each detectStatus /
+     * parseSession call actually saw and returned, instead of having
+     * to instrument the daemon.
+     */
+    getScriptInvocationTrace(): import("./cli-script-runner.js").CliScriptInvocationTrace[];
+    /**
+     * Returns the full raw PTY byte stream captured since adapter start.
+     * Used by the `record_provider_pty` IPC command to produce fixtures.
+     * Bounded by MAX_ACCUMULATED_BUFFER; older bytes may have been dropped.
+     */
+    getAccumulatedRawBuffer(): {
+        text: string;
+        droppedChars: number;
+    };
+    set cliScripts(scripts: CliScripts);
     private runtimeSettings;
     /** Full accumulated rendered PTY transcript for parser/readback use */
     private accumulatedBuffer;
@@ -98,16 +103,9 @@ export declare class ProviderCliAdapter implements CliAdapter {
      *  Hermes turn (tool calls + reasoning + final bubble) without the
      *  rolling window pushing the turn's ╭─ opening line out of view. */
     private static readonly MAX_ACCUMULATED_BUFFER;
-    private currentTurnScope;
-    private traceEntries;
-    private traceSeq;
-    private traceSessionId;
     private parsedStatusCache;
     private static readonly SCREEN_SNAPSHOT_MIN_INTERVAL_MS;
-    private static readonly MAX_TRACE_ENTRIES;
     private readonly providerResolutionMeta;
-    private static readonly FINISH_RETRY_DELAY_MS;
-    private static readonly MAX_FINISH_RETRIES;
     private getBufferState;
     private recordBoundedAppendDrop;
     private readTerminalScreenText;
@@ -120,18 +118,12 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private shouldUseFullProviderTranscriptContext;
     private getIdleFinishConfirmMs;
     private getStatusActivityHoldMs;
-    private setStatus;
-    private clearIdleFinishCandidate;
-    private armIdleFinishCandidate;
-    private recordTrace;
-    private resetTraceSession;
     private readonly timeouts;
     private readonly approvalKeys;
     private readonly sendDelayMs;
     private readonly sendKey;
     private readonly submitStrategy;
     private readonly requirePromptEchoBeforeSubmit;
-    private static readonly SCRIPT_STATUS_DEBOUNCE_MS;
     constructor(provider: CliProviderModule, workingDir: string, extraArgs?: string[], extraEnv?: Record<string, string>, transportFactory?: PtyTransportFactory);
     /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
     setCliScripts(scripts: CliScripts): void;
@@ -146,29 +138,15 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private handleOutput;
     private resolveStartupState;
     private scheduleStartupSettleCheck;
-    private scheduleSettle;
-    private armApprovalExitTimeout;
-    private shouldRetryFinishResponse;
-    private hasRecentInteractiveActivity;
-    private shouldDeferIdleTimeoutFinish;
     private waitForInteractivePrompt;
     private clearAllTimers;
-    private clearStaleIdleResponseGuard;
-    private hasMeaningfulResponseBuffer;
-    private evaluateSettled;
-    private applyPendingScriptStatusDebounce;
-    private applyHoldGenerating;
-    private applyWaitingApproval;
-    private applyGenerating;
-    private applyIdle;
-    private finishResponse;
-    private maybeCommitVisibleIdleTranscript;
-    private commitCurrentTranscript;
-    private invokeCliScript;
-    private runParseSession;
-    private runDetectStatus;
-    private runParseApproval;
-    private hasActionableApproval;
+    runParseSession(): ParsedSession | null;
+    runDetectStatus(text: string): string | null;
+    runParseApproval(tail: string): {
+        message: string;
+        buttons: string[];
+    } | null;
+    private applyParsedSessionMetadata;
     private projectEffectiveStatus;
     getStatus(options?: {
         allowParse?: boolean;
@@ -187,7 +165,9 @@ export declare class ProviderCliAdapter implements CliAdapter {
      * Uses resolveAction script if available, otherwise falls back to standard text.
      */
     resolveAction(data: any): Promise<void>;
+    setInteractivePromptResponse(_response: InteractivePromptResponse): Promise<void>;
     private isSubmitStuck;
+    private hasMeaningfulResponseBufferLocal;
     private writeToPty;
     private resetPendingSendState;
     private commitSendUserTurn;
@@ -198,7 +178,15 @@ export declare class ProviderCliAdapter implements CliAdapter {
     private submitSendKey;
     private submitImmediatePrompt;
     private waitForEchoAndSubmit;
-    sendMessage(text: string): Promise<void>;
+    sendMessage(text: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    forceSendMessage(text: string): Promise<void>;
+    private enqueuePendingOutboundMessage;
+    private shouldQueuePendingOutboundMessage;
+    private schedulePendingOutboundFlush;
+    private flushPendingOutboundQueue;
+    private sendMessageNow;
     getPartialResponse(): string;
     getDebugSnapshot(): Record<string, unknown>;
     getRuntimeMetadata(): PtyRuntimeMetadata | null;
@@ -211,8 +199,63 @@ export declare class ProviderCliAdapter implements CliAdapter {
     clearHistory(): void;
     isProcessing(): boolean;
     isReady(): boolean;
-    writeRaw(data: string): Promise<void>;
+    get currentStatus(): CliSessionStatus['status'];
+    set currentStatus(v: CliSessionStatus['status']);
+    get isWaitingForResponse(): boolean;
+    set isWaitingForResponse(v: boolean);
+    get activeModal(): {
+        message: string;
+        buttons: string[];
+    } | null;
+    set activeModal(v: {
+        message: string;
+        buttons: string[];
+    } | null);
+    get currentTurnScope(): TurnParseScope | null;
+    set currentTurnScope(v: TurnParseScope | null);
+    get responseEpoch(): number;
+    set responseEpoch(v: number);
+    get submitRetryUsed(): boolean;
+    set submitRetryUsed(v: boolean);
+    get submitRetryPromptSnippet(): string;
+    set submitRetryPromptSnippet(v: string);
+    get responseSettleIgnoreUntil(): number;
+    set responseSettleIgnoreUntil(v: number);
+    get submitPendingUntil(): number;
+    set submitPendingUntil(v: number);
+    get lastApprovalResolvedAt(): number;
+    set lastApprovalResolvedAt(v: number);
+    get providerErrorMessage(): string | null;
+    get providerErrorReason(): string | null;
+    get pendingScriptStatus(): 'generating' | 'waiting_approval' | null;
+    get pendingScriptStatusSince(): number;
+    get finishRetryCount(): number;
+    set finishRetryCount(v: number);
+    get traceSessionId(): string;
+    get traceEntries(): CliTraceEntry[];
+    get statusHistory(): {
+        status: string;
+        at: number;
+        trigger?: string;
+    }[];
+    get traceSeq(): number;
+    /** Expose engine's evaluateSettled for test access */
+    evaluateSettled(): void;
+    /** Expose engine's scheduleSettle for test access */
+    scheduleSettle(): void;
+    /** Expose engine's clearIdleFinishCandidate for test access */
+    clearIdleFinishCandidate(reason: string): void;
+    /** Expose engine's finishResponse for test access */
+    finishResponse(): void;
+    /** Returns a point-in-time snapshot of all buffer/screen state for external consumers (e.g. CliStateEngine). */
+    getSnapshot(): CliBufferSnapshot;
+    isAlive(): boolean;
+    flushOutboundQueue(): void;
+    writeRaw(data: string | Buffer): Promise<void>;
     resolveModal(buttonIndex: number): void;
+    getApprovalKeyForIndex(buttonIndex: number): string | undefined;
+    /** Returns true if an approval was resolved within the adapter's cooldown window. */
+    isApprovalRecentlyResolved(): boolean;
     resize(cols: number, rows: number): void;
     private getParsedDebugState;
     getDebugState(): Record<string, any>;

package/dist/cli-adapters/provider-cli-parse.d.ts

@@ -15,11 +15,15 @@ export declare function buildCliParseInput(options: {
     accumulatedRawBuffer: string;
     recentOutputBuffer: string;
     terminalScreenText: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     baseMessages: CliChatMessage[];
     partialResponse: string;
     isWaitingForResponse?: boolean;
     scope?: TurnParseScope | null;
     runtimeSettings: Record<string, any>;
+    spawnAt?: number;
 }): CliScriptInput;
 export declare function summarizeCliTraceText(text: string, max?: number): string;
 export declare function summarizeCliTraceMessages(messages: CliChatMessage[], limit?: number): {

package/dist/cli-adapters/provider-cli-shared.d.ts

@@ -1,6 +1,7 @@
 import type { ProviderResumeCapability } from '../providers/contracts.js';
 import type { ChatMessageKind } from '../providers/chat-message-normalization.js';
 import type { ChatBubbleState } from '../types.js';
+import type { InteractivePrompt } from '../providers/types/interactive-prompt.js';
 import { sanitizeSpawnEnv } from './spawn-env.js';
 export interface CliChatMessage {
     role: string;
@@ -26,8 +27,18 @@ export interface CliSessionStatus {
         message: string;
         buttons: string[];
     } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
+    pendingOutboundCount?: number;
+    pendingOutboundMessages?: Array<{
+        id: string;
+        role: 'user';
+        content: string;
+        queuedAt: number;
+        source: string;
+    }>;
     errorMessage?: string;
     errorReason?: string;
+    providerSessionId?: string;
     bufferState?: {
         responseBuffer?: {
             truncated: boolean;
@@ -59,6 +70,9 @@ export interface ParsedSession {
         buttons: string[];
     } | null;
     parsedStatus: string | null;
+    errorMessage?: string;
+    errorReason?: string;
+    providerSessionId?: string;
     transcriptAuthority?: 'provider' | 'daemon';
     coverage?: 'full' | 'tail' | 'current-turn';
 }
@@ -112,6 +126,10 @@ export interface CliScriptInput {
     rawBuffer: string;
     recentBuffer: string;
     screenText: string;
+    workspace?: string;
+    workingDir?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
     screen: CliScreenSnapshot;
     bufferScreen: CliScreenSnapshot;
     recentScreen: CliScreenSnapshot;
@@ -121,6 +139,7 @@ export interface CliScriptInput {
     promptText?: string;
     settings?: Record<string, any>;
     args?: Record<string, any>;
+    spawnAt?: number;
 }
 export interface CliStatusInput {
     tail: string;
@@ -158,16 +177,26 @@ export interface CliProviderModule {
     binary: string;
     approvalKeys?: Record<number, string>;
     sendDelayMs?: number;
+    /** Wall-clock budget (ms) for a single provider script invocation. Default 50. Range 1..5000.
+     *  Exceeding the budget records `timedOut: true` on the invocation trace and emits a
+     *  throttled WARN — it does NOT abort the script (Node CJS can't interrupt sync code). */
+    scriptCallBudgetMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
     /** Require the typed prompt to be visible on the PTY screen before sending Enter. */
     requirePromptEchoBeforeSubmit?: boolean;
     /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
     allowInputDuringGeneration?: boolean;
+    /** When true, only transition to idle after the parsed transcript includes a final standard assistant message. */
+    requiresFinalAssistantBeforeIdle?: boolean;
+    /** When true, allow providers to augment stale snapshot data before parse. Reserved for future use. */
+    augmentStaleSnapshot?: boolean;
     /** When provider-owned, daemon treats provider parser output as canonical transcript authority. */
     transcriptAuthority?: 'provider' | 'daemon';
     /** Full context lets provider-owned parsers canonicalize retained history instead of daemon prefix stitching. */
     transcriptContext?: 'full' | 'tail';
+    /** v1 declarative tui block — used by CliScriptRunner to synthesize SDK helpers (declarativeDetectStatus, declarativeParseApproval). */
+    tui?: Record<string, unknown>;
     scripts?: CliScripts;
     spawn: {
         command: 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/commands/handler.d.ts

@@ -104,7 +104,117 @@ export declare class DaemonCommandHandler implements CommandHelpers {
     setAgentStreamManager(manager: DaemonAgentStreamManager): void;
     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/mesh-coordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js';
+import type { MeshCoordinatorMcpConfigFormat, MeshCoordinatorSystemPromptInjection, ProviderModule } from '../providers/contracts.js';
 export interface MeshCoordinatorMcpServerLaunch {
     command: string;
     args: string[];
@@ -42,3 +42,74 @@ export interface ResolveMeshCoordinatorSetupOptions {
 }
 export declare function createHermesManualMeshCoordinatorSetup(meshId: string, workspace: string): MeshCoordinatorSetup;
 export declare function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup;
+/**
+ * Apply a provider's declared system-prompt injection rule, mutating `cliArgs`
+ * and `launchEnv` in place and writing any required workspace context file.
+ *
+ * Replaces the previous hard-coded `if (cliType === 'claude-cli') ... else if
+ * (cliType === 'hermes-cli') ...` branches in router.ts. Adding a new CLI is
+ * now provider.v1.json data, not a router edit.
+ *
+ * Failures are non-fatal: log and continue with whatever was applied so the
+ * coordinator session still launches, just without the prompt for that
+ * provider. A missing/unknown rule means "skip injection" — safe by default
+ * (the previous fallback unconditionally pushed --append-system-prompt onto
+ * every non-Claude CLI, which crashed agy on launch).
+ */
+export interface CoordinatorInjectionEffect {
+    /** Absolute path the daemon wrote a wrapper-blocked file to. Only set for
+     *  context_file injection. R48 schedules a strip after launch so workers
+     *  don't see the wrapper on disk; R47's unregister cleanup uses it as a
+     *  fallback if the timer never fires (process crash, etc). */
+    contextFilePath?: string;
+}
+export declare function applyMeshCoordinatorSystemPromptInjection(systemPrompt: string, injection: MeshCoordinatorSystemPromptInjection | undefined, ctx: {
+    cliArgs: string[];
+    launchEnv: Record<string, string>;
+    workspace: string;
+    cliType: string;
+}): CoordinatorInjectionEffect;
+/**
+ * Strip the daemon's wrapper block from a context_file we previously wrote.
+ *
+ * Used in two places:
+ *   1. R48 inject-then-remove: ~5s after spawn, after agy/gemini have read
+ *      the file into their in-memory system-prompt cache. Removing it from
+ *      disk at that point doesn't affect the running coordinator but keeps
+ *      worker sessions (or fresh non-coordinator launches) in the same
+ *      workspace from picking up our wrapper.
+ *   2. R47 unregister fallback: if the timer never fires (process crash,
+ *      kill -9), coordinator-registry.unregisterMeshCoordinator runs the
+ *      same logic when its entry is dropped.
+ *
+ * Idempotent: missing file is fine, missing sentinels are fine, returns
+ * silently. Leaves user-authored content outside the sentinels intact.
+ * Deletes the file outright if our wrapper was the only content.
+ */
+export declare function stripCoordinatorWrapperFile(filePath: string): void;
+export interface PtyExecResult {
+    exitCode: number | null;
+    signal: number | null;
+    output: string;
+    timedOut: boolean;
+}
+/**
+ * Run a one-shot CLI command under a real PTY and collect its output.
+ *
+ * Some provider mcp-registration commands (`agy mcp add`, future bubbletea
+ * TUIs) refuse to run without `/dev/tty`. Daemon-side `execFileSync` runs
+ * pipe-only, so those commands fail with errors like
+ *   `bubbletea: error opening TTY: open /dev/tty: device not configured`
+ * and silently skip the registration, leaving the launched session
+ * without the adhdev-mesh MCP tools — which is exactly what we saw with
+ * agy coordinators.
+ *
+ * Wrapping the registration through node-pty gives the child a real PTY,
+ * so the bubbletea check passes. We close stdin immediately and just
+ * collect stdout until the process exits or the timeout fires.
+ */
+export declare function execUnderPty(command: string, args: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}): Promise<PtyExecResult>;

package/dist/commands/router.d.ts

@@ -74,6 +74,8 @@ export interface CommandRouterDeps {
     sessionHostControl?: SessionHostControlPlane | null;
     /** Selected-coordinator mesh peer telemetry surface for target daemons, when supported by the runtime. */
     getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
+    /** Dispatch a command to a remote mesh node via P2P/relay. Injected by cloud runtime; absent in standalone. */
+    dispatchMeshCommand?: (daemonId: string, cmd: string, args: Record<string, unknown>) => Promise<unknown>;
 }
 export interface CommandRouterResult {
     success: boolean;
@@ -85,9 +87,22 @@ export declare class DaemonCommandRouter {
      *  Allows the MCP server to query mesh data via get_mesh even when
      *  the mesh doesn't exist in the local meshes.json file. */
     private inlineMeshCache;
+    /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+    private aggregateMeshStatusCache;
+    /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
+    private runningRefineJobs;
+    /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
+    private terminalRefineJobs;
     constructor(deps: CommandRouterDeps);
+    private cloneJsonValue;
+    private hydrateCachedAggregateMeshStatusFromInline;
+    private getCachedAggregateMeshStatus;
+    private rememberAggregateMeshStatus;
     getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined;
+    private warmInlineMeshCache;
     private getMeshForCommand;
+    private invalidateAggregateMeshStatus;
+    private requireMeshHostMutationOwner;
     private updateInlineMeshNode;
     private removeInlineMeshNode;
     private normalizeMeshSessionCleanupMode;
@@ -110,6 +125,13 @@ export declare class DaemonCommandRouter {
      * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
      */
     execute(cmd: string, args: any, source?: string): Promise<CommandRouterResult>;
+    private buildRefineJobKey;
+    private buildRefineJobHandle;
+    private queueRefineJobEvent;
+    private appendRefineJobLedger;
+    private executeMeshRefineNodeSynchronously;
+    private finishMeshRefineJob;
+    private startMeshRefineJob;
     /**
      * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
      * Returns null if not handled at this level → caller delegates to CommandHandler.

package/dist/config/chat-history.d.ts

@@ -110,12 +110,19 @@ export declare function readProviderChatHistory(agentType: string, options?: {
     excludeRecentCount?: number;
     historyBehavior?: ProviderHistoryBehavior;
     scripts?: ProviderNativeHistoryScripts;
+    excludeInProgressTurn?: boolean;
+    sessionStartedAtMs?: number;
+    envOverrides?: Record<string, string>;
 }): {
     messages: HistoryMessage[];
     hasMore: boolean;
     source: 'provider-native' | 'adhdev-mirror' | 'native-unavailable';
     sourcePath?: string;
     sourceMtimeMs?: number;
+    providerSessionId?: string;
+    nativeHistoryCoverage?: string;
+    partialReason?: string;
+    unavailableReason?: string;
 };
 export declare function listProviderHistorySessions(agentType: string, options?: {
     canonicalHistory?: ProviderCanonicalHistoryConfig;

package/dist/config/config.d.ts

@@ -86,6 +86,11 @@ export declare function isStableMachineId(machineId?: string | null): boolean;
  * Get the config directory path
  */
 export declare function getConfigDir(): string;
+/**
+ * Get the daemon runtime data directory (~/.adhdev/daemon/).
+ * Distinct from the user-config dir so runtime state can be cleared independently.
+ */
+export declare function getDaemonDataDir(): string;
 /**
  * Load configuration from disk
  */