@adhdev/daemon-core 0.9.82-rc.16 → 0.9.82-rc.161

package/dist/providers/contracts.d.ts

@@ -10,6 +10,14 @@ import type { ProviderSummaryMetadata } from '../shared-types.js';
 import type { ChatMessageKind } from './chat-message-normalization.js';
 export type ReadChatTurnStatus = 'open' | 'waiting_approval' | 'complete' | 'error';
 export interface ReadChatResult {
+    /**
+     * Declared chat contract version. Absent or `'1.0'` → legacy v1 payload
+     * (current shape). `'2.0'` → v2 payload conforming to transcript-v2.ts
+     * (ReadChatResultV2). Validators in read-chat-contract.ts route on this
+     * field. A1 only adds the field; A2 will make v2 the daemon-internal
+     * canonical form and reject unrecognised versions at provider load time.
+     */
+    contractVersion?: import('./transcript-v2.js').ChatContractVersion;
     messages: ChatMessage[];
     status: AgentStatus;
     activeModal?: ModalInfo | null;
@@ -297,7 +305,55 @@ export interface ProviderMeshCoordinatorConfig {
         /** Copyable setup template. Supports {{meshId}}, {{adhdevMcpCommand}}, {{workspace}}, {{serverName}}. */
         template?: string;
     };
+    /**
+     * How the coordinator system prompt reaches the launched CLI. Replaces the
+     * old hard-coded `if (cliType === 'claude-cli') push --append-system-prompt`
+     * branches in router.ts: a new CLI now ships its injection rule in its
+     * provider.v1.json, no daemon code change needed. Users can override the
+     * rendered prompt or the injection mechanism per-provider; if omitted, no
+     * system prompt is injected (safe default — won't crash spawn with a flag
+     * the CLI doesn't recognize).
+     */
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjection;
 }
+/**
+ * Declarative description of how a CLI accepts a session-scoped system prompt.
+ *
+ * Modes:
+ *   - cli_arg          → push `flag` + prompt onto spawn args                (Claude)
+ *   - config_override  → push `flag` + a templated key=value config override (Codex)
+ *   - context_file     → write prompt into a workspace markdown the CLI
+ *                        auto-loads as project context                       (Gemini, Antigravity)
+ *   - env_var          → expose prompt to the spawned process as $name       (Hermes)
+ *
+ * The prompt text is templated with `{prompt}` (raw) or `{prompt_json}`
+ * (JSON-encoded for embedding inside config-override strings).
+ */
+export type MeshCoordinatorSystemPromptInjection = {
+    mode: 'cli_arg';
+    /** Spawn-args flag, e.g. '--append-system-prompt'. The prompt becomes the next argv. */
+    flag: string;
+} | {
+    mode: 'config_override';
+    /** Spawn-args flag, e.g. '-c'. Followed by `template` with placeholders rendered. */
+    flag: string;
+    /** Template using {prompt} or {prompt_json}, e.g. 'developer_instructions={prompt_json}'. */
+    template: string;
+} | {
+    mode: 'context_file';
+    /** Workspace-relative file path the CLI auto-loads, e.g. 'AGENTS.md' or 'GEMINI.md'. */
+    path: string;
+    /**
+     * Optional wrapper around the prompt. Use `{prompt}` placeholder. Existing
+     * wrapper-delimited blocks are replaced rather than duplicated, so re-launching
+     * a coordinator doesn't pile up copies. If omitted, the prompt is appended raw.
+     */
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    /** Env-var name, e.g. 'HERMES_EPHEMERAL_SYSTEM_PROMPT'. */
+    name: string;
+};
 export interface ProviderCompatibilityEntry {
     ideVersion: string;
     scriptDir: string;
@@ -378,6 +434,14 @@ export interface ProviderModule {
     extensionIdPattern_flags?: string;
     compatibility?: ProviderCompatibilityEntry[];
     defaultScriptDir?: string;
+    /**
+     * v1 declarative tui block (spinner/settledPrompt/modal/dispatchOrder/etc).
+     * When present, the daemon's CliScriptRunner builds canonical
+     * (input → verdict) functions from this and injects them into provider
+     * scripts as `sdk.declarativeDetectStatus` and `sdk.declarativeParseApproval`.
+     * v0 / verified-tier providers can omit this entirely.
+     */
+    tui?: Record<string, unknown>;
     /**
      * Scripts that can run at the IDE main-page level (not just inside the extension webview session frame).
      * Default: ['listModes', 'setMode', 'listModels', 'setModel'].
@@ -429,8 +493,16 @@ export interface ProviderModule {
     /** History behavior config — controls message filtering and collapse during replay */
     historyBehavior?: ProviderHistoryBehavior;
     /**
-     * Canonical history sync config — for providers that maintain native history files.
-     * When set, daemon syncs from native format into ADHDev JSONL store on each tick.
+     * Native history config — for providers that maintain native history files.
+     * When set, daemon reads/lists provider-native transcripts directly. This is
+     * the canonical v1 field name; the legacy `canonicalHistory` field name is
+     * still accepted by the loader and aliased onto this field at load time.
+     */
+    nativeHistory?: NativeHistoryConfig;
+    /**
+     * @deprecated Legacy v0 alias for {@link ProviderModule.nativeHistory}.
+     * Loader populates this from `nativeHistory` so existing internal readers
+     * keep working during the transition. Remove after one release.
      */
     canonicalHistory?: ProviderCanonicalHistoryConfig;
     /**
@@ -561,20 +633,25 @@ export interface ProviderHistoryBehavior {
  * daemon-core. They let each provider own native transcript file discovery and
  * parsing while daemon-core only validates/pages the normalized result.
  */
-export interface ProviderCanonicalHistoryScriptsConfig {
+export interface NativeHistoryScriptsConfig {
     /** Reads one native session. Default: 'readNativeHistory'. */
     readSession?: string;
     /** Lists native sessions with summary metadata. Default: 'listNativeHistory'. */
     listSessions?: string;
 }
 /**
- * Canonical history sync config — for providers that maintain their own native history files.
+ * @deprecated Use {@link NativeHistoryScriptsConfig}. Retained as an alias for
+ * one release so external consumers that referenced the old name keep compiling.
+ */
+export type ProviderCanonicalHistoryScriptsConfig = NativeHistoryScriptsConfig;
+/**
+ * Native history config — for providers that maintain their own native history files.
  *
  * Preferred mode is provider-owned scripts via `scripts`. `format` is now an
  * opaque provider label retained for diagnostics/backward compatibility; daemon
  * live paths must not branch on provider-specific format values.
  */
-export interface ProviderCanonicalHistoryConfig {
+export interface NativeHistoryConfig {
     /** Opaque provider-owned history format label. */
     format?: string;
     /** Optional native history glob/template for diagnostics only. */
@@ -590,7 +667,23 @@ export interface ProviderCanonicalHistoryConfig {
      * Omitted mode defaults to 'native-source'.
      */
     mode?: 'native-source' | 'materialized-mirror' | 'disabled';
+    /**
+     * Chat transcript contract version this provider's read_chat output
+     * conforms to. See transcript-v2.ts for the v2 invariants. Absent or `'1.0'`
+     * → legacy v1 payload (current behaviour). `'2.0'` → strict v2 payload
+     * (stable providerUnitKey/bubbleId/sequence, strict enums, honest coverage).
+     *
+     * A1 only surfaces this field; validators in read-chat-contract.ts route
+     * on it. A2 makes v2 the daemon-internal canonical form and rejects
+     * unrecognised values at provider load time.
+     */
+    contractVersion?: import('./transcript-v2.js').ChatContractVersion;
 }
+/**
+ * @deprecated Use {@link NativeHistoryConfig}. Retained as an alias for one
+ * release so external consumers that referenced the old name keep compiling.
+ */
+export type ProviderCanonicalHistoryConfig = NativeHistoryConfig;
 /**
  * Auto-implement spawn config — controls how the provider is spawned for autonomous AI-driven
  * provider script implementation (dev-auto-implement.ts).

package/dist/providers/native-history/antigravity-cli-transcript.d.ts

@@ -0,0 +1,100 @@
+/**
+ * antigravity-cli-transcript — Daemon-side built-in native history adapter for antigravity-cli.
+ *
+ * Antigravity CLI stores conversations in multiple complementary locations:
+ *
+ *   1. ~/.gemini/antigravity-cli/history.jsonl
+ *      Lightweight index of user prompts, one row per turn:
+ *        { conversationId: string, display: string, workspace: string, timestamp: number }
+ *
+ *   2. ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
+ *      Per-session full transcript, one row per agent step:
+ *        { source: 'USER_EXPLICIT'|'MODEL', type: string, content: string, status: 'DONE'|..., created_at: number }
+ *
+ *   3. ~/.gemini/antigravity-cli/conversations/<uuid>.pb
+ *      Protobuf binary — schema not publicly documented. Adapter extracts
+ *      printable UTF-8 text runs as best-effort content (no proto library needed).
+ *
+ * This adapter provides:
+ *   - Full coverage when a brain transcript exists (authoritative source).
+ *   - Partial coverage (user prompts only) from history.jsonl as fallback.
+ *   - Best-effort raw-string extraction from .pb files when no other source exists.
+ *
+ * watchPath (from provider.v1.json):
+ *   ~/.gemini/antigravity-cli/history.jsonl
+ *   ~/.gemini/antigravity-cli/brain/{uuid}/.system_generated/logs/transcript*.jsonl
+ *   ~/.gemini/antigravity-cli/conversations/{uuid}.pb
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'antigravity-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    /**
+     * 'full' — brain transcript was available and parsed.
+     * 'partial' — only history.jsonl user-prompts are available.
+     * 'best-effort' — .pb file bytes were used for raw text extraction.
+     */
+    nativeHistoryCoverage: 'full' | 'partial' | 'best-effort';
+    workspace?: string;
+    partialReason?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'antigravity-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full' | 'partial' | 'best-effort';
+    partialReason?: string;
+}
+/**
+ * Read a single Antigravity CLI session by its source file path.
+ *
+ * `sessionPath` is the absolute path to one of:
+ *   - A brain transcript JSONL: ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
+ *   - The shared history.jsonl: ~/.gemini/antigravity-cli/history.jsonl
+ *   - A conversation protobuf: ~/.gemini/antigravity-cli/conversations/<uuid>.pb
+ *
+ * The session UUID is inferred from the directory name (brain), filename (pb), or
+ * must be provided explicitly via `sessionId` for history.jsonl paths.
+ *
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string, sessionId?: string, workspace?: string): NativeHistorySession | null;
+/**
+ * List all Antigravity CLI sessions found across all watchPath locations.
+ *
+ * Priority:
+ *   1. Brain transcript sessions (full coverage) — preferred source.
+ *   2. History JSONL entries without a brain transcript (partial coverage).
+ *   3. .pb conversation files without any other source (best-effort).
+ *
+ * Returns summary metadata sorted by most recently updated first.
+ */
+export declare function listSessions(_watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/claude-cli-transcript.d.ts

@@ -0,0 +1,70 @@
+/**
+ * claude-cli-transcript — Daemon-side built-in native history adapter for claude-cli.
+ *
+ * Reads Claude Code JSONL transcript files directly without shelling out to a JS override.
+ * The transcript format is one JSON object per line, where each line has:
+ *   - type: 'user' | 'assistant'
+ *   - message: { content: string | ContentBlock[] }
+ *   - timestamp: number (ms epoch) | string (ISO)
+ *   - sessionId?: string
+ *   - cwd?: string
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'claude-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'claude-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full';
+}
+/**
+ * Read a single Claude Code session by its transcript file path.
+ *
+ * `sessionPath` is the absolute path to a `<uuid>.jsonl` file.
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string): NativeHistorySession | null;
+/**
+ * List all Claude Code sessions under the given glob-style watchPath base dir.
+ *
+ * `watchPath` is the pattern from provider.v1.json (`~/.claude/projects/**\/*.jsonl`).
+ * This implementation expands the home directory and scans `~/.claude/projects/`
+ * recursively, collecting all `.jsonl` files.
+ *
+ * Returns summary metadata for each session (no full message reads on this hot path;
+ * each file is opened only for lightweight scanning).
+ */
+export declare function listSessions(watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/codex-cli-transcript.d.ts

@@ -0,0 +1,73 @@
+/**
+ * codex-cli-transcript — Daemon-side built-in native history adapter for codex-cli.
+ *
+ * Reads Codex CLI rollout JSONL session files directly without shelling out to a JS override.
+ * Files are stored at ~/.codex/sessions/<uuid>[-<slug>].jsonl.
+ *
+ * Format — each line is a JSON object of one of these types:
+ *   { type: 'session_meta', timestamp: number, payload: { id: string, cwd: string, ... } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'message', role: 'user'|'assistant', content: ... } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'function_call' | 'custom_tool_call', name?: string, arguments?: string, input?: unknown } }
+ *   { type: 'response_item', timestamp: number, payload: { type: 'function_call_output' | 'custom_tool_call_output', output?: string, result?: string } }
+ *
+ * watchPath (from provider.v1.json): ~/.codex/sessions
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export type NativeHistoryRole = 'user' | 'assistant' | 'system';
+export type NativeHistoryKind = 'standard' | 'tool' | 'session_start';
+export interface NativeHistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: NativeHistoryRole;
+    content: string;
+    kind: NativeHistoryKind;
+    senderName?: string;
+    agent: 'codex-cli';
+    historySessionId: string;
+    workspace?: string;
+    /** Stable per-message identity (v2 contract). */
+    providerUnitKey?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+    agent: 'codex-cli';
+    source: 'provider-native';
+    nativeHistoryCoverage: 'full';
+}
+/**
+ * Read a single Codex CLI session by its JSONL file path.
+ *
+ * `sessionPath` is the absolute path to a `<uuid>[-<slug>].jsonl` file
+ * under ~/.codex/sessions/.
+ * Returns `null` when the file is missing, empty, or yields no parseable messages.
+ */
+export declare function readSession(sessionPath: string): NativeHistorySession | null;
+/**
+ * List all Codex CLI sessions under the given watchPath base dir.
+ *
+ * `watchPath` is the value from provider.v1.json (`~/.codex/sessions`).
+ * Expands the home directory and scans the directory recursively,
+ * collecting all `.jsonl` files.
+ *
+ * Returns summary metadata for each session, sorted by most recently updated first.
+ */
+export declare function listSessions(watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/dispatcher.d.ts

@@ -0,0 +1,24 @@
+export type ReaderId = 'claude-cli' | 'codex-cli' | 'antigravity-cli' | 'hermes-cli';
+export interface NativeHistoryInput {
+    agentType?: string;
+    sessionId?: string;
+    providerSessionId?: string;
+    historySessionId?: string;
+    workspace?: string;
+    format?: string;
+    watchPath?: string;
+    args?: Record<string, unknown>;
+}
+export interface NativeHistoryResult {
+    messages: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+        kind?: string;
+    }>;
+    providerSessionId?: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage?: 'full' | 'partial' | 'best-effort';
+}
+export declare function createNativeHistoryDispatcher(reader: ReaderId): (input: NativeHistoryInput) => NativeHistoryResult | null;

package/dist/providers/native-history/hermes-cli-transcript.d.ts

@@ -0,0 +1,30 @@
+export interface NativeHistoryMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    receivedAt: number;
+    kind?: string;
+}
+export interface NativeHistorySession {
+    messages: NativeHistoryMessage[];
+    providerSessionId: string;
+    source: 'provider-native';
+    sourcePath: string;
+    sourceMtimeMs: number;
+    nativeHistoryCoverage: 'full';
+    workspace?: string;
+}
+export interface NativeHistorySessionMeta {
+    historySessionId: string;
+    sessionId: string;
+    sourcePath: string;
+    sourceMtimeMs: number;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    sessionTitle?: string;
+    preview?: string;
+    workspace?: string;
+}
+export declare function readSession(sessionPath: string): NativeHistorySession | null;
+export declare function listSessions(_watchPath: string): Promise<NativeHistorySessionMeta[]>;

package/dist/providers/native-history/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * native-history — Daemon-side built-in adapters for CLI provider native history.
+ *
+ * Each adapter reads conversation history directly from the CLI tool's on-disk
+ * storage without shelling out to a provider JS override script.
+ *
+ * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
+ */
+export { readSession as readClaudeCliSession, listSessions as listClaudeCliSessions, } from './claude-cli-transcript.js';
+export { readSession as readCodexCliSession, listSessions as listCodexCliSessions, } from './codex-cli-transcript.js';
+export { readSession as readAntigravityCliSession, listSessions as listAntigravityCliSessions, } from './antigravity-cli-transcript.js';
+export { readSession as readHermesCliSession, listSessions as listHermesCliSessions, } from './hermes-cli-transcript.js';
+export { createNativeHistoryDispatcher, type ReaderId } from './dispatcher.js';

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;
@@ -295,6 +297,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 +323,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/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 {};