@adhdev/daemon-core 0.9.82-rc.41 → 0.9.82-rc.411

package/dist/providers/provider-instance-manager.d.ts

@@ -82,6 +82,20 @@ export declare class ProviderInstanceManager {
      * Called when user changes settings from dashboard.
      */
     updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
+    /** Stamp a mesh assignment on a single instance (used by mesh_send_task
+     *  --direct so the worker's completion event has a coordinator routing
+     *  marker in state.settings). Returns true if the instance existed and
+     *  the stamp was applied. */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+        coordinatorDaemonId?: string;
+        coordinatorSessionId?: string;
+    }): boolean;
+    /** Clear a mesh assignment after the dispatched task reaches a terminal
+     *  state (generating_completed / stopped / failed). */
+    detachMeshAssignmentFromInstance(instanceId: string): boolean;
     refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number;
     /**
     * All terminate

package/dist/providers/provider-instance.d.ts

@@ -11,7 +11,8 @@ import type { ProviderModule, ProviderResumeCapability } from './contracts.js';
 import type { AcpConfigOption, AcpMode, ProviderControlSchema, ProviderSummaryMetadata, SessionCapability } from '../shared-types.js';
 import type { MessageInputSupport } from './provider-input-support.js';
 import type { ChatMessage } from '../types.js';
-export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+import type { InteractivePrompt } from './types/interactive-prompt.js';
+export type ProviderStatus = 'idle' | 'generating' | 'waiting_approval' | 'waiting_choice' | 'error' | 'stopped' | 'starting';
 export interface ProviderRuntimeWriteOwner {
     clientId: string;
     ownerType: 'agent' | 'user';
@@ -42,6 +43,7 @@ export interface ActiveChatData {
         message: string;
         buttons: string[];
     } | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     inputContent?: string;
 }
 /** Standardized error reasons across all provider categories */
@@ -56,6 +58,7 @@ interface ProviderStateBase {
     status: ProviderStatus;
     /** chat data */
     activeChat: ActiveChatData | null;
+    activeInteractivePrompt?: InteractivePrompt | null;
     /** Workspace — project path or name (all categories) */
     workspace?: string | null;
     /** Runtime info (real-time detection) */
@@ -178,8 +181,27 @@ export interface ProviderInstance {
     onEvent(event: string, data?: any): void;
     /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
+    /** Stamp a direct-dispatch mesh task assignment so generating_completed
+     *  events route back to the originating coordinator. Cleared by
+     *  detachMeshAssignment when the task reaches a terminal state. */
+    attachMeshAssignment?(assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+        coordinatorDaemonId?: string;
+        coordinatorSessionId?: string;
+    }): void;
+    detachMeshAssignment?(): void;
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
+    /**
+     * Record that a human is actively attending this session by hand right now
+     * (foreground tab selection, controlbar use, manual approval, terminal
+     * input). Provider-common signal that suppresses auto-approve for a short
+     * window so the user can drive the session manually; background mesh worker
+     * sessions never receive it, so their delegated auto-approve is unaffected.
+     */
+    noteManualInteraction?(now?: number): void;
     /** cleanup */
     dispose(): void;
 }

package/dist/providers/provider-loader.d.ts

@@ -58,7 +58,9 @@ export declare class ProviderLoader {
     /** Inject VersionArchive so resolve() can auto-detect installed versions */
     setVersionArchive(archive: VersionArchive): void;
     private static readonly GITHUB_TARBALL_URL;
+    private static readonly REGISTRY_BASE_URL;
     private static readonly META_FILE;
+    private static readonly REGISTRY_META_FILE;
     private static readonly REPO_PROVIDER_DIRNAME;
     private static readonly SIBLING_MARKER_FILE;
     private static readonly SIBLING_ENV_VAR;
@@ -84,6 +86,7 @@ export declare class ProviderLoader {
          */
         probeStarts?: string[];
     });
+    private migrateMarketplaceDirToExternal;
     private log;
     private debugLog;
     /**
@@ -128,9 +131,12 @@ export declare class ProviderLoader {
     resolveProviderFile(type: string, ...segments: string[]): string | null;
     /**
     * Load all providers (3-tier priority)
-    * 1. .upstream/ (GitHub auto-download — primary source)
-    * 2. User custom (~/.adhdev/providers/ excluding .upstream)
-    * User custom always wins (highest priority).
+    * 1. ~/.adhdev/providers/.upstream/ — official git, auto-synced
+    * 2. ~/.adhdev/external/ — 3rd-party git sources, user-added,
+    *    bundled providers may include arbitrary JS (untrusted by default)
+    * 3. ~/.adhdev/providers/ (excluding .upstream) — user-authored customs,
+    *    always wins
+    * Highest priority listed last (overwrites earlier loads).
     * If .upstream/ is empty, call fetchLatest() before loadAll().
     */
     loadAll(): void;
@@ -295,6 +301,22 @@ export declare class ProviderLoader {
     *
     * @returns Whether an update occurred
     */
+    /**
+     * Sync providers from the ADHDev registry (registry.adhf.dev).
+     *
+     * Downloads only providers whose server checksum differs from the locally
+     * cached checksum. Falls back gracefully to the GitHub tarball path if the
+     * registry is unreachable or returns an unexpected response.
+     *
+     * Returns `{ updated: true }` when at least one provider file changed on disk,
+     * `{ updated: false }` when everything is already current, or
+     * `{ updated: false, error }` when the registry couldn't be reached and we
+     * should proceed to the GitHub tarball fallback.
+     */
+    fetchFromRegistry(): Promise<{
+        updated: boolean;
+        error?: string;
+    }>;
     fetchLatest(): Promise<{
         updated: boolean;
         error?: string;
@@ -305,7 +327,7 @@ export declare class ProviderLoader {
     private copyDirRecursive;
     /** .meta.json save */
     private writeMeta;
-    /** Count provider files (provider.js or provider.json) */
+    /** Count provider files (provider.v1.json or provider.json — at most one per dir). */
     private countProviders;
     /**
     * Get public settings schema for a provider (for dashboard UI rendering)

package/dist/providers/provider-trust.d.ts

@@ -0,0 +1,31 @@
+export type ProviderTrust = 'user-custom' | 'trusted' | 'trusted-with-scripts' | 'external-safe' | 'external-untrusted';
+export type ProviderLayer = 'user' | 'upstream' | 'external';
+export interface ProviderManifestShape {
+    /** Has a `tui` block — SDK builders consume it as code paths. */
+    hasTui: boolean;
+    /** Has a non-empty `overrides` object — JS override paths. */
+    hasOverrides: boolean;
+    /** compatibility[].scriptDir or defaultScriptDir is set — JS scripts dir. */
+    hasScriptDir: boolean;
+}
+/**
+ * Inspect a manifest to decide whether it ships JavaScript hooks.
+ * Cheap; pure; safe to call on every provider load.
+ */
+export declare function inspectManifestShape(manifest: Record<string, unknown>): ProviderManifestShape;
+/**
+ * Classify trust given the layer the provider was loaded from + the
+ * manifest's JS-hook footprint.
+ */
+export declare function classifyTrust(layer: ProviderLayer, shape: ProviderManifestShape): ProviderTrust;
+/**
+ * Returns true when activation should require an explicit user confirm.
+ * Today only `external-untrusted` qualifies; future trust levels may
+ * fold in here.
+ */
+export declare function requiresConfirmation(trust: ProviderTrust): boolean;
+/**
+ * Render a short human-readable rationale for the trust tag. Used by
+ * the dashboard's confirmation modal and the provider catalog tooltip.
+ */
+export declare function describeTrust(trust: ProviderTrust): string;

package/dist/providers/read-chat-contract.d.ts

@@ -1,2 +1,31 @@
 import type { ReadChatResult } from './contracts.js';
+import { CHAT_CONTRACT_VERSION_V1, CHAT_CONTRACT_VERSION_V2, type ChatContractVersion, type ReadChatResultV2 } from './transcript-v2.js';
+/**
+ * Read the producer-declared contract version from a raw read_chat payload.
+ * Returns v1 when absent or unrecognised, so legacy producers keep working
+ * through A1. A2 will tighten this to throw when an unsupported version is
+ * declared.
+ */
+export declare function readPayloadContractVersion(raw: unknown): ChatContractVersion;
+/**
+ * Validate a v2 payload. Thin wrapper around assertReadChatResultV2Payload
+ * that prefixes the contract violation with the caller's source label.
+ */
+export declare function validateReadChatResultV2Payload(raw: unknown, source?: string): ReadChatResultV2;
+/**
+ * Versioned entry point. Routes on the producer-declared contractVersion:
+ *   - v2 → strict v2 validation (transcript-v2.ts invariants)
+ *   - v1 (or absent) → legacy permissive validation
+ *
+ * Callers that have not yet been audited to handle v2 outputs should use
+ * validateReadChatResultPayload directly; that path stays bound to v1 shape
+ * during the A1 transition.
+ */
+export declare function validateReadChatResultPayloadVersioned(raw: unknown, source?: string): {
+    version: typeof CHAT_CONTRACT_VERSION_V1;
+    payload: ReadChatResult & Record<string, unknown>;
+} | {
+    version: typeof CHAT_CONTRACT_VERSION_V2;
+    payload: ReadChatResultV2;
+};
 export declare function validateReadChatResultPayload(raw: unknown, source?: string): ReadChatResult & Record<string, unknown>;

package/dist/providers/sdk/v1/builders/acp/detect-status.d.ts

@@ -0,0 +1,68 @@
+/**
+ * buildDetectStatusFromAcp
+ *
+ * Turns a declarative `acp/session-protocol@1` block into a runtime
+ * `(input: AcpStatusInput) => 'idle' | 'generating' | 'waiting_approval' | null`
+ * function.
+ *
+ * Dispatch order:
+ *   1. Not connected → null (no information available).
+ *   2. Error patterns — checked first; first match returns the declared verdict.
+ *   3. Generating pattern — `generating`.
+ *   4. Idle pattern — `idle`.
+ *   5. Default: `null` (no change — caller preserves last known status).
+ *
+ * All regex patterns are compiled once at builder time so the returned
+ * detector function is allocation-free on the hot path.
+ */
+interface AcpRegexPatternSpec {
+    regex: string;
+    flags?: string;
+    description?: string;
+}
+interface AcpErrorPatternSpec extends AcpRegexPatternSpec {
+    verdict: 'idle' | 'generating' | 'waiting_approval';
+}
+export interface AcpSessionSpec {
+    $schema?: 'adhdev:acp/session-protocol@1';
+    /** Pattern that matches a line emitted when the agent is idle/ready. */
+    idlePattern?: AcpRegexPatternSpec;
+    /** Pattern that matches a line emitted while the agent is actively working. */
+    generatingPattern?: AcpRegexPatternSpec;
+    /**
+     * Error/edge-case patterns. Checked in order; first match returns the
+     * declared verdict. Useful for approval prompts, fatal errors, etc.
+     */
+    errorPatterns?: AcpErrorPatternSpec[];
+    /** Wire format; informational only at the builder level — regex matching
+     *  is identical regardless of promptStyle. */
+    promptStyle?: 'json-rpc' | 'plain-text' | 'mcp';
+    /** Message delimiter used to split incoming bytes (default: newline). */
+    messageDelimiter?: string;
+}
+export interface AcpStatusInput {
+    /** The most recently received line from the stdio stream. */
+    lastLine: string;
+    /**
+     * A sliding window of recent output lines (newest last).
+     * Builders may check these when a single line is not enough for context.
+     */
+    recentLines: string[];
+    /** Whether the ACP process is currently connected and running. */
+    isConnected: boolean;
+}
+export type AcpDetectedStatus = 'idle' | 'generating' | 'waiting_approval' | null;
+interface CompiledAcpSpec {
+    idle: RegExp | null;
+    generating: RegExp | null;
+    errors: Array<{
+        re: RegExp;
+        verdict: AcpDetectedStatus;
+    }>;
+}
+declare function compileSpec(spec: AcpSessionSpec): CompiledAcpSpec;
+export declare function buildDetectStatusFromAcp(spec: AcpSessionSpec): (input: AcpStatusInput) => AcpDetectedStatus;
+export declare const __internal: {
+    compileSpec: typeof compileSpec;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/detect-status.d.ts

@@ -0,0 +1,86 @@
+/**
+ * buildDetectStatusFromTui
+ *
+ * Turns a manifest's declarative TUI block into a runtime
+ * `(input: CliStatusInput) => CliStatus | null` function.
+ *
+ * Inputs handled (all optional except spinner):
+ *   - tui/spinner@1          → contributes `generating`
+ *   - tui/settled-prompt@1   → contributes `idle`
+ *   - tui/modal@1            → contributes `waiting_approval`
+ *
+ * Dispatch order (sprint-2026-06 contract):
+ *   1. Active generation cues win over idle prompt — checked first.
+ *      Reason: codex/claude keep model footer visible during `Working` and
+ *      `hasReadyPrompt` falsely fired idle. Audit §4.2 introduces
+ *      `tui/cue-ordering` as the named primitive for this rule.
+ *   2. Modal cue (if present) is checked next — `waiting_approval`.
+ *   3. Settled-prompt cue — `idle`.
+ *   4. Default: `null` (no change).
+ */
+import type { CliStatusInput, CliDetectStatusFn } from '../../types/cli/index.js';
+import { type VisibleRegionSpec } from './visible-region.js';
+interface RegexLikeSpec {
+    regex: string;
+    flags?: string;
+}
+interface SpinnerPatternSpec extends RegexLikeSpec {
+    description?: string;
+}
+interface SpinnerSpec {
+    $schema: 'adhdev:tui/spinner@1';
+    patterns: SpinnerPatternSpec[];
+    scope?: 'live-frame-tail' | 'whole-screen' | 'recent-buffer';
+    scopeWindowLines?: number;
+}
+interface SettledPromptFooterSpec {
+    pattern: string;
+    kind?: 'substring' | 'regex';
+    flags?: string;
+}
+interface SettledPromptSpec {
+    $schema: 'adhdev:tui/settled-prompt@1';
+    regex: string;
+    flags?: string;
+    withFooter?: SettledPromptFooterSpec[];
+    scope?: 'last-n-lines' | 'whole-screen';
+    scopeWindowLines?: number;
+}
+interface ModalSpec {
+    $schema: 'adhdev:tui/modal@1';
+    questionPattern: string;
+    questionFlags?: string;
+    questionVariants?: Array<{
+        regex: string;
+        flags?: string;
+        label?: string;
+    }>;
+    buttonPattern: string;
+    buttonFlags?: string;
+    buttonLabelGroup?: number;
+}
+export type DispatchGroup = 'spinner' | 'modal' | 'settled-prompt' | 'cue-ordering' | 'error-detection' | 'approval-stitching';
+export interface DispatchOrderSpec {
+    $schema: 'adhdev:tui/dispatch-order@1';
+    order: DispatchGroup[];
+    onNoMatch?: 'idle' | 'unknown' | 'preserve-last';
+}
+export interface DetectStatusTuiSpec {
+    spinner?: SpinnerSpec;
+    settledPrompt?: SettledPromptSpec;
+    modal?: ModalSpec;
+    dispatchOrder?: DispatchOrderSpec;
+    visibleRegion?: VisibleRegionSpec;
+}
+declare function scopeText(input: CliStatusInput, scope: SpinnerSpec['scope'] | SettledPromptSpec['scope'], windowLines: number | undefined): string;
+declare function spinnerMatches(spec: SpinnerSpec, input: CliStatusInput): boolean;
+declare function settledPromptMatches(spec: SettledPromptSpec, input: CliStatusInput): boolean;
+declare function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean;
+export declare function buildDetectStatusFromTui(spec: DetectStatusTuiSpec): CliDetectStatusFn;
+export declare const __internal: {
+    scopeText: typeof scopeText;
+    spinnerMatches: typeof spinnerMatches;
+    settledPromptMatches: typeof settledPromptMatches;
+    modalMatches: typeof modalMatches;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/parse-approval-squash.d.ts

@@ -0,0 +1,59 @@
+/**
+ * buildParseApprovalFromSquash
+ *
+ * Companion to buildParseApprovalFromTui. Handles the squashed-modal case:
+ * the terminal has re-flowed the approval frame so the rendered text is a
+ * single run of lowercase-alnum bytes (e.g. `doyoutrustthecontentsofthisdirectory…1yescontinue2noquit`).
+ *
+ * Author declares:
+ *   - `cues`        — compact substrings/regexes that identify the modal
+ *   - `footers`     — optional compact substrings that must also be present
+ *   - `buttonRules` — compact→labels mappings used to recover button labels
+ *
+ * Returns the same shape as buildParseApprovalFromTui — a CliApprovalModal
+ * (message + buttons) or null when no rule matches. Caller composes the two
+ * builders: try the regular modal first, then fall back to squash. Codex
+ * needs both because at narrow widths the terminal renders the squash form,
+ * and at wider widths it renders the regular framed form.
+ */
+import type { CliApprovalInput, CliParseApprovalFn } from '../../types/cli/index.js';
+interface SquashCueSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+    label?: string;
+    messageWhenMatched?: string;
+}
+interface SquashFooterSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+}
+interface SquashButtonRuleSpec {
+    compact: string;
+    kind?: 'substring' | 'regex';
+    labels: string[];
+}
+export interface ApprovalSquashSpec {
+    $schema: 'adhdev:tui/approval-squash@1';
+    cues: SquashCueSpec[];
+    footers?: SquashFooterSpec[];
+    buttonRules: SquashButtonRuleSpec[];
+    scope?: 'tail-window' | 'whole-screen';
+    tailWindowLines?: number;
+}
+/**
+ * The canonical normalisation. Identical to codex-cli's `compactText`:
+ * lowercase, then strip everything that is not a-z or 0-9.
+ *
+ * Exported for tests and for the (rare) provider that wants to compose this
+ * with extra normalisation steps.
+ */
+export declare function compactText(value: string): string;
+declare function matchSubstringOrRegex(needle: string, kind: 'substring' | 'regex' | undefined, haystack: string): boolean;
+declare function scopeText(spec: ApprovalSquashSpec, input: CliApprovalInput): string;
+export declare function buildParseApprovalFromSquash(spec: ApprovalSquashSpec): CliParseApprovalFn;
+export declare const __internal: {
+    compactText: typeof compactText;
+    matchSubstringOrRegex: typeof matchSubstringOrRegex;
+    scopeText: typeof scopeText;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/parse-approval.d.ts

@@ -0,0 +1,65 @@
+/**
+ * buildParseApprovalFromTui
+ *
+ * Turns a `tui/modal@1` block into a runtime
+ * `(input: CliApprovalInput) => CliApprovalModal | null` function.
+ *
+ * Contract rules enforced (sprint-2026-06):
+ *   - Returns null when the question pattern is not visible.
+ *   - Returns null when the button list is empty or shorter than minButtons.
+ *   - Button labels are raw text; never rewritten (e.g. "Yes, and don't ask
+ *     again for X" stays verbatim).
+ *   - Modal scope respects between-last-two-separators / window-around-question
+ *     / whole-screen to avoid false-positives from numbered lists in
+ *     assistant prose.
+ */
+import type { CliParseApprovalFn } from '../../types/cli/index.js';
+import { type VisibleRegionSpec } from './visible-region.js';
+interface ModalQuestionVariant {
+    regex: string;
+    flags?: string;
+    label?: string;
+}
+interface ModalContextHeader {
+    regex: string;
+    flags?: string;
+}
+export interface ModalTuiSpec {
+    $schema: 'adhdev:tui/modal@1';
+    questionPattern: string;
+    questionFlags?: string;
+    questionVariants?: ModalQuestionVariant[];
+    buttonPattern: string;
+    buttonFlags?: string;
+    buttonLabelGroup?: number;
+    /**
+     * Optional fallback for terminals that render all options on a single line
+     * (e.g. Antigravity feedback survey: `[0] skip [1] yes [2] no [3] still using`).
+     * When per-line button extraction collects fewer than `minButtons`, the
+     * builder makes a second pass with this regex (global match, capture group 1
+     * is the label).
+     */
+    inlineButtonPattern?: string;
+    inlineButtonFlags?: string;
+    scope?: 'between-last-two-separators' | 'window-around-question' | 'whole-screen';
+    scopeWindowLines?: number;
+    contextHeader?: ModalContextHeader;
+    continuationLines?: boolean;
+    minButtons?: number;
+}
+declare function findQuestionLineIndex(spec: ModalTuiSpec, lines: string[]): {
+    index: number;
+    matchedSource: 'primary' | string;
+} | null;
+declare function scopeLines(spec: ModalTuiSpec, lines: string[], questionIndex: number): {
+    start: number;
+    end: number;
+};
+declare function extractButtons(spec: ModalTuiSpec, lines: string[], windowStart: number, windowEnd: number): string[];
+export declare function buildParseApprovalFromTui(spec: ModalTuiSpec, visibleRegion?: VisibleRegionSpec): CliParseApprovalFn;
+export declare const __internal: {
+    findQuestionLineIndex: typeof findQuestionLineIndex;
+    scopeLines: typeof scopeLines;
+    extractButtons: typeof extractButtons;
+};
+export {};

package/dist/providers/sdk/v1/builders/cli/parse-session.d.ts

@@ -0,0 +1,91 @@
+/**
+ * buildParseSessionFromTui — synthesize a parseSession function from the
+ * manifest tui block alone.
+ *
+ * Composition:
+ *   1. detectStatus from tui.spinner/modal/settledPrompt/dispatchOrder
+ *      (delegated to buildDetectStatusFromTui)
+ *   2. parseApproval from tui.modal (delegated to buildParseApprovalFromTui)
+ *   3. message extraction from tui.transcriptPty (this file)
+ *
+ * The result has the same shape as the legacy parse_output:
+ *   { status, messages, activeModal, transcriptAuthority?, coverage?, providerSessionId? }
+ *
+ * Identity stamping (providerUnitKey, bubbleId, sequence, bubbleState) is
+ * applied by the caller, mirroring _shared/parse_session.js. We export the
+ * stamper as `normalizeMessageIdentity` for reuse.
+ */
+import { type ModalTuiSpec } from './parse-approval.js';
+export interface PrefixSpec {
+    regex: string;
+    flags?: string;
+}
+export interface ToolPrefixSpec extends PrefixSpec {
+    skip?: boolean;
+}
+export interface ChromePatternSpec {
+    regex: string;
+    flags?: string;
+    label?: string;
+}
+export interface TranscriptPtySpec {
+    $schema?: 'adhdev:tui/transcript-pty@1';
+    assistantPrefix: PrefixSpec;
+    userPrefix?: PrefixSpec;
+    toolPrefix?: ToolPrefixSpec;
+    continuationLine?: {
+        indented?: boolean;
+    };
+    chromePatterns?: ChromePatternSpec[];
+    stripLeadingChrome?: boolean;
+    scope?: 'screen' | 'buffer' | 'tail';
+}
+export interface SessionIdExtractionSpec {
+    $schema?: 'adhdev:tui/session-id-extraction@1';
+    regex: string;
+    flags?: string;
+    scope?: 'screen' | 'tail' | 'buffer';
+    label?: string;
+}
+export interface ParseSessionTuiSpec {
+    spinner?: any;
+    settledPrompt?: any;
+    modal?: ModalTuiSpec;
+    dispatchOrder?: any;
+    transcriptPty: TranscriptPtySpec;
+    sessionIdExtraction?: SessionIdExtractionSpec;
+}
+export interface SynthesizedMessage {
+    role: 'user' | 'assistant';
+    kind?: 'standard' | 'tool';
+    content: string;
+    receivedAt?: number;
+}
+export interface SynthesizedSession {
+    status: string | null;
+    messages: SynthesizedMessage[];
+    activeModal: {
+        message: string;
+        buttons: string[];
+    } | null;
+    modal: {
+        message: string;
+        buttons: string[];
+    } | null;
+    parsedStatus: string | null;
+    transcriptAuthority?: 'provider' | 'daemon';
+    coverage?: 'full' | 'tail' | 'current-turn';
+    providerSessionId?: string;
+}
+export declare function normalizeMessageIdentity<T extends {
+    role?: string;
+    kind?: string;
+    content?: string;
+}>(messages: T[], status: string): Array<T & {
+    providerUnitKey: string;
+    bubbleId: string;
+    sequence: number;
+    _turnKey: string;
+    bubbleState: 'streaming' | 'final';
+}>;
+export declare function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any) => SynthesizedSession;

package/dist/providers/sdk/v1/builders/cli/visible-region.d.ts

@@ -0,0 +1,42 @@
+/**
+ * applyVisibleRegion
+ *
+ * Scopes the raw terminal text to the "visible region" declared by a
+ * `tui/visible-region@1` spec before handing it to detect-status and
+ * parse-approval matchers.
+ *
+ * Scope semantics:
+ *   screen   → full text unchanged  (daemon already passes rendered screen)
+ *   buffer   → full text unchanged
+ *   tail     → last `tailChars` characters (default 4000)
+ *   between-anchors → text between most recent (or first) top/bottom anchor
+ *                     regex matches; falls back to full text if anchors not found
+ *
+ * selectAnchor:
+ *   "last"  → use the LAST occurrence of the top anchor — useful for providers
+ *             like Antigravity that redraw a separator + prompt on every turn;
+ *             this excludes all scrollback above the current session frame.
+ *   "first" → use the FIRST occurrence (default per schema).
+ */
+interface AnchorPatternSpec {
+    pattern: string;
+    flags?: string;
+}
+interface AnchorsSpec {
+    top?: AnchorPatternSpec;
+    bottom?: AnchorPatternSpec;
+}
+export interface VisibleRegionSpec {
+    $schema?: 'adhdev:tui/visible-region@1';
+    scope: 'screen' | 'tail' | 'buffer' | 'between-anchors';
+    tailChars?: number;
+    anchors?: AnchorsSpec;
+    selectAnchor?: 'first' | 'last';
+    stripCues?: string[];
+}
+/**
+ * Apply the visible-region spec to `text` and return the scoped substring.
+ * Never throws on missing anchors — falls back to the full text instead.
+ */
+export declare function applyVisibleRegion(spec: VisibleRegionSpec, text: string): string;
+export {};