@adhdev/daemon-core 0.9.82-rc.26 → 0.9.82-rc.260

package/dist/providers/spec/cli-adapter.d.ts

@@ -0,0 +1,102 @@
+import type { CliAdapter, CliAdapterStatus } from '../../cli-adapter-types.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { type InteractivePromptResponse } from '../types/interactive-prompt.js';
+export declare class SpecCliAdapter implements CliAdapter {
+    readonly cliType: string;
+    readonly cliName: string;
+    readonly workingDir: string;
+    /**
+     * Marker the daemon's finalization gate checks: `getStatus()` returns
+     * `messages: []` by design here (chat history lives in the daemon's
+     * native-history pipeline, not the adapter). Without this flag,
+     * cli-provider-instance's `missing_final_assistant` gate would stall
+     * every turn until the 30s safety timeout because it expects the
+     * adapter to surface the final assistant message.
+     */
+    readonly chatMessagesOwnedExternally: true;
+    private driver;
+    /** Common spec fields the adapter reads, present in both v3 and v4. */
+    private spec;
+    private lastEvent;
+    private latestState;
+    private latestModal;
+    private statusCallback;
+    private ptyDataCallback;
+    private partialResponse;
+    private activeInteractivePrompt;
+    private interactivePromptTransport;
+    private claudeTuiPromptCaptureInFlight;
+    private jsonLineTail;
+    private exited;
+    private spawned;
+    private providerSessionId;
+    /** Wall clock at the moment spawn() ran. Used as the cutoff for
+     *  native-history file selection so a prior session's transcript
+     *  can't leak into this session before the agent has written its
+     *  own records. */
+    private spawnedAtMs;
+    /** Env vars the daemon set on the spawned child. Mesh coordinator
+     *  points hermes at a per-coordinator HERMES_HOME so the dashboard's
+     *  native-history reader needs that override to find the right
+     *  state.db; without it the reader sees ~/.hermes/state.db which
+     *  the coordinator-launched hermes never writes to. The choice to
+     *  redirect HERMES_HOME is a workaround for an unresolved hermes
+     *  upstream feature gap (see hermes-agent#23130 — runtime-supplied
+     *  MCP config), so this routing keeps the dashboard honest until
+     *  hermes ships a runtime MCP override. */
+    private spawnedEnv;
+    constructor(specPath: string, workingDir: string, cliArgs: string[], extraEnv: Record<string, string>, transportFactory?: PtyTransportFactory);
+    spawn(): Promise<void>;
+    sendMessage(text: string): Promise<void>;
+    getStatus(): CliAdapterStatus;
+    private maybeRefreshNativeHistory;
+    getScriptParsedStatus(): unknown;
+    getPartialResponse(): string;
+    shutdown(): void;
+    cancel(): void;
+    isProcessing(): boolean;
+    isReady(): boolean;
+    setOnStatusChange(cb: () => void): void;
+    setOnPtyData(cb: (data: string) => void): void;
+    writeRaw(data: string): void;
+    resize(cols: number, rows: number): void;
+    resolveModal(buttonIndex: number): void;
+    resolveAction(data: unknown): Promise<void>;
+    setInteractivePromptResponse(response: InteractivePromptResponse): Promise<void>;
+    isApprovalRecentlyResolved(): boolean;
+    clearHistory(): void;
+    updateRuntimeSettings(): void;
+    setServerConn(): void;
+    /**
+     * Map an invokeScript(name, args) call onto a control_bar entry.
+     *
+     * scriptName is matched against control.id. The control's action.type
+     * drives the dispatch:
+     *
+     *   send_keys     → click_control                   (e.g. stop)
+     *   open_picker   → click_control then resolve when extract_choices
+     *                   surface; choice index comes from args.choiceIndex
+     *                   or args.choice (string label match), defaulting to 0
+     *   attach_image  → attach_image dispatch; expects args.blob (data url
+     *                   or base64) and args.mime
+     *
+     * Callers that pass an unknown control id get a { not_found } response.
+     * No control matched, no driver call — keeps the surface honest.
+     */
+    invokeScript(scriptName: string, args?: Record<string, unknown>): Promise<unknown>;
+    getDebugSnapshot(): unknown;
+    getRuntimeMetadata(): unknown;
+    updateRuntimeMeta(meta?: Record<string, unknown>): void;
+    refreshProviderDefinition(): void;
+    private handleEvent;
+    private detectInteractivePromptFromPtyChunk;
+    private readCurrentScreenSections;
+    private extractProviderSessionIdFromScreen;
+    private readClaudeScreenAssistantMessages;
+    private maybeCaptureClaudeTuiPrompt;
+    private readClaudeTuiHeaders;
+    private captureClaudeTuiPrompt;
+    getDebugState(): Record<string, any>;
+    getTraceState(limit?: number): Record<string, any>;
+    getProviderResolutionMeta(): Record<string, any>;
+}

package/dist/providers/spec/evaluator.d.ts

@@ -0,0 +1,23 @@
+import type { SectionDef, Condition, ExtractTitle, ExtractButtons } from './types.js';
+export interface ResolvedSection {
+    id: string;
+    fromLine: number;
+    toLine: number;
+    text: string;
+}
+export interface TraceEntry {
+    kind: 'section' | 'state_match' | 'state_skip' | 'modal' | 'control' | 'notification' | 'delegate';
+    text: string;
+}
+export declare function resolveSections(sectionsObj: Record<string, SectionDef>, lines: string[]): ResolvedSection[];
+export declare function sectionText(sections: ResolvedSection[], sectionId: string | undefined, fullScreen: string): string;
+export declare function evaluateCondition(cond: Condition, sections: ResolvedSection[], fullScreen: string, cursor: {
+    row: number;
+    col: number;
+} | undefined, prevLines: string[] | undefined, trace: TraceEntry[], stateId: string): boolean;
+export declare function extractTitle(rule: ExtractTitle, sections: ResolvedSection[], fullScreen: string): string | null;
+export declare function extractButtonsFromRule(rule: ExtractButtons, hay: string): {
+    index: number;
+    label: string;
+    key: string;
+}[];

package/dist/providers/spec/fsm-driver.d.ts

@@ -0,0 +1,232 @@
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import { type TraceEntry } from './evaluator.js';
+import { type TransitionEval } from './fsm-evaluator.js';
+export type DashboardEvent = {
+    kind: 'pty_data';
+    chunk: string;
+} | {
+    kind: 'state_changed';
+    state: {
+        id: string;
+        label: string;
+        title: string | null;
+        status: 'idle' | 'generating' | 'approval';
+    };
+    modal: {
+        title: string | null;
+        buttons: {
+            index: number;
+            label: string;
+        }[];
+    } | null;
+    controls: {
+        id: string;
+        label: string;
+        action_type: string;
+    }[];
+} | {
+    kind: 'notification';
+    id: string;
+    title: string;
+    body: string;
+} | {
+    kind: 'delegate';
+    id: string;
+    task: string;
+} | {
+    kind: 'spec_trace';
+    entries: TraceEntry[];
+} | {
+    kind: 'exit';
+    exit_code: number;
+} | {
+    kind: 'spec_error';
+    errors: string[];
+};
+export type DashboardCommand = {
+    kind: 'send_message';
+    text: string;
+} | {
+    kind: 'pty_write';
+    data: string;
+} | {
+    kind: 'click_control';
+    control_id: string;
+    payload?: unknown;
+} | {
+    kind: 'click_modal_button';
+    index: number;
+} | {
+    kind: 'attach_image';
+    blob: string;
+    mime: string;
+} | {
+    kind: 'resize';
+    cols: number;
+    rows: number;
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'shutdown';
+};
+export interface DriverHistoryEntry {
+    stateId: string;
+    label: string;
+    at: number;
+    durationMs: number;
+    reason: string;
+    matchedStateId?: string;
+    matchedRules?: string[];
+    debounceKind?: string;
+    idleHoldMs?: number;
+    busyHoldMs?: number;
+    via?: string;
+}
+export interface ISpecDriver {
+    subscribe(listener: (ev: DashboardEvent) => void): () => void;
+    start(): void;
+    dispatch(cmd: DashboardCommand): void;
+    snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    getScreen(): string;
+    getSpecPath(): string;
+    shutdown(): void;
+    getStateHistory(): ReadonlyArray<DriverHistoryEntry>;
+    getSections(): Array<{
+        id: string;
+        text: string;
+    }> | null;
+    getLastBusyAt(): number;
+    hasIdleHoldPending(): boolean;
+    getCompletionIdleDebounceState(): {
+        active: boolean;
+        ageMs: number;
+        holdMs: number;
+        forceAfterMs: number;
+    } | null;
+    getFsmDebug?(): unknown;
+}
+export interface SpecDriverOpts {
+    specPath: string;
+    workingDir: string;
+    extraEnv?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    hotReload?: boolean;
+    emitTrace?: boolean;
+    transportFactory?: PtyTransportFactory;
+    extraCliArgs?: string[];
+}
+export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
+export declare function guessExt(mime: string): string;
+type HistoryEntry = DriverHistoryEntry;
+export declare class FsmDriver implements ISpecDriver {
+    private readonly opts;
+    private spec;
+    private adapter;
+    private listeners;
+    private currentStateId;
+    private stateEnteredAt;
+    private startedAtMs;
+    private prevScreenLines;
+    /** Per cursor_above region (key: cursor_above, -1 = whole screen) → last
+     *  time that region's content changed. Drives stable_ms conditions. */
+    private regionLastChangedAt;
+    /** Timer that re-runs evaluate() when a time-condition would flip true
+     *  with no PTY frame to trigger it. */
+    private wakeTimer;
+    private currentEval;
+    private stateHistory;
+    private prevStateAt;
+    private readySeenOnce;
+    private pendingSends;
+    private pickerInProgress;
+    private delegateTimers;
+    private specWatcher;
+    /** Last full FSM evaluation, kept for the debugger. */
+    private lastFsmEval;
+    constructor(opts: SpecDriverOpts);
+    subscribe(listener: (ev: DashboardEvent) => void): () => void;
+    start(): void;
+    dispatch(cmd: DashboardCommand): void;
+    snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
+    getScreen(): string;
+    getSpecPath(): string;
+    shutdown(): void;
+    getFsmDebug(): {
+        currentState: string;
+        label: string;
+        stateAgeMs: number;
+        status: string;
+        cursor: {
+            row: number;
+            col: number;
+        };
+        transitions: TransitionEval[];
+    };
+    getStateHistory(): ReadonlyArray<HistoryEntry>;
+    getSections(): Array<{
+        id: string;
+        text: string;
+    }> | null;
+    /** v3-compat shims so the cli-adapter's existing debug snapshot keeps
+     *  working without branching on driver type. */
+    getLastBusyAt(): number;
+    hasIdleHoldPending(): boolean;
+    getCompletionIdleDebounceState(): {
+        active: boolean;
+        ageMs: number;
+        holdMs: number;
+        forceAfterMs: number;
+    } | null;
+    private loadSpecOrThrow;
+    private buildAdapterOpts;
+    private armSpecWatcher;
+    private emitInitialState;
+    private buildClock;
+    private evalFsmNow;
+    private reevaluate;
+    private commitTransition;
+    /** Re-derive the visible modal + controls for the current state and emit a
+     *  state_changed if anything differs from the last emit. */
+    private emitStateChanged;
+    private deriveModal;
+    private deriveTitle;
+    private deriveControls;
+    /** Track which cursor_above regions changed since the previous frame so
+     *  stable_ms conditions can measure quiet time. We record every region
+     *  size referenced by a stable_ms condition in the spec, plus the whole
+     *  screen (-1). */
+    private trackRegionChanges;
+    /** All cursor_above region sizes referenced by stable_ms conditions in the
+     *  current state's outgoing transitions, plus whole-screen. Cached lazily
+     *  per spec load would be nicer but the set is tiny. */
+    private stableRegionSizes;
+    /** Schedule a re-evaluation for the soonest pending time-condition on any
+     *  outgoing transition (elapsed_ms / stable_ms / min_hold_ms). Without
+     *  this, a state whose only exit is time-based would never leave once the
+     *  PTY goes quiet. */
+    private scheduleWakeForState;
+    private maybeMarkReady;
+    private fireNotifications;
+    private armOrCancelDelegateTimers;
+    private fireDelegate;
+    private handleSendMessage;
+    private actuallySendMessage;
+    private handleClickControl;
+    private handleClickModalButton;
+    private handleAttachImage;
+    private tryAdvancePicker;
+    private handleExit;
+    private pushHistory;
+    private specTag;
+    private emit;
+}
+export {};

package/dist/providers/spec/fsm-evaluator.d.ts

@@ -0,0 +1,72 @@
+import type { SectionDef } from './types.js';
+import { type ResolvedSection, type TraceEntry } from './evaluator.js';
+import { type CliSpecV4, type FsmCondition } from './fsm-types.js';
+export interface FsmClock {
+    /** Wall-clock now (ms). Passed in so the evaluator stays pure. */
+    now: number;
+    /** When the current state was entered (ms). */
+    stateEnteredAt: number;
+    /** Last-changed timestamp per cursor_above region. Key = cursor_above
+     *  value (0 / undefined → whole-screen, keyed as -1). Missing key means
+     *  "never observed changing" → treated as stable since stateEnteredAt. */
+    regionLastChangedAt: Map<number, number>;
+}
+/** Per-condition evaluation detail — the debugging payload. */
+export interface CondResult {
+    kind: 'regex' | 'changed' | 'elapsed' | 'stable' | 'all' | 'any' | 'not';
+    result: boolean;
+    detail: string;
+    /** Remaining ms until a time-based condition would flip to true. 0 if
+     *  already true or not applicable. Lets the UI show a countdown. */
+    remainingMs?: number;
+    children?: CondResult[];
+}
+/** One evaluated transition with its full reasoning. */
+export interface TransitionEval {
+    to: string;
+    label: string;
+    /** Did the `from` clause include the current state? (Always true for the
+     *  transitions we return — kept for completeness.) */
+    eligible: boolean;
+    /** min_hold_ms guard satisfied? */
+    holdSatisfied: boolean;
+    holdRemainingMs: number;
+    /** Guard condition result (true if no `when`). */
+    condResult: boolean;
+    cond?: CondResult;
+    /** Overall: would this transition fire? */
+    fires: boolean;
+    priority: number;
+}
+export interface FsmEvaluation {
+    /** Sections resolved from the screen (shared with v3 shape). */
+    sections: ResolvedSection[];
+    /** Every outgoing transition from the current state, priority-ordered,
+     *  each annotated with why it fired or didn't. */
+    transitions: TransitionEval[];
+    /** The transition that fires (first in priority order with fires===true),
+     *  or null to stay in the current state. */
+    fired: TransitionEval | null;
+    /** v3-compatible trace lines for the legacy inspector. */
+    trace: TraceEntry[];
+}
+/**
+ * Evaluate the FSM: given the current state id and screen, return every
+ * outgoing transition annotated with why it fires/doesn't, plus the one that
+ * fires (if any).
+ */
+export declare function evaluateFsm(spec: CliSpecV4, currentStateId: string, screenText: string, cursor: {
+    row: number;
+    col: number;
+} | undefined, prevLines: string[] | undefined, clock: FsmClock): FsmEvaluation;
+/**
+ * Evaluate a single condition against a screen + section map — for the spec
+ * editor's live preview ("does this regex match the current screen right
+ * now?"). Time leaves (elapsed_ms/stable_ms) are evaluated against a synthetic
+ * clock where the state was just entered, so they report their countdown
+ * rather than firing; the preview is about screen-content match, not timing.
+ */
+export declare function evaluateConditionPreview(cond: FsmCondition, sections: Record<string, SectionDef> | undefined, screenText: string, cursor?: {
+    row: number;
+    col: number;
+}): CondResult;

package/dist/providers/spec/fsm-loader.d.ts

@@ -0,0 +1,14 @@
+import { type CliSpecV4 } from './fsm-types.js';
+export interface FsmLoadOk {
+    ok: true;
+    spec: CliSpecV4;
+    sourcePath: string;
+}
+export interface FsmLoadErr {
+    ok: false;
+    errors: string[];
+    sourcePath: string;
+}
+export declare function loadFsmSpec(sourcePath: string): FsmLoadOk | FsmLoadErr;
+/** Pure validator — usable from a "validate before save" API in the panel. */
+export declare function validateFsmSpec(raw: unknown): string[];

package/dist/providers/spec/fsm-types.d.ts

@@ -0,0 +1,91 @@
+import type { RegexCondition, ChangedCondition, Control, NotificationRule, DelegateTrigger, NativeHistoryConfig, SectionDef, ExtractTitle, ExtractButtons } from './types.js';
+/** True once `ms` have elapsed since the current state was entered. */
+export interface ElapsedCondition {
+    elapsed_ms: number;
+}
+/** True once the region `cursor_above` lines above the cursor has been
+ *  unchanged for `ms`. A stability gate — the inverse of a busy signal. */
+export interface StableCondition {
+    stable_ms: number;
+    /** Lines above the cursor that must be stable. Default: whole screen. */
+    cursor_above?: number;
+}
+export interface FsmAllCondition {
+    all: FsmCondition[];
+}
+export interface FsmAnyCondition {
+    any: FsmCondition[];
+}
+/** Negation — true when the inner condition is false. Lets a transition say
+ *  "go busy unless the completion marker is present", etc. */
+export interface FsmNotCondition {
+    not: FsmCondition;
+}
+export type FsmCondition = RegexCondition | ChangedCondition | ElapsedCondition | StableCondition | FsmAllCondition | FsmAnyCondition | FsmNotCondition;
+export interface FsmState {
+    id: string;
+    label: string;
+    /** Exactly one state must be `initial: true` — the state at spawn. */
+    initial?: boolean;
+    /** Modal states (approval/picker) expose modal buttons in the UI and are
+     *  treated as "interesting" — the dashboard surfaces them distinctly. */
+    modal?: boolean;
+    /** Status this state maps to for the dashboard/cli-adapter status field.
+     *  One of: idle | generating | approval. Defaults: modal→approval,
+     *  initial→idle, id==='busy'→generating, else idle. Explicit wins. */
+    status?: 'idle' | 'generating' | 'approval';
+    /** Optional extraction run whenever this state is the committed state —
+     *  used by modal states to surface a title + buttons. */
+    extract?: {
+        title?: ExtractTitle;
+        buttons?: ExtractButtons;
+    };
+}
+export interface FsmTransition {
+    /** Source state id, or list of source ids, or "*" for any state. */
+    from: string | string[];
+    /** Destination state id. */
+    to: string;
+    /** Guard condition. Omitted → always eligible (only gated by `from` +
+     *  min_hold_ms). Evaluated against the current screen + clock. */
+    when?: FsmCondition;
+    /** Minimum time the machine must have been in `from` before this edge can
+     *  fire. Replaces busy_hold_ms / idle_hold_ms (per-edge, not global). */
+    min_hold_ms?: number;
+    /** Higher priority transitions are evaluated first. Default 0. Ties broken
+     *  by declaration order. */
+    priority?: number;
+    /** Human label for the debugger. */
+    label?: string;
+}
+export interface CliSpecV4 {
+    $schema: 'adhdev:cli/spec@4';
+    id: string;
+    name: string;
+    binary: string;
+    spawn_args?: string[];
+    env?: Record<string, string>;
+    cli_version_range?: string;
+    send_message: {
+        submit_key: string;
+        delay_ms_before_submit?: number;
+        delay_ms_per_char?: number;
+    };
+    sections: Record<string, SectionDef>;
+    states: FsmState[];
+    transitions: FsmTransition[];
+    control_bar?: Control[];
+    notifications?: NotificationRule[];
+    delegate?: DelegateTrigger[];
+    native_history?: NativeHistoryConfig;
+    requiresFinalAssistantBeforeIdle?: boolean;
+}
+export declare function isV4Spec(raw: unknown): raw is CliSpecV4;
+export declare function initialState(spec: CliSpecV4): FsmState;
+export declare function stateById(spec: CliSpecV4, id: string): FsmState | undefined;
+/** Outgoing transitions from `stateId`, highest priority first, declaration
+ *  order as tiebreak. Includes wildcard ("*") and list-membership sources. */
+export declare function outgoingTransitions(spec: CliSpecV4, stateId: string): FsmTransition[];
+/** Map a state to the dashboard status string, applying the documented
+ *  defaults when `status` is not explicit. */
+export declare function statusForState(state: FsmState): 'idle' | 'generating' | 'approval';

package/dist/providers/spec/native-history-executor.d.ts

@@ -0,0 +1,41 @@
+import type { NativeHistoryConfig } from './types.js';
+export interface NativeHistoryInput {
+    agentType?: string;
+    sessionId?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
+    workspace?: string;
+    /** Daemon-side wall clock at the moment the session was registered.
+     *  Native-history file lookups use this as the lower bound: any file
+     *  whose mtime is before the current session started can't be from
+     *  this session, so it's excluded from newest-recent matching. The
+     *  caller (chat-history pipeline) populates this from the session
+     *  registry; specs/executor never need to know how it's sourced. */
+    sessionStartedAtMs?: number;
+    /** Env overrides the daemon set on the spawned CLI. The mesh
+     *  coordinator points hermes at a per-coordinator HERMES_HOME so
+     *  the hermes process writes its state.db into a tmp directory
+     *  instead of ~/.hermes. expandPath consults this map before
+     *  process.env so the native-history reader follows the spawned
+     *  child's view of HERMES_HOME / similar overrides; without it
+     *  the reader would always look at ~/.hermes and miss every
+     *  coordinator-session transcript. */
+    envOverrides?: Record<string, string>;
+    args?: Record<string, unknown>;
+}
+export interface NativeHistoryMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    receivedAt: number;
+    kind?: string;
+    workspace?: string;
+}
+export interface NativeHistoryResult {
+    messages: NativeHistoryMessage[];
+    providerSessionId?: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage?: 'full' | 'partial' | 'best-effort';
+    workspace?: string;
+}
+export declare function executeNativeHistory(cfg: NativeHistoryConfig, input: NativeHistoryInput): NativeHistoryResult | null;

package/dist/providers/spec/route.d.ts

@@ -0,0 +1,4 @@
+import type { CliProviderModule } from '../../cli-adapters/provider-cli-adapter.js';
+import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
+import type { CliAdapter } from '../../cli-adapter-types.js';
+export declare function createCliAdapter(provider: CliProviderModule, workingDir: string, cliArgs: string[], extraEnv: Record<string, string>, transportFactory?: PtyTransportFactory): CliAdapter;