@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.1

package/lib/types/configuration.d.ts

@@ -0,0 +1,235 @@
+import { z } from 'zod';
+export declare const ConfigurationValuesSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    home: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    mode: z.ZodEnum<{
+        team: "team";
+        solo: "solo";
+    }>;
+    routerEndpoint: z.ZodString;
+    maintainerEndpoint: z.ZodString;
+    keyEnv: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    legacyEnabled: z.ZodOptional<z.ZodBoolean>;
+    connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        routerEndpoint: z.ZodString;
+        maintainerEndpoint: z.ZodString;
+        keyEnv: z.ZodDefault<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    defaultConnection: z.ZodOptional<z.ZodString>;
+    showCompletion: z.ZodOptional<z.ZodBoolean>;
+    upstream: z.ZodOptional<z.ZodString>;
+    upstreams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        routerEndpoint: z.ZodDefault<z.ZodString>;
+        maintainerEndpoint: z.ZodDefault<z.ZodString>;
+        keyEnv: z.ZodDefault<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    advanced: z.ZodOptional<z.ZodObject<{
+        inboxProcessingStaleAfterSecs: z.ZodNumber;
+        routerQueryTimeoutSecs: z.ZodNumber;
+        httpTimeoutSecs: z.ZodNumber;
+        httpRetryCount: z.ZodNumber;
+        httpRetryBaseDelayMs: z.ZodNumber;
+        httpRetryMaxDelayMs: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ConfigurationValues = z.infer<typeof ConfigurationValuesSchema>;
+export declare const ModelChoiceSchema: z.ZodObject<{
+    provider: z.ZodString;
+    providerName: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type ModelChoice = z.infer<typeof ModelChoiceSchema>;
+export declare const ConfigurationSnapshotSchema: z.ZodObject<{
+    revision: z.ZodString;
+    values: z.ZodObject<{
+        agentId: z.ZodString;
+        home: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        mode: z.ZodEnum<{
+            team: "team";
+            solo: "solo";
+        }>;
+        routerEndpoint: z.ZodString;
+        maintainerEndpoint: z.ZodString;
+        keyEnv: z.ZodString;
+        timeoutMs: z.ZodNumber;
+        legacyEnabled: z.ZodOptional<z.ZodBoolean>;
+        connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            routerEndpoint: z.ZodString;
+            maintainerEndpoint: z.ZodString;
+            keyEnv: z.ZodDefault<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        defaultConnection: z.ZodOptional<z.ZodString>;
+        showCompletion: z.ZodOptional<z.ZodBoolean>;
+        upstream: z.ZodOptional<z.ZodString>;
+        upstreams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodDefault<z.ZodString>;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            routerEndpoint: z.ZodDefault<z.ZodString>;
+            maintainerEndpoint: z.ZodDefault<z.ZodString>;
+            keyEnv: z.ZodDefault<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        advanced: z.ZodOptional<z.ZodObject<{
+            inboxProcessingStaleAfterSecs: z.ZodNumber;
+            routerQueryTimeoutSecs: z.ZodNumber;
+            httpTimeoutSecs: z.ZodNumber;
+            httpRetryCount: z.ZodNumber;
+            httpRetryBaseDelayMs: z.ZodNumber;
+            httpRetryMaxDelayMs: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    models: z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        providerName: z.ZodString;
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    active: z.ZodBoolean;
+    dataDirectory: z.ZodString;
+    upstreamPending: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>>;
+}, z.core.$strict>;
+export type ConfigurationSnapshot = z.infer<typeof ConfigurationSnapshotSchema>;
+export declare const SaveConfigurationSchema: z.ZodObject<{
+    revision: z.ZodString;
+    values: z.ZodObject<{
+        agentId: z.ZodString;
+        home: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        mode: z.ZodEnum<{
+            team: "team";
+            solo: "solo";
+        }>;
+        routerEndpoint: z.ZodString;
+        maintainerEndpoint: z.ZodString;
+        keyEnv: z.ZodString;
+        timeoutMs: z.ZodNumber;
+        legacyEnabled: z.ZodOptional<z.ZodBoolean>;
+        connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            routerEndpoint: z.ZodString;
+            maintainerEndpoint: z.ZodString;
+            keyEnv: z.ZodDefault<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        defaultConnection: z.ZodOptional<z.ZodString>;
+        showCompletion: z.ZodOptional<z.ZodBoolean>;
+        upstream: z.ZodOptional<z.ZodString>;
+        upstreams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodDefault<z.ZodString>;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            routerEndpoint: z.ZodDefault<z.ZodString>;
+            maintainerEndpoint: z.ZodDefault<z.ZodString>;
+            keyEnv: z.ZodDefault<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        advanced: z.ZodOptional<z.ZodObject<{
+            inboxProcessingStaleAfterSecs: z.ZodNumber;
+            routerQueryTimeoutSecs: z.ZodNumber;
+            httpTimeoutSecs: z.ZodNumber;
+            httpRetryCount: z.ZodNumber;
+            httpRetryBaseDelayMs: z.ZodNumber;
+            httpRetryMaxDelayMs: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SaveConfiguration = z.infer<typeof SaveConfigurationSchema>;
+export declare const ConfigurationResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    snapshot: z.ZodObject<{
+        revision: z.ZodString;
+        values: z.ZodObject<{
+            agentId: z.ZodString;
+            home: z.ZodString;
+            provider: z.ZodString;
+            model: z.ZodString;
+            mode: z.ZodEnum<{
+                team: "team";
+                solo: "solo";
+            }>;
+            routerEndpoint: z.ZodString;
+            maintainerEndpoint: z.ZodString;
+            keyEnv: z.ZodString;
+            timeoutMs: z.ZodNumber;
+            legacyEnabled: z.ZodOptional<z.ZodBoolean>;
+            connections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+                routerEndpoint: z.ZodString;
+                maintainerEndpoint: z.ZodString;
+                keyEnv: z.ZodDefault<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            defaultConnection: z.ZodOptional<z.ZodString>;
+            showCompletion: z.ZodOptional<z.ZodBoolean>;
+            upstream: z.ZodOptional<z.ZodString>;
+            upstreams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodDefault<z.ZodString>;
+                agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                routerEndpoint: z.ZodDefault<z.ZodString>;
+                maintainerEndpoint: z.ZodDefault<z.ZodString>;
+                keyEnv: z.ZodDefault<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>>;
+            advanced: z.ZodOptional<z.ZodObject<{
+                inboxProcessingStaleAfterSecs: z.ZodNumber;
+                routerQueryTimeoutSecs: z.ZodNumber;
+                httpTimeoutSecs: z.ZodNumber;
+                httpRetryCount: z.ZodNumber;
+                httpRetryBaseDelayMs: z.ZodNumber;
+                httpRetryMaxDelayMs: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        models: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            providerName: z.ZodString;
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        active: z.ZodBoolean;
+        dataDirectory: z.ZodString;
+        upstreamPending: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    code: z.ZodEnum<{
+        conflict: "conflict";
+        invalid: "invalid";
+        unavailable: "unavailable";
+        persistence: "persistence";
+        inactive: "inactive";
+        busy: "busy";
+    }>;
+    fields: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "ok">;
+export type ConfigurationResult = z.infer<typeof ConfigurationResultSchema>;
+export declare function configurationValues(raw: unknown): ConfigurationValues;
+export declare function mergeConfiguration(raw: Record<string, unknown>, values: ConfigurationValues): Record<string, unknown>;

package/lib/types/credentials.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const CredentialRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"describe">;
+    reference: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"store">;
+    reference: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"discard">;
+    reference: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"check">;
+    connection: z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        routerEndpoint: z.ZodString;
+        maintainerEndpoint: z.ZodString;
+        keyEnv: z.ZodDefault<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        routerEndpoint: z.ZodDefault<z.ZodString>;
+        maintainerEndpoint: z.ZodDefault<z.ZodString>;
+        keyEnv: z.ZodDefault<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    value: z.ZodString;
+}, z.core.$strict>], "action">;
+export type CredentialRequest = z.input<typeof CredentialRequestSchema>;
+export declare const CredentialResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    message: z.ZodString;
+    messageInfo: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        count: z.ZodOptional<z.ZodNumber>;
+        entityId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    configured: z.ZodOptional<z.ZodBoolean>;
+    writable: z.ZodOptional<z.ZodBoolean>;
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        service: z.ZodEnum<{
+            router: "router";
+            maintainer: "maintainer";
+        }>;
+        state: z.ZodEnum<{
+            failed: "failed";
+            ok: "ok";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export type CredentialResult = z.infer<typeof CredentialResultSchema>;

package/lib/types/dream/audit.d.ts

@@ -0,0 +1,4 @@
+import type { StoreContext } from '../store/context.js';
+import type { Checkpoint, Progress } from './schema.js';
+export declare function executionAudit(context: StoreContext, jobId: string, checkpoint: Checkpoint): Promise<void>;
+export declare function jobReport(context: StoreContext, jobId: string, progress: Progress, coverage: unknown, records: readonly Checkpoint[]): Promise<void>;

package/lib/types/dream/autonomous.d.ts

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+import type { AcnKnowledge } from '../knowledge/service.js';
+import type { Job } from '../worker/types.js';
+import type { JobControl } from '../worker/worker.js';
+import type { Progress } from './schema.js';
+export declare const DreamTools: {
+    dream_record_candidates: z.ZodObject<{
+        candidates: z.ZodArray<z.ZodObject<{
+            group_id: z.ZodString;
+            claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+            kind: z.ZodEnum<{
+                quality: "quality";
+                evidence: "evidence";
+                consolidation: "consolidation";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    dream_stage_group: z.ZodObject<{
+        group: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                quality: "quality";
+                evidence: "evidence";
+                consolidation: "consolidation";
+            }>;
+            reason: z.ZodString;
+            evidence_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            coverage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                input_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                output_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+                note: z.ZodString;
+            }, z.core.$strict>>>;
+            change_basis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                claim_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                removed_or_changed: z.ZodString;
+                added: z.ZodString;
+                justification: z.ZodString;
+                evidence_ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            operations: z.ZodArray<z.ZodObject<{
+                id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                action: z.ZodEnum<{
+                    keep: "keep";
+                    update: "update";
+                    deprecate: "deprecate";
+                }>;
+                changes: z.ZodDefault<z.ZodObject<{
+                    name: z.ZodOptional<z.ZodString>;
+                    statement: z.ZodOptional<z.ZodString>;
+                    scope: z.ZodOptional<z.ZodString>;
+                    confidence: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        medium: "medium";
+                        low: "low";
+                    }>>;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        active: "active";
+                        stale: "stale";
+                        deprecated: "deprecated";
+                    }>>;
+                    source_claim_ids: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.core.$ZodBranded<z.ZodString, "PolicyId", "out">]>>>;
+                    evidence_summary: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        group_id: z.ZodString;
+    }, z.core.$strict>;
+    dream_validate: z.ZodObject<{
+        group_id: z.ZodString;
+    }, z.core.$strict>;
+    dream_apply_group: z.ZodObject<{
+        validation_id: z.ZodString;
+        review: z.ZodObject<{
+            claims: z.ZodArray<z.ZodObject<{
+                claim_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                final_name: z.ZodDefault<z.ZodString>;
+                name_reason: z.ZodDefault<z.ZodString>;
+                information_preserved: z.ZodString;
+                removal_or_correction: z.ZodString;
+                factual_correction: z.ZodBoolean;
+                output_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+                evidence_ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            scope_and_certainty: z.ZodString;
+        }, z.core.$strict>;
+        group_id: z.ZodString;
+    }, z.core.$strict>;
+    dream_keep_candidate: z.ZodObject<{
+        reason_kind: z.ZodEnum<{
+            insufficient_evidence: "insufficient_evidence";
+            useful_knowledge: "useful_knowledge";
+            uncertain_preservation: "uncertain_preservation";
+            no_consolidation_benefit: "no_consolidation_benefit";
+            external_change: "external_change";
+        }>;
+        reason: z.ZodString;
+        group_id: z.ZodString;
+    }, z.core.$strict>;
+    dream_read_draft: z.ZodObject<{
+        group_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    dream_read_history: z.ZodObject<{
+        offset: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    dream_review_sync: z.ZodObject<{
+        source_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+        carrier_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        validation_id: z.ZodOptional<z.ZodString>;
+        review: z.ZodOptional<z.ZodObject<{
+            claims: z.ZodArray<z.ZodObject<{
+                claim_id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+                final_name: z.ZodDefault<z.ZodString>;
+                name_reason: z.ZodDefault<z.ZodString>;
+                information_preserved: z.ZodString;
+                removal_or_correction: z.ZodString;
+                factual_correction: z.ZodBoolean;
+                output_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+                evidence_ids: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            scope_and_certainty: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    dream_finish: z.ZodObject<{
+        review: z.ZodObject<{
+            quality: z.ZodString;
+            evidence: z.ZodString;
+            consolidation: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    read_claim: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+    }, z.core.$strict>;
+    read_trace: z.ZodObject<{
+        claim_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        trace_id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TraceId", "out">>;
+        id: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TraceId", "out">>;
+        offset: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    file_read: z.ZodObject<{
+        path: z.ZodString;
+        claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        start: z.ZodDefault<z.ZodNumber>;
+        count: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    file_glob: z.ZodObject<{
+        query: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+    file_grep: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strict>;
+};
+export type DreamTool = keyof typeof DreamTools;
+export declare const isDreamTool: (name: string) => name is DreamTool;
+export declare class DreamSession {
+    readonly knowledge: AcnKnowledge;
+    readonly job: Job;
+    readonly control: JobControl;
+    readonly progress: Progress;
+    private readonly claims;
+    private readonly originalHigh;
+    readonly workspace: string;
+    private readonly boundary;
+    private pending;
+    private constructor();
+    static create(knowledge: AcnKnowledge, job: Job, control: JobControl, boundary: () => Promise<void>): Promise<DreamSession>;
+    get finished(): boolean;
+    get exhausted(): boolean;
+    get wrappingUp(): boolean;
+    budgetNotice(): string;
+    admitStep(signal?: AbortSignal): Promise<void>;
+    finishBudget(signal?: AbortSignal): Promise<void>;
+    private finish;
+    private save;
+    private current;
+    private readable;
+    private candidateProgress;
+    input(): Promise<object>;
+    private evidenceState;
+    private register;
+    execute(name: DreamTool, args: unknown, signal?: AbortSignal): Promise<unknown>;
+    private dispatch;
+}

package/lib/types/dream/candidates.d.ts

@@ -0,0 +1,34 @@
+import type { Claim } from '../protocol/claim.js';
+import type { AgentId } from '../protocol/ids.js';
+import type { ResolvedConfig } from '../config.js';
+import type { z } from 'zod';
+import type { DreamStateSchema } from './schema.js';
+export declare const INPUT_TOKENS = 64000;
+export declare function conservativeTokens(text: string): number;
+export declare function claimInput(claims: readonly Claim[], budget?: number): {
+    loaded: {
+        id: string & z.core.$brand<"ClaimId">;
+        name: string;
+        statement: string;
+        scope: string;
+        holder: string & z.core.$brand<"AgentId">;
+        confidence: "high" | "medium" | "low";
+        status: "active" | "stale" | "deprecated";
+        created_at: string;
+        source_claim_ids: ((string & z.core.$brand<"ClaimId">) | (string & z.core.$brand<"PolicyId">))[];
+        evidence_summary: string;
+        updated_at?: string | undefined;
+    }[];
+    coverage: {
+        total: number;
+        included: number;
+        omitted: number;
+        order: string;
+        estimated_tokens: number;
+        budget_tokens: number;
+    };
+};
+export declare function versions(claims: readonly Claim[]): {
+    [k: string]: string;
+};
+export declare function dreamEligible(config: ResolvedConfig['dream'], state: z.infer<typeof DreamStateSchema>, claims: readonly Claim[], owner: AgentId, manual: boolean, now?: number): boolean;

package/lib/types/dream/checkpoint.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import type { StoreContext } from '../store/context.js';
+import type { JobControl } from '../worker/worker.js';
+import type { Checkpoint, Group, OriginSchema as OriginType, Progress, SemanticReview, SelfReview, Validation } from './schema.js';
+type Origin = z.infer<typeof OriginType>;
+export declare class DreamStore {
+    readonly context: StoreContext;
+    private readonly settleRegular?;
+    constructor(context: StoreContext, settleRegular?: (() => Promise<void>) | undefined);
+    state(): Promise<{
+        last_success_at: string | null;
+        last_input_snapshot_at: string | null;
+        known_versions: Record<string & z.core.$brand<"ClaimId">, string>;
+    }>;
+    origin(jobId: string): Promise<Origin | null>;
+    progress(jobId: string): Promise<Progress | null>;
+    final(jobId: string): Promise<Checkpoint | null>;
+    saveOrigin(jobId: string, origin: Origin): Promise<void>;
+    saveProgress(jobId: string, progress: Progress): Promise<void>;
+    report(jobId: string, progress: Progress): Promise<void>;
+    records(jobId: string): Promise<{
+        path: string;
+        checkpoint: Checkpoint;
+    }[]>;
+    private jobs;
+    private pending;
+    private unfinished;
+    recover(): Promise<void>;
+    recoverLocked(): Promise<void>;
+    commitGroup(jobId: string, groupId: string, group: Group, validation: Validation, semantic: SemanticReview, selfReview: SelfReview | null, control: JobControl): Promise<Checkpoint>;
+    finish(jobId: string, progress: Progress, control: JobControl): Promise<Checkpoint>;
+    private applyLocked;
+    archive(jobId: string, key: string, value: unknown): Promise<void>;
+}
+export {};

package/lib/types/dream/evidence-files.d.ts

@@ -0,0 +1,10 @@
+import type { Receipt } from './evidence.js';
+export declare const within: (root: string, path: string) => boolean;
+export declare function authorizeFile(workspace: string, privateHome: string, input: string): Promise<string>;
+export declare function readEvidenceFile(workspace: string, privateHome: string, input: string, maxBytes: number): Promise<{
+    path: string;
+    content: string;
+    revision: Receipt['output']['file_version']['revision'];
+}>;
+export declare function receiptCurrent(receipt: Receipt, workspace: string, privateHome: string): Promise<boolean>;
+export declare function discoverable(name: string): boolean;

package/lib/types/dream/evidence-store.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import type { ResolvedConfig } from '../config.js';
+import type { StoreContext } from '../store/context.js';
+import type { Claim } from '../protocol/claim.js';
+import { type Receipts } from './evidence.js';
+export declare const ReadArgs: z.ZodObject<{
+    path: z.ZodString;
+    claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+    start: z.ZodDefault<z.ZodNumber>;
+    count: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const GlobArgs: z.ZodObject<{
+    query: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const GrepArgs: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strict>;
+export declare const ClaimArgs: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"read">;
+    id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+}, z.core.$strict>], "action">;
+export declare const EvidenceTools: {
+    read: z.ZodObject<{
+        path: z.ZodString;
+        claim_ids: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>;
+        start: z.ZodDefault<z.ZodNumber>;
+        count: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    glob: z.ZodObject<{
+        query: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+    grep: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strict>;
+    claim: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"list">;
+    }, z.core.$strict>, z.ZodObject<{
+        action: z.ZodLiteral<"read">;
+        id: z.core.$ZodBranded<z.ZodString, "ClaimId", "out">;
+    }, z.core.$strict>], "action">;
+};
+export type EvidenceTool = keyof typeof EvidenceTools;
+export declare const EvidenceManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    job_id: z.ZodString;
+    group_id: z.ZodString;
+    workspace_root: z.ZodString;
+    claim_versions: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">, z.ZodString>;
+    receipts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        tool: z.ZodLiteral<"file_read">;
+        input: z.ZodObject<{
+            path: z.ZodString;
+            claim_ids: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ClaimId", "out">>>;
+            show_linenos: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>;
+        output: z.ZodObject<{
+            content: z.ZodString;
+            page: z.ZodOptional<z.ZodObject<{
+                returned_start: z.ZodNumber;
+                returned_end: z.ZodNumber;
+            }, z.core.$loose>>;
+            file_version: z.ZodObject<{
+                path: z.ZodString;
+                revision: z.ZodObject<{
+                    sha256: z.ZodString;
+                    byte_len: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strip>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
+    calls: z.ZodNumber;
+    model_steps: z.ZodNumber;
+    bytes_read: z.ZodNumber;
+    files_examined: z.ZodNumber;
+    limits: z.ZodObject<{
+        calls: z.ZodNumber;
+        steps: z.ZodNumber;
+        bytes: z.ZodNumber;
+        chars: z.ZodNumber;
+        files: z.ZodNumber;
+    }, z.core.$strict>;
+    completed: z.ZodBoolean;
+}, z.core.$strict>;
+export type EvidenceManifest = z.infer<typeof EvidenceManifestSchema>;
+export declare const privateDataHome: (context: StoreContext) => string;
+export declare class EvidenceStore {
+    readonly context: StoreContext;
+    readonly jobId: string;
+    readonly groupId: string;
+    readonly path: string;
+    constructor(context: StoreContext, jobId: string, groupId: string);
+    read(): Promise<EvidenceManifest | null>;
+    private save;
+    initialize(workspace: string, claims: readonly Claim[], config: ResolvedConfig['dream'], signal?: AbortSignal): Promise<EvidenceManifest>;
+    admitStep(signal: AbortSignal): Promise<void>;
+    reopen(signal: AbortSignal): Promise<void>;
+    complete(signal: AbortSignal): Promise<void>;
+    current(manifest: EvidenceManifest): Promise<boolean>;
+    authorize(receipts: Receipts, workspace: string | undefined, before: readonly Claim[]): Promise<boolean>;
+    execute(name: EvidenceTool, args: unknown, claims: readonly Claim[], signal: AbortSignal): Promise<z.infer<ReturnType<typeof z.json>>>;
+}