@adhdev/daemon-core 0.9.82-rc.45 → 0.9.82-rc.450

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 {};

package/dist/providers/sdk/v1/fixture-tooling/format.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Provider fixture format — v1.
+ *
+ * A fixture is two files committed alongside a provider:
+ *
+ *   fixtures/<scenario>.pty             — raw PTY byte capture (binary or text)
+ *   fixtures/<scenario>.expected.json   — expected handler outputs at one
+ *                                          or more anchor frames
+ *
+ * Scenarios cover one concrete agent behaviour: cold start, prompt sent,
+ * generating with tool call, approval modal, idle after assistant complete,
+ * etc.
+ *
+ * The replay runner feeds the .pty bytes through the daemon's terminal
+ * emulator (TerminalTranscriptAccumulator) building up snapshots at each
+ * declared anchor, invokes the provider handlers, and compares results
+ * to the .expected.json shape.
+ *
+ * This file is the source of truth for the format. Schema mirror at
+ * sdk/v1/schemas/fixture-expected.schema.json.
+ */
+import type { CliApprovalModal, CliChatMessage, CliStatus } from '../types/cli/index.js';
+/**
+ * The top-level shape of <scenario>.expected.json.
+ *
+ * `anchors` is an ordered list; each anchor declares a point in the
+ * PTY stream (by byte offset or by sentinel string) and the expected
+ * handler outputs at that point.
+ */
+export interface FixtureExpected {
+    /** Schema version. Currently always 1. */
+    version: 1;
+    /** Free-form human description of the scenario. */
+    description?: string;
+    /** Provider type this fixture is for. */
+    providerType: string;
+    /** Path (relative to the .expected.json file) of the corresponding .pty file. */
+    ptyFile: string;
+    /** Optional cols/rows the recording was captured under. Defaults to 80x24. */
+    terminal?: {
+        cols: number;
+        rows: number;
+    };
+    /** Anchor points. Order matters; bytes are replayed up to each anchor. */
+    anchors: FixtureAnchor[];
+}
+export interface FixtureAnchor {
+    /** Human-readable identifier. Used in test reporter output. */
+    name: string;
+    /** Optional description. */
+    description?: string;
+    /**
+     * Where to stop replaying bytes. Exactly one of:
+     *   - `untilByte` — stop after the Nth raw byte
+     *   - `untilSentinel` — stop the first time `sentinel` appears in the
+     *     accumulated rendered screen text
+     */
+    untilByte?: number;
+    untilSentinel?: string;
+    /**
+     * Expected handler outputs. All keys optional; the replay runner only
+     * checks the keys you provide.
+     */
+    expect: {
+        detectStatus?: CliStatus | null;
+        parseApproval?: CliApprovalModal | null;
+        parseSession?: {
+            status?: CliStatus;
+            modal?: CliApprovalModal | null;
+            providerSessionId?: string;
+            /**
+             * Either an exact array (deep-equal) or a shape declaration that lets
+             * you match only the role/kind/content shape without pinning specific
+             * fields. Pin specific message-by-message when you care about content.
+             */
+            messages?: CliChatMessage[] | MessageShape[];
+        };
+    };
+    /**
+     * Optional notes about why this anchor exists. Encouraged for
+     * regression-style fixtures so future maintainers know what bug the
+     * fixture catches.
+     */
+    notes?: string;
+}
+/**
+ * A shape declaration that matches a message by role/kind plus optional
+ * content substring or regex. Use this instead of an exact CliChatMessage
+ * when you do not want to pin exact text.
+ */
+export interface MessageShape {
+    role: CliChatMessage['role'];
+    kind?: CliChatMessage['kind'];
+    /** Substring the content must contain. Plain string only. */
+    contentIncludes?: string;
+    /** Regex the content must match. */
+    contentMatches?: {
+        source: string;
+        flags?: string;
+    };
+}
+/**
+ * Result of replaying one anchor — what the handlers actually emitted.
+ * Used by the test runner to produce diff output.
+ */
+export interface AnchorReplayResult {
+    anchor: FixtureAnchor;
+    passes: boolean;
+    diffs: string[];
+    actual: {
+        detectStatus?: CliStatus | null;
+        parseApproval?: CliApprovalModal | null;
+        parseSession?: {
+            status: CliStatus;
+            modal: CliApprovalModal | null;
+            providerSessionId?: string;
+            messages: CliChatMessage[];
+        };
+    };
+}
+export interface FixtureReplayResult {
+    fixturePath: string;
+    expected: FixtureExpected;
+    perAnchor: AnchorReplayResult[];
+    overallPasses: boolean;
+}

package/dist/providers/sdk/v1/fixture-tooling/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fixture tooling — public surface.
+ *
+ * Imported by `adhdev provider test` and by daemon-core's CI regression
+ * suite. Format types and the replay runner are stable v1.
+ */
+export type { FixtureExpected, FixtureAnchor, MessageShape, AnchorReplayResult, FixtureReplayResult, } from './format.js';
+export { loadFixtureExpected, replayFixture, formatReplayReport, type CliProviderHandlers, type ReplayOptions, } from './replay.js';

package/dist/providers/sdk/v1/fixture-tooling/replay.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Fixture replay runner.
+ *
+ * Given a `.pty` byte capture and `.expected.json` declaration, replay the
+ * bytes through the daemon's TerminalTranscriptAccumulator, invoke the
+ * provider handlers at each anchor, and diff against expectations.
+ *
+ * Used by:
+ *   - `adhdev provider test` (daemon-cloud CLI)
+ *   - daemon-core CI suite for production-provider regression tests
+ *   - external authors as `adhdev provider test ./`
+ */
+import { type CliScriptInput as InternalCliScriptInput, type CliStatusInput as InternalCliStatusInput, type CliApprovalInput as InternalCliApprovalInput, type ParsedSession as InternalParsedSession } from '../../../../cli-adapters/provider-cli-shared.js';
+import type { FixtureExpected, FixtureReplayResult } from './format.js';
+export interface CliProviderHandlers {
+    createState?: () => Record<string, unknown>;
+    parseSession: (state: unknown, input: InternalCliScriptInput) => InternalParsedSession;
+    detectStatus: (input: InternalCliStatusInput) => string | null;
+    parseApproval: (input: InternalCliApprovalInput) => {
+        message: string;
+        buttons: string[];
+    } | null;
+    parseOutput?: (state: unknown, input: InternalCliScriptInput) => unknown;
+}
+export interface ReplayOptions {
+    /** Override accumulator dimensions. Defaults to the fixture's terminal block or 80x24. */
+    cols?: number;
+    rows?: number;
+    /** Provided manually (e.g. by tests). Defaults to wall-clock at replay start. */
+    spawnAt?: number;
+}
+export declare function loadFixtureExpected(expectedPath: string): FixtureExpected;
+export declare function replayFixture(expectedPath: string, handlers: CliProviderHandlers, options?: ReplayOptions): FixtureReplayResult;
+/**
+ * Format a result as a human-readable report. Returns the multi-line string;
+ * caller decides whether to print or assert.
+ */
+export declare function formatReplayReport(result: FixtureReplayResult): string;

package/dist/providers/sdk/v1/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Provider SDK — v1 surface.
+ *
+ * Internal consumers (daemon-core) import directly from here.
+ * External consumers (provider authors) import from the npm package
+ * `@adhdev/provider-types` (Apache 2.0), which is extracted from this
+ * source at build time.
+ */
+export * from './types/cli/index.js';
+export * from './types/common/index.js';
+export { buildDetectStatusFromTui, type DetectStatusTuiSpec, } from './builders/cli/detect-status.js';
+export { buildParseApprovalFromTui, type ModalTuiSpec, } from './builders/cli/parse-approval.js';
+export { applyVisibleRegion, type VisibleRegionSpec, } from './builders/cli/visible-region.js';
+export { buildParseApprovalFromSquash, compactText, type ApprovalSquashSpec, } from './builders/cli/parse-approval-squash.js';
+export { buildParseSessionFromTui, normalizeMessageIdentity, type ParseSessionTuiSpec, type TranscriptPtySpec, type SessionIdExtractionSpec, type SynthesizedMessage, type SynthesizedSession, } from './builders/cli/parse-session.js';
+export { buildDetectStatusFromAcp, type AcpSessionSpec, type AcpStatusInput, type AcpDetectedStatus, } from './builders/acp/detect-status.js';
+export { loadFixtureExpected, replayFixture, formatReplayReport, type FixtureExpected, type FixtureAnchor, type MessageShape, type AnchorReplayResult, type FixtureReplayResult, type CliProviderHandlers, type ReplayOptions, } from './fixture-tooling/index.js';
+export { analyzeOverrideTaint, formatTaintResult, type TaintLevel, type TaintCategory, type TaintFinding, type TaintResult, validateCliProviderManifest, formatManifestValidationIssues, type ManifestValidationIssue, type ManifestValidationResult, } from './validators/index.js';
+export declare const V1_PRIMITIVE_CATALOG: Readonly<{
+    readonly acp: readonly ["adhdev:acp/session-protocol@1"];
+    readonly tui: readonly ["adhdev:tui/prompt-marker@1", "adhdev:tui/spinner@1", "adhdev:tui/settled-prompt@1", "adhdev:tui/assistant-block@1", "adhdev:tui/tool-block@1", "adhdev:tui/thinking-block@1", "adhdev:tui/user-echo@1", "adhdev:tui/modal@1", "adhdev:tui/modal-as-message@1", "adhdev:tui/footer-chrome@1", "adhdev:tui/welcome-screen@1", "adhdev:tui/visible-region@1", "adhdev:tui/cue-ordering@1", "adhdev:tui/dispatch-order@1", "adhdev:tui/index-finder@1", "adhdev:tui/status-downgrade@1", "adhdev:tui/approval-stitching@1", "adhdev:tui/approval-squash@1", "adhdev:tui/media-input@1", "adhdev:tui/session-id-extraction@1", "adhdev:tui/error-detection@1"];
+    readonly nativeHistory: readonly ["adhdev:native-history/codex-rollout@1", "adhdev:native-history/claude-jsonl@1", "adhdev:native-history/anthropic-cli-transcript@1", "adhdev:native-history/hermes-session@1"];
+    readonly cliCapability: readonly ["adhdev:cli/capability-list@1", "adhdev:cli/control-state@1", "adhdev:cli/capability-action@1", "adhdev:cli/control-toggle@1", "adhdev:cli/picker-open@1", "adhdev:cli/picker-set@1"];
+    readonly common: readonly ["adhdev:common/setting-boolean@1", "adhdev:common/setting-number@1", "adhdev:common/setting-string@1", "adhdev:common/setting-select@1", "adhdev:common/capability-input@1", "adhdev:common/capability-output@1", "adhdev:common/capability-controls@1", "adhdev:common/auth-env-var@1", "adhdev:common/auth-cli-command@1", "adhdev:common/spawn@1", "adhdev:common/timeouts@1", "adhdev:common/resume@1", "adhdev:common/mesh-coordinator@1"];
+    readonly override: readonly ["adhdev:override/cli-parse-session@1", "adhdev:override/cli-detect-status@1", "adhdev:override/cli-parse-approval@1", "adhdev:override/cli-parse-output@1", "adhdev:override/cli-read-native-history@1", "adhdev:override/cli-list-native-history@1", "adhdev:override/cli-capability-handler@1"];
+}>;
+/** Aggregate flat list — for provider catalog endpoints. */
+export declare const V1_ALL_PRIMITIVES: ReadonlyArray<string>;
+/** Catalog version label exposed at `registry.adhf.dev/primitives`. */
+export declare const V1_CONTRACT_VERSION: "1.0.0";