pulseed 0.2.0 → 0.4.0

package/dist/platform/dream/dream-types.d.ts

@@ -0,0 +1,2587 @@
+import { z } from "zod";
+export declare const DreamSourceSchema: z.ZodEnum<["observation", "task", "verification", "strategy", "stall"]>;
+export type DreamSource = z.infer<typeof DreamSourceSchema>;
+export type ImportanceSource = DreamSource;
+export declare const DreamEventTypeSchema: z.ZodEnum<["PreObserve", "PostObserve", "PreTaskCreate", "PostTaskCreate", "PreExecute", "PostExecute", "GoalStateChange", "LoopCycleStart", "LoopCycleEnd", "ReflectionComplete", "StallDetected"]>;
+export type DreamEventType = z.infer<typeof DreamEventTypeSchema>;
+export declare const DriveScoreLogSchema: z.ZodObject<{
+    dimensionName: z.ZodString;
+    score: z.ZodNumber;
+    urgency: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    score: number;
+    dimensionName: string;
+    confidence?: number | undefined;
+    urgency?: number | undefined;
+}, {
+    score: number;
+    dimensionName: string;
+    confidence?: number | undefined;
+    urgency?: number | undefined;
+}>;
+export type DriveScoreLog = z.infer<typeof DriveScoreLogSchema>;
+export declare const VerificationResultSummarySchema: z.ZodObject<{
+    verdict: z.ZodString;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    confidence: number;
+    verdict: string;
+}, {
+    timestamp: string;
+    confidence: number;
+    verdict: string;
+}>;
+export type VerificationResultSummary = z.infer<typeof VerificationResultSummarySchema>;
+export declare const IterationGapDimensionSchema: z.ZodObject<{
+    dimension_name: z.ZodString;
+    raw_gap: z.ZodNumber;
+    normalized_gap: z.ZodNumber;
+    confidence: z.ZodNumber;
+    uncertainty_weight: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    uncertainty_weight: number;
+    dimension_name: string;
+    raw_gap: number;
+    normalized_gap: number;
+}, {
+    confidence: number;
+    uncertainty_weight: number;
+    dimension_name: string;
+    raw_gap: number;
+    normalized_gap: number;
+}>;
+export type IterationGapDimension = z.infer<typeof IterationGapDimensionSchema>;
+export declare const IterationLogSchema: z.ZodObject<{
+    entryId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    goalId: z.ZodString;
+    iteration: z.ZodNumber;
+    sessionId: z.ZodString;
+    gapAggregate: z.ZodNumber;
+    gapDimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        dimension_name: z.ZodString;
+        raw_gap: z.ZodNumber;
+        normalized_gap: z.ZodNumber;
+        confidence: z.ZodNumber;
+        uncertainty_weight: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        uncertainty_weight: number;
+        dimension_name: string;
+        raw_gap: number;
+        normalized_gap: number;
+    }, {
+        confidence: number;
+        uncertainty_weight: number;
+        dimension_name: string;
+        raw_gap: number;
+        normalized_gap: number;
+    }>, "many">>;
+    driveScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        dimensionName: z.ZodString;
+        score: z.ZodNumber;
+        urgency: z.ZodOptional<z.ZodNumber>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        score: number;
+        dimensionName: string;
+        confidence?: number | undefined;
+        urgency?: number | undefined;
+    }, {
+        score: number;
+        dimensionName: string;
+        confidence?: number | undefined;
+        urgency?: number | undefined;
+    }>, "many">>;
+    taskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    taskAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    strategyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    verificationResult: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        verdict: z.ZodString;
+        confidence: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        confidence: number;
+        verdict: string;
+    }, {
+        timestamp: string;
+        confidence: number;
+        verdict: string;
+    }>>>;
+    stallDetected: z.ZodBoolean;
+    stallSeverity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    tokensUsed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    elapsedMs: z.ZodNumber;
+    skipped: z.ZodOptional<z.ZodBoolean>;
+    skipReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    completionJudgment: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    waitSuppressed: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    iteration: number;
+    goalId: string;
+    sessionId: string;
+    gapAggregate: number;
+    stallDetected: boolean;
+    completionJudgment: Record<string, unknown>;
+    elapsedMs: number;
+    tokensUsed?: number | null | undefined;
+    skipped?: boolean | undefined;
+    driveScores?: {
+        score: number;
+        dimensionName: string;
+        confidence?: number | undefined;
+        urgency?: number | undefined;
+    }[] | undefined;
+    skipReason?: string | null | undefined;
+    waitSuppressed?: boolean | undefined;
+    entryId?: string | undefined;
+    gapDimensions?: {
+        confidence: number;
+        uncertainty_weight: number;
+        dimension_name: string;
+        raw_gap: number;
+        normalized_gap: number;
+    }[] | undefined;
+    taskId?: string | null | undefined;
+    taskAction?: string | null | undefined;
+    strategyId?: string | null | undefined;
+    verificationResult?: {
+        timestamp: string;
+        confidence: number;
+        verdict: string;
+    } | null | undefined;
+    stallSeverity?: number | null | undefined;
+}, {
+    timestamp: string;
+    iteration: number;
+    goalId: string;
+    sessionId: string;
+    gapAggregate: number;
+    stallDetected: boolean;
+    completionJudgment: Record<string, unknown>;
+    elapsedMs: number;
+    tokensUsed?: number | null | undefined;
+    skipped?: boolean | undefined;
+    driveScores?: {
+        score: number;
+        dimensionName: string;
+        confidence?: number | undefined;
+        urgency?: number | undefined;
+    }[] | undefined;
+    skipReason?: string | null | undefined;
+    waitSuppressed?: boolean | undefined;
+    entryId?: string | undefined;
+    gapDimensions?: {
+        confidence: number;
+        uncertainty_weight: number;
+        dimension_name: string;
+        raw_gap: number;
+        normalized_gap: number;
+    }[] | undefined;
+    taskId?: string | null | undefined;
+    taskAction?: string | null | undefined;
+    strategyId?: string | null | undefined;
+    verificationResult?: {
+        timestamp: string;
+        confidence: number;
+        verdict: string;
+    } | null | undefined;
+    stallSeverity?: number | null | undefined;
+}>;
+export type IterationLog = z.infer<typeof IterationLogSchema>;
+export declare const SessionLogSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    goalId: z.ZodString;
+    sessionId: z.ZodString;
+    iterationCount: z.ZodNumber;
+    finalGapAggregate: z.ZodNumber;
+    initialGapAggregate: z.ZodNumber;
+    totalTokensUsed: z.ZodNumber;
+    totalElapsedMs: z.ZodNumber;
+    stallCount: z.ZodNumber;
+    outcome: z.ZodString;
+    strategiesUsed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    outcome: string;
+    goalId: string;
+    sessionId: string;
+    iterationCount: number;
+    finalGapAggregate: number;
+    initialGapAggregate: number;
+    totalTokensUsed: number;
+    totalElapsedMs: number;
+    stallCount: number;
+    strategiesUsed: string[];
+}, {
+    timestamp: string;
+    outcome: string;
+    goalId: string;
+    sessionId: string;
+    iterationCount: number;
+    finalGapAggregate: number;
+    initialGapAggregate: number;
+    totalTokensUsed: number;
+    totalElapsedMs: number;
+    stallCount: number;
+    strategiesUsed?: string[] | undefined;
+}>;
+export type SessionLog = z.infer<typeof SessionLogSchema>;
+export declare const ImportanceEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    goalId: z.ZodString;
+    source: z.ZodEnum<["observation", "task", "verification", "strategy", "stall"]>;
+    importance: z.ZodNumber;
+    reason: z.ZodString;
+    data_ref: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    processed: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    source: "verification" | "observation" | "task" | "stall" | "strategy";
+    timestamp: string;
+    id: string;
+    reason: string;
+    tags: string[];
+    goalId: string;
+    importance: number;
+    data_ref: string;
+    processed: boolean;
+}, {
+    source: "verification" | "observation" | "task" | "stall" | "strategy";
+    timestamp: string;
+    id: string;
+    reason: string;
+    goalId: string;
+    importance: number;
+    data_ref: string;
+    tags?: string[] | undefined;
+    processed?: boolean | undefined;
+}>;
+export type ImportanceEntry = z.infer<typeof ImportanceEntrySchema>;
+export declare const EventLogSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    eventType: z.ZodEnum<["PreObserve", "PostObserve", "PreTaskCreate", "PostTaskCreate", "PreExecute", "PostExecute", "GoalStateChange", "LoopCycleStart", "LoopCycleEnd", "ReflectionComplete", "StallDetected"]>;
+    goalId: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    data: Record<string, unknown>;
+    goalId: string;
+    eventType: "PreObserve" | "PostObserve" | "PreTaskCreate" | "PostTaskCreate" | "PreExecute" | "PostExecute" | "GoalStateChange" | "LoopCycleStart" | "LoopCycleEnd" | "ReflectionComplete" | "StallDetected";
+    taskId?: string | undefined;
+}, {
+    timestamp: string;
+    goalId: string;
+    eventType: "PreObserve" | "PostObserve" | "PreTaskCreate" | "PostTaskCreate" | "PreExecute" | "PostExecute" | "GoalStateChange" | "LoopCycleStart" | "LoopCycleEnd" | "ReflectionComplete" | "StallDetected";
+    data?: Record<string, unknown> | undefined;
+    taskId?: string | undefined;
+}>;
+export type EventLog = z.infer<typeof EventLogSchema>;
+export declare const WatermarkStateSchema: z.ZodObject<{
+    goals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+        lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+    }, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+    }>>>;
+    importanceBuffer: z.ZodDefault<z.ZodObject<{
+        lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+        lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+        lastProcessedId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    }, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    goals: Record<string, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+    }>;
+    importanceBuffer: {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    };
+}, {
+    goals?: Record<string, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+    }> | undefined;
+    importanceBuffer?: {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    } | undefined;
+}>;
+export type WatermarkState = z.infer<typeof WatermarkStateSchema>;
+export declare const DreamWatermarkSchema: z.ZodObject<{
+    goals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+        lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+    }, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+    }>>>;
+    importanceBuffer: z.ZodDefault<z.ZodObject<{
+        lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+        lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+        lastProcessedId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    }, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    goals: Record<string, {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+    }>;
+    importanceBuffer: {
+        lastProcessedLine: number;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    };
+}, {
+    goals?: Record<string, {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+    }> | undefined;
+    importanceBuffer?: {
+        lastProcessedLine?: number | undefined;
+        lastProcessedTimestamp?: string | undefined;
+        lastProcessedId?: string | undefined;
+    } | undefined;
+}>;
+export type DreamWatermark = WatermarkState;
+export declare const DreamLogCollectionConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    iterationLoggingEnabled: z.ZodDefault<z.ZodBoolean>;
+    sessionSummariesEnabled: z.ZodDefault<z.ZodBoolean>;
+    eventPersistenceEnabled: z.ZodDefault<z.ZodBoolean>;
+    importanceThreshold: z.ZodDefault<z.ZodNumber>;
+    maxFileSizeBytes: z.ZodDefault<z.ZodNumber>;
+    pruneTargetRatio: z.ZodDefault<z.ZodNumber>;
+    rotationMode: z.ZodDefault<z.ZodEnum<["size", "date"]>>;
+    watermarkBehavior: z.ZodDefault<z.ZodEnum<["readonly", "readwrite"]>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    iterationLoggingEnabled: boolean;
+    sessionSummariesEnabled: boolean;
+    eventPersistenceEnabled: boolean;
+    importanceThreshold: number;
+    maxFileSizeBytes: number;
+    pruneTargetRatio: number;
+    rotationMode: "date" | "size";
+    watermarkBehavior: "readonly" | "readwrite";
+}, {
+    enabled?: boolean | undefined;
+    iterationLoggingEnabled?: boolean | undefined;
+    sessionSummariesEnabled?: boolean | undefined;
+    eventPersistenceEnabled?: boolean | undefined;
+    importanceThreshold?: number | undefined;
+    maxFileSizeBytes?: number | undefined;
+    pruneTargetRatio?: number | undefined;
+    rotationMode?: "date" | "size" | undefined;
+    watermarkBehavior?: "readonly" | "readwrite" | undefined;
+}>;
+export type DreamLogCollectionConfig = z.infer<typeof DreamLogCollectionConfigSchema>;
+export type DreamRotationMode = DreamLogCollectionConfig["rotationMode"];
+export type DreamWatermarkBehavior = DreamLogCollectionConfig["watermarkBehavior"];
+export declare const DreamLogConfigSchema: z.ZodObject<{
+    logCollection: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        iterationLoggingEnabled: z.ZodDefault<z.ZodBoolean>;
+        sessionSummariesEnabled: z.ZodDefault<z.ZodBoolean>;
+        eventPersistenceEnabled: z.ZodDefault<z.ZodBoolean>;
+        importanceThreshold: z.ZodDefault<z.ZodNumber>;
+        maxFileSizeBytes: z.ZodDefault<z.ZodNumber>;
+        pruneTargetRatio: z.ZodDefault<z.ZodNumber>;
+        rotationMode: z.ZodDefault<z.ZodEnum<["size", "date"]>>;
+        watermarkBehavior: z.ZodDefault<z.ZodEnum<["readonly", "readwrite"]>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        iterationLoggingEnabled: boolean;
+        sessionSummariesEnabled: boolean;
+        eventPersistenceEnabled: boolean;
+        importanceThreshold: number;
+        maxFileSizeBytes: number;
+        pruneTargetRatio: number;
+        rotationMode: "date" | "size";
+        watermarkBehavior: "readonly" | "readwrite";
+    }, {
+        enabled?: boolean | undefined;
+        iterationLoggingEnabled?: boolean | undefined;
+        sessionSummariesEnabled?: boolean | undefined;
+        eventPersistenceEnabled?: boolean | undefined;
+        importanceThreshold?: number | undefined;
+        maxFileSizeBytes?: number | undefined;
+        pruneTargetRatio?: number | undefined;
+        rotationMode?: "date" | "size" | undefined;
+        watermarkBehavior?: "readonly" | "readwrite" | undefined;
+    }>>;
+    analysis: z.ZodDefault<z.ZodObject<{
+        batchSize: z.ZodDefault<z.ZodNumber>;
+        minIterationsForAnalysis: z.ZodDefault<z.ZodNumber>;
+        maxGoalsPerRun: z.ZodDefault<z.ZodNumber>;
+        patternConfidenceThreshold: z.ZodDefault<z.ZodNumber>;
+        lightRecentIterationWindow: z.ZodDefault<z.ZodNumber>;
+        lightTokenBudget: z.ZodDefault<z.ZodNumber>;
+        deepTokenBudget: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        batchSize: number;
+        minIterationsForAnalysis: number;
+        maxGoalsPerRun: number;
+        patternConfidenceThreshold: number;
+        lightRecentIterationWindow: number;
+        lightTokenBudget: number;
+        deepTokenBudget: number;
+    }, {
+        batchSize?: number | undefined;
+        minIterationsForAnalysis?: number | undefined;
+        maxGoalsPerRun?: number | undefined;
+        patternConfidenceThreshold?: number | undefined;
+        lightRecentIterationWindow?: number | undefined;
+        lightTokenBudget?: number | undefined;
+        deepTokenBudget?: number | undefined;
+    }>>;
+    activation: z.ZodDefault<z.ZodObject<{
+        semanticWorkingMemory: z.ZodDefault<z.ZodBoolean>;
+        crossGoalLessons: z.ZodDefault<z.ZodBoolean>;
+        semanticContext: z.ZodDefault<z.ZodBoolean>;
+        autoAcquireKnowledge: z.ZodDefault<z.ZodBoolean>;
+        learnedPatternHints: z.ZodDefault<z.ZodBoolean>;
+        strategyTemplates: z.ZodDefault<z.ZodBoolean>;
+        decisionHeuristics: z.ZodDefault<z.ZodBoolean>;
+        graphTraversal: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        semanticWorkingMemory: boolean;
+        crossGoalLessons: boolean;
+        semanticContext: boolean;
+        autoAcquireKnowledge: boolean;
+        learnedPatternHints: boolean;
+        strategyTemplates: boolean;
+        decisionHeuristics: boolean;
+        graphTraversal: boolean;
+    }, {
+        semanticWorkingMemory?: boolean | undefined;
+        crossGoalLessons?: boolean | undefined;
+        semanticContext?: boolean | undefined;
+        autoAcquireKnowledge?: boolean | undefined;
+        learnedPatternHints?: boolean | undefined;
+        strategyTemplates?: boolean | undefined;
+        decisionHeuristics?: boolean | undefined;
+        graphTraversal?: boolean | undefined;
+    }>>;
+    consolidation: z.ZodDefault<z.ZodObject<{
+        memory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        agentMemory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        crossGoalTransfer: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            topKActiveGoals: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            topKActiveGoals: number;
+        }, {
+            enabled?: boolean | undefined;
+            topKActiveGoals?: number | undefined;
+        }>>;
+        decisionHistory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            retentionDays: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            retentionDays: number;
+        }, {
+            enabled?: boolean | undefined;
+            retentionDays?: number | undefined;
+        }>>;
+        stallHistory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        sessionData: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            archiveAfterDays: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            archiveAfterDays: number;
+        }, {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        }>>;
+        iterationLogs: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            archiveAfterDays: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            archiveAfterDays: number;
+        }, {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        }>>;
+        gapHistory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        observationLogs: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        reports: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        trustScores: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        strategyHistory: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        verificationArtifacts: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        archive: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
+        knowledgeOptimization: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            redundancySimilarityThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            redundancySimilarityThreshold: number;
+        }, {
+            enabled?: boolean | undefined;
+            redundancySimilarityThreshold?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        archive: {
+            enabled: boolean;
+        };
+        reports: {
+            enabled: boolean;
+        };
+        memory: {
+            enabled: boolean;
+        };
+        agentMemory: {
+            enabled: boolean;
+        };
+        crossGoalTransfer: {
+            enabled: boolean;
+            topKActiveGoals: number;
+        };
+        decisionHistory: {
+            enabled: boolean;
+            retentionDays: number;
+        };
+        stallHistory: {
+            enabled: boolean;
+        };
+        sessionData: {
+            enabled: boolean;
+            archiveAfterDays: number;
+        };
+        iterationLogs: {
+            enabled: boolean;
+            archiveAfterDays: number;
+        };
+        gapHistory: {
+            enabled: boolean;
+        };
+        observationLogs: {
+            enabled: boolean;
+        };
+        trustScores: {
+            enabled: boolean;
+        };
+        strategyHistory: {
+            enabled: boolean;
+        };
+        verificationArtifacts: {
+            enabled: boolean;
+        };
+        knowledgeOptimization: {
+            enabled: boolean;
+            redundancySimilarityThreshold: number;
+        };
+    }, {
+        archive?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        reports?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        memory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        agentMemory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        crossGoalTransfer?: {
+            enabled?: boolean | undefined;
+            topKActiveGoals?: number | undefined;
+        } | undefined;
+        decisionHistory?: {
+            enabled?: boolean | undefined;
+            retentionDays?: number | undefined;
+        } | undefined;
+        stallHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        sessionData?: {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        } | undefined;
+        iterationLogs?: {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        } | undefined;
+        gapHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        observationLogs?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        trustScores?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        strategyHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        verificationArtifacts?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        knowledgeOptimization?: {
+            enabled?: boolean | undefined;
+            redundancySimilarityThreshold?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    logCollection: {
+        enabled: boolean;
+        iterationLoggingEnabled: boolean;
+        sessionSummariesEnabled: boolean;
+        eventPersistenceEnabled: boolean;
+        importanceThreshold: number;
+        maxFileSizeBytes: number;
+        pruneTargetRatio: number;
+        rotationMode: "date" | "size";
+        watermarkBehavior: "readonly" | "readwrite";
+    };
+    analysis: {
+        batchSize: number;
+        minIterationsForAnalysis: number;
+        maxGoalsPerRun: number;
+        patternConfidenceThreshold: number;
+        lightRecentIterationWindow: number;
+        lightTokenBudget: number;
+        deepTokenBudget: number;
+    };
+    activation: {
+        semanticWorkingMemory: boolean;
+        crossGoalLessons: boolean;
+        semanticContext: boolean;
+        autoAcquireKnowledge: boolean;
+        learnedPatternHints: boolean;
+        strategyTemplates: boolean;
+        decisionHeuristics: boolean;
+        graphTraversal: boolean;
+    };
+    consolidation: {
+        archive: {
+            enabled: boolean;
+        };
+        reports: {
+            enabled: boolean;
+        };
+        memory: {
+            enabled: boolean;
+        };
+        agentMemory: {
+            enabled: boolean;
+        };
+        crossGoalTransfer: {
+            enabled: boolean;
+            topKActiveGoals: number;
+        };
+        decisionHistory: {
+            enabled: boolean;
+            retentionDays: number;
+        };
+        stallHistory: {
+            enabled: boolean;
+        };
+        sessionData: {
+            enabled: boolean;
+            archiveAfterDays: number;
+        };
+        iterationLogs: {
+            enabled: boolean;
+            archiveAfterDays: number;
+        };
+        gapHistory: {
+            enabled: boolean;
+        };
+        observationLogs: {
+            enabled: boolean;
+        };
+        trustScores: {
+            enabled: boolean;
+        };
+        strategyHistory: {
+            enabled: boolean;
+        };
+        verificationArtifacts: {
+            enabled: boolean;
+        };
+        knowledgeOptimization: {
+            enabled: boolean;
+            redundancySimilarityThreshold: number;
+        };
+    };
+}, {
+    logCollection?: {
+        enabled?: boolean | undefined;
+        iterationLoggingEnabled?: boolean | undefined;
+        sessionSummariesEnabled?: boolean | undefined;
+        eventPersistenceEnabled?: boolean | undefined;
+        importanceThreshold?: number | undefined;
+        maxFileSizeBytes?: number | undefined;
+        pruneTargetRatio?: number | undefined;
+        rotationMode?: "date" | "size" | undefined;
+        watermarkBehavior?: "readonly" | "readwrite" | undefined;
+    } | undefined;
+    analysis?: {
+        batchSize?: number | undefined;
+        minIterationsForAnalysis?: number | undefined;
+        maxGoalsPerRun?: number | undefined;
+        patternConfidenceThreshold?: number | undefined;
+        lightRecentIterationWindow?: number | undefined;
+        lightTokenBudget?: number | undefined;
+        deepTokenBudget?: number | undefined;
+    } | undefined;
+    activation?: {
+        semanticWorkingMemory?: boolean | undefined;
+        crossGoalLessons?: boolean | undefined;
+        semanticContext?: boolean | undefined;
+        autoAcquireKnowledge?: boolean | undefined;
+        learnedPatternHints?: boolean | undefined;
+        strategyTemplates?: boolean | undefined;
+        decisionHeuristics?: boolean | undefined;
+        graphTraversal?: boolean | undefined;
+    } | undefined;
+    consolidation?: {
+        archive?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        reports?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        memory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        agentMemory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        crossGoalTransfer?: {
+            enabled?: boolean | undefined;
+            topKActiveGoals?: number | undefined;
+        } | undefined;
+        decisionHistory?: {
+            enabled?: boolean | undefined;
+            retentionDays?: number | undefined;
+        } | undefined;
+        stallHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        sessionData?: {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        } | undefined;
+        iterationLogs?: {
+            enabled?: boolean | undefined;
+            archiveAfterDays?: number | undefined;
+        } | undefined;
+        gapHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        observationLogs?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        trustScores?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        strategyHistory?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        verificationArtifacts?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+        knowledgeOptimization?: {
+            enabled?: boolean | undefined;
+            redundancySimilarityThreshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type DreamLogConfig = z.infer<typeof DreamLogConfigSchema>;
+export declare const DreamPhaseSchema: z.ZodEnum<["A", "B", "C"]>;
+export type DreamPhase = z.infer<typeof DreamPhaseSchema>;
+export declare const DreamTierSchema: z.ZodEnum<["light", "deep"]>;
+export type DreamTier = z.infer<typeof DreamTierSchema>;
+export declare const IterationWindowSchema: z.ZodObject<{
+    goalId: z.ZodString;
+    startIteration: z.ZodNumber;
+    endIteration: z.ZodNumber;
+    iterations: z.ZodArray<z.ZodObject<{
+        entryId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        goalId: z.ZodString;
+        iteration: z.ZodNumber;
+        sessionId: z.ZodString;
+        gapAggregate: z.ZodNumber;
+        gapDimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            dimension_name: z.ZodString;
+            raw_gap: z.ZodNumber;
+            normalized_gap: z.ZodNumber;
+            confidence: z.ZodNumber;
+            uncertainty_weight: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }, {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }>, "many">>;
+        driveScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            dimensionName: z.ZodString;
+            score: z.ZodNumber;
+            urgency: z.ZodOptional<z.ZodNumber>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }, {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }>, "many">>;
+        taskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        taskAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        strategyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        verificationResult: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            verdict: z.ZodString;
+            confidence: z.ZodNumber;
+            timestamp: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        }, {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        }>>>;
+        stallDetected: z.ZodBoolean;
+        stallSeverity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        tokensUsed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        elapsedMs: z.ZodNumber;
+        skipped: z.ZodOptional<z.ZodBoolean>;
+        skipReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        completionJudgment: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        waitSuppressed: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        iteration: number;
+        goalId: string;
+        sessionId: string;
+        gapAggregate: number;
+        stallDetected: boolean;
+        completionJudgment: Record<string, unknown>;
+        elapsedMs: number;
+        tokensUsed?: number | null | undefined;
+        skipped?: boolean | undefined;
+        driveScores?: {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }[] | undefined;
+        skipReason?: string | null | undefined;
+        waitSuppressed?: boolean | undefined;
+        entryId?: string | undefined;
+        gapDimensions?: {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }[] | undefined;
+        taskId?: string | null | undefined;
+        taskAction?: string | null | undefined;
+        strategyId?: string | null | undefined;
+        verificationResult?: {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        } | null | undefined;
+        stallSeverity?: number | null | undefined;
+    }, {
+        timestamp: string;
+        iteration: number;
+        goalId: string;
+        sessionId: string;
+        gapAggregate: number;
+        stallDetected: boolean;
+        completionJudgment: Record<string, unknown>;
+        elapsedMs: number;
+        tokensUsed?: number | null | undefined;
+        skipped?: boolean | undefined;
+        driveScores?: {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }[] | undefined;
+        skipReason?: string | null | undefined;
+        waitSuppressed?: boolean | undefined;
+        entryId?: string | undefined;
+        gapDimensions?: {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }[] | undefined;
+        taskId?: string | null | undefined;
+        taskAction?: string | null | undefined;
+        strategyId?: string | null | undefined;
+        verificationResult?: {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        } | null | undefined;
+        stallSeverity?: number | null | undefined;
+    }>, "many">;
+    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    importance: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodDefault<z.ZodEnum<["importance", "recent", "regular"]>>;
+}, "strip", z.ZodTypeAny, {
+    source: "importance" | "recent" | "regular";
+    goalId: string;
+    startIteration: number;
+    endIteration: number;
+    iterations: {
+        timestamp: string;
+        iteration: number;
+        goalId: string;
+        sessionId: string;
+        gapAggregate: number;
+        stallDetected: boolean;
+        completionJudgment: Record<string, unknown>;
+        elapsedMs: number;
+        tokensUsed?: number | null | undefined;
+        skipped?: boolean | undefined;
+        driveScores?: {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }[] | undefined;
+        skipReason?: string | null | undefined;
+        waitSuppressed?: boolean | undefined;
+        entryId?: string | undefined;
+        gapDimensions?: {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }[] | undefined;
+        taskId?: string | null | undefined;
+        taskAction?: string | null | undefined;
+        strategyId?: string | null | undefined;
+        verificationResult?: {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        } | null | undefined;
+        stallSeverity?: number | null | undefined;
+    }[];
+    evidenceRefs: string[];
+    importance?: number | undefined;
+}, {
+    goalId: string;
+    startIteration: number;
+    endIteration: number;
+    iterations: {
+        timestamp: string;
+        iteration: number;
+        goalId: string;
+        sessionId: string;
+        gapAggregate: number;
+        stallDetected: boolean;
+        completionJudgment: Record<string, unknown>;
+        elapsedMs: number;
+        tokensUsed?: number | null | undefined;
+        skipped?: boolean | undefined;
+        driveScores?: {
+            score: number;
+            dimensionName: string;
+            confidence?: number | undefined;
+            urgency?: number | undefined;
+        }[] | undefined;
+        skipReason?: string | null | undefined;
+        waitSuppressed?: boolean | undefined;
+        entryId?: string | undefined;
+        gapDimensions?: {
+            confidence: number;
+            uncertainty_weight: number;
+            dimension_name: string;
+            raw_gap: number;
+            normalized_gap: number;
+        }[] | undefined;
+        taskId?: string | null | undefined;
+        taskAction?: string | null | undefined;
+        strategyId?: string | null | undefined;
+        verificationResult?: {
+            timestamp: string;
+            confidence: number;
+            verdict: string;
+        } | null | undefined;
+        stallSeverity?: number | null | undefined;
+    }[];
+    source?: "importance" | "recent" | "regular" | undefined;
+    importance?: number | undefined;
+    evidenceRefs?: string[] | undefined;
+}>;
+export type IterationWindow = z.infer<typeof IterationWindowSchema>;
+export declare const IngestionStatsSchema: z.ZodObject<{
+    linesRead: z.ZodNumber;
+    malformedLines: z.ZodNumber;
+    batchesBuilt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    linesRead: number;
+    malformedLines: number;
+    batchesBuilt: number;
+}, {
+    linesRead: number;
+    malformedLines: number;
+    batchesBuilt: number;
+}>;
+export type IngestionStats = z.infer<typeof IngestionStatsSchema>;
+export declare const IngestionOutputSchema: z.ZodObject<{
+    prioritizedBatches: z.ZodArray<z.ZodObject<{
+        goalId: z.ZodString;
+        startIteration: z.ZodNumber;
+        endIteration: z.ZodNumber;
+        iterations: z.ZodArray<z.ZodObject<{
+            entryId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+            goalId: z.ZodString;
+            iteration: z.ZodNumber;
+            sessionId: z.ZodString;
+            gapAggregate: z.ZodNumber;
+            gapDimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                dimension_name: z.ZodString;
+                raw_gap: z.ZodNumber;
+                normalized_gap: z.ZodNumber;
+                confidence: z.ZodNumber;
+                uncertainty_weight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }, {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }>, "many">>;
+            driveScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                dimensionName: z.ZodString;
+                score: z.ZodNumber;
+                urgency: z.ZodOptional<z.ZodNumber>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }, {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }>, "many">>;
+            taskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            taskAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            strategyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            verificationResult: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                verdict: z.ZodString;
+                confidence: z.ZodNumber;
+                timestamp: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            }, {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            }>>>;
+            stallDetected: z.ZodBoolean;
+            stallSeverity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            tokensUsed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            elapsedMs: z.ZodNumber;
+            skipped: z.ZodOptional<z.ZodBoolean>;
+            skipReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            completionJudgment: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            waitSuppressed: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }, {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }>, "many">;
+        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        importance: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodDefault<z.ZodEnum<["importance", "recent", "regular"]>>;
+    }, "strip", z.ZodTypeAny, {
+        source: "importance" | "recent" | "regular";
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        evidenceRefs: string[];
+        importance?: number | undefined;
+    }, {
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        source?: "importance" | "recent" | "regular" | undefined;
+        importance?: number | undefined;
+        evidenceRefs?: string[] | undefined;
+    }>, "many">;
+    regularBatches: z.ZodArray<z.ZodObject<{
+        goalId: z.ZodString;
+        startIteration: z.ZodNumber;
+        endIteration: z.ZodNumber;
+        iterations: z.ZodArray<z.ZodObject<{
+            entryId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+            goalId: z.ZodString;
+            iteration: z.ZodNumber;
+            sessionId: z.ZodString;
+            gapAggregate: z.ZodNumber;
+            gapDimensions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                dimension_name: z.ZodString;
+                raw_gap: z.ZodNumber;
+                normalized_gap: z.ZodNumber;
+                confidence: z.ZodNumber;
+                uncertainty_weight: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }, {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }>, "many">>;
+            driveScores: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                dimensionName: z.ZodString;
+                score: z.ZodNumber;
+                urgency: z.ZodOptional<z.ZodNumber>;
+                confidence: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }, {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }>, "many">>;
+            taskId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            taskAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            strategyId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            verificationResult: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                verdict: z.ZodString;
+                confidence: z.ZodNumber;
+                timestamp: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            }, {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            }>>>;
+            stallDetected: z.ZodBoolean;
+            stallSeverity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            tokensUsed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            elapsedMs: z.ZodNumber;
+            skipped: z.ZodOptional<z.ZodBoolean>;
+            skipReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            completionJudgment: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            waitSuppressed: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }, {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }>, "many">;
+        evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        importance: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodDefault<z.ZodEnum<["importance", "recent", "regular"]>>;
+    }, "strip", z.ZodTypeAny, {
+        source: "importance" | "recent" | "regular";
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        evidenceRefs: string[];
+        importance?: number | undefined;
+    }, {
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        source?: "importance" | "recent" | "regular" | undefined;
+        importance?: number | undefined;
+        evidenceRefs?: string[] | undefined;
+    }>, "many">;
+    importanceEntries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodString;
+        goalId: z.ZodString;
+        source: z.ZodEnum<["observation", "task", "verification", "strategy", "stall"]>;
+        importance: z.ZodNumber;
+        reason: z.ZodString;
+        data_ref: z.ZodString;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        processed: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        source: "verification" | "observation" | "task" | "stall" | "strategy";
+        timestamp: string;
+        id: string;
+        reason: string;
+        tags: string[];
+        goalId: string;
+        importance: number;
+        data_ref: string;
+        processed: boolean;
+    }, {
+        source: "verification" | "observation" | "task" | "stall" | "strategy";
+        timestamp: string;
+        id: string;
+        reason: string;
+        goalId: string;
+        importance: number;
+        data_ref: string;
+        tags?: string[] | undefined;
+        processed?: boolean | undefined;
+    }>, "many">;
+    sessionLogs: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        goalId: z.ZodString;
+        sessionId: z.ZodString;
+        iterationCount: z.ZodNumber;
+        finalGapAggregate: z.ZodNumber;
+        initialGapAggregate: z.ZodNumber;
+        totalTokensUsed: z.ZodNumber;
+        totalElapsedMs: z.ZodNumber;
+        stallCount: z.ZodNumber;
+        outcome: z.ZodString;
+        strategiesUsed: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        outcome: string;
+        goalId: string;
+        sessionId: string;
+        iterationCount: number;
+        finalGapAggregate: number;
+        initialGapAggregate: number;
+        totalTokensUsed: number;
+        totalElapsedMs: number;
+        stallCount: number;
+        strategiesUsed: string[];
+    }, {
+        timestamp: string;
+        outcome: string;
+        goalId: string;
+        sessionId: string;
+        iterationCount: number;
+        finalGapAggregate: number;
+        initialGapAggregate: number;
+        totalTokensUsed: number;
+        totalElapsedMs: number;
+        stallCount: number;
+        strategiesUsed?: string[] | undefined;
+    }>, "many">;
+    stats: z.ZodObject<{
+        linesRead: z.ZodNumber;
+        malformedLines: z.ZodNumber;
+        batchesBuilt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    }, {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    }>;
+    watermarkTargets: z.ZodObject<{
+        goals: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+            lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+        }, {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+        }>>>;
+        importanceBuffer: z.ZodDefault<z.ZodObject<{
+            lastProcessedLine: z.ZodDefault<z.ZodNumber>;
+            lastProcessedTimestamp: z.ZodOptional<z.ZodString>;
+            lastProcessedId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        }, {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        goals: Record<string, {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+        }>;
+        importanceBuffer: {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        };
+    }, {
+        goals?: Record<string, {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+        }> | undefined;
+        importanceBuffer?: {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    stats: {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    };
+    prioritizedBatches: {
+        source: "importance" | "recent" | "regular";
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        evidenceRefs: string[];
+        importance?: number | undefined;
+    }[];
+    regularBatches: {
+        source: "importance" | "recent" | "regular";
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        evidenceRefs: string[];
+        importance?: number | undefined;
+    }[];
+    importanceEntries: {
+        source: "verification" | "observation" | "task" | "stall" | "strategy";
+        timestamp: string;
+        id: string;
+        reason: string;
+        tags: string[];
+        goalId: string;
+        importance: number;
+        data_ref: string;
+        processed: boolean;
+    }[];
+    sessionLogs: {
+        timestamp: string;
+        outcome: string;
+        goalId: string;
+        sessionId: string;
+        iterationCount: number;
+        finalGapAggregate: number;
+        initialGapAggregate: number;
+        totalTokensUsed: number;
+        totalElapsedMs: number;
+        stallCount: number;
+        strategiesUsed: string[];
+    }[];
+    watermarkTargets: {
+        goals: Record<string, {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+        }>;
+        importanceBuffer: {
+            lastProcessedLine: number;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        };
+    };
+}, {
+    stats: {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    };
+    prioritizedBatches: {
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        source?: "importance" | "recent" | "regular" | undefined;
+        importance?: number | undefined;
+        evidenceRefs?: string[] | undefined;
+    }[];
+    regularBatches: {
+        goalId: string;
+        startIteration: number;
+        endIteration: number;
+        iterations: {
+            timestamp: string;
+            iteration: number;
+            goalId: string;
+            sessionId: string;
+            gapAggregate: number;
+            stallDetected: boolean;
+            completionJudgment: Record<string, unknown>;
+            elapsedMs: number;
+            tokensUsed?: number | null | undefined;
+            skipped?: boolean | undefined;
+            driveScores?: {
+                score: number;
+                dimensionName: string;
+                confidence?: number | undefined;
+                urgency?: number | undefined;
+            }[] | undefined;
+            skipReason?: string | null | undefined;
+            waitSuppressed?: boolean | undefined;
+            entryId?: string | undefined;
+            gapDimensions?: {
+                confidence: number;
+                uncertainty_weight: number;
+                dimension_name: string;
+                raw_gap: number;
+                normalized_gap: number;
+            }[] | undefined;
+            taskId?: string | null | undefined;
+            taskAction?: string | null | undefined;
+            strategyId?: string | null | undefined;
+            verificationResult?: {
+                timestamp: string;
+                confidence: number;
+                verdict: string;
+            } | null | undefined;
+            stallSeverity?: number | null | undefined;
+        }[];
+        source?: "importance" | "recent" | "regular" | undefined;
+        importance?: number | undefined;
+        evidenceRefs?: string[] | undefined;
+    }[];
+    importanceEntries: {
+        source: "verification" | "observation" | "task" | "stall" | "strategy";
+        timestamp: string;
+        id: string;
+        reason: string;
+        goalId: string;
+        importance: number;
+        data_ref: string;
+        tags?: string[] | undefined;
+        processed?: boolean | undefined;
+    }[];
+    sessionLogs: {
+        timestamp: string;
+        outcome: string;
+        goalId: string;
+        sessionId: string;
+        iterationCount: number;
+        finalGapAggregate: number;
+        initialGapAggregate: number;
+        totalTokensUsed: number;
+        totalElapsedMs: number;
+        stallCount: number;
+        strategiesUsed?: string[] | undefined;
+    }[];
+    watermarkTargets: {
+        goals?: Record<string, {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+        }> | undefined;
+        importanceBuffer?: {
+            lastProcessedLine?: number | undefined;
+            lastProcessedTimestamp?: string | undefined;
+            lastProcessedId?: string | undefined;
+        } | undefined;
+    };
+}>;
+export type IngestionOutput = z.infer<typeof IngestionOutputSchema>;
+export declare const DreamPatternCandidateSchema: z.ZodObject<{
+    pattern_type: z.ZodString;
+    goal_id: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    summary: z.ZodString;
+    evidence_refs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    metadata: Record<string, unknown>;
+    summary: string;
+    pattern_type: string;
+    evidence_refs: string[];
+    goal_id?: string | undefined;
+}, {
+    confidence: number;
+    summary: string;
+    pattern_type: string;
+    goal_id?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    evidence_refs?: string[] | undefined;
+}>;
+export type DreamPatternCandidate = z.infer<typeof DreamPatternCandidateSchema>;
+export declare const DreamPatternResponseSchema: z.ZodObject<{
+    patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        pattern_type: z.ZodString;
+        goal_id: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodNumber;
+        summary: z.ZodString;
+        evidence_refs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        metadata: Record<string, unknown>;
+        summary: string;
+        pattern_type: string;
+        evidence_refs: string[];
+        goal_id?: string | undefined;
+    }, {
+        confidence: number;
+        summary: string;
+        pattern_type: string;
+        goal_id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        evidence_refs?: string[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    patterns: {
+        confidence: number;
+        metadata: Record<string, unknown>;
+        summary: string;
+        pattern_type: string;
+        evidence_refs: string[];
+        goal_id?: string | undefined;
+    }[];
+}, {
+    patterns?: {
+        confidence: number;
+        summary: string;
+        pattern_type: string;
+        goal_id?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        evidence_refs?: string[] | undefined;
+    }[] | undefined;
+}>;
+export type DreamPatternResponse = z.infer<typeof DreamPatternResponseSchema>;
+export declare const ScheduleSuggestionSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["cron", "goal_trigger", "cleanup", "dream_cron"]>;
+    goalId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    }, {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"interval">;
+        seconds: z.ZodNumber;
+        jitter_factor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    }, {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    }>]>>;
+    confidence: z.ZodNumber;
+    reason: z.ZodString;
+    proposal: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<["pending", "applied", "rejected", "dismissed"]>>;
+    applied_entry_id: z.ZodOptional<z.ZodString>;
+    decided_at: z.ZodOptional<z.ZodString>;
+    decision_reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+    status: "pending" | "applied" | "rejected" | "dismissed";
+    confidence: number;
+    reason: string;
+    proposal: string;
+    name?: string | undefined;
+    id?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone: string;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor: number;
+    } | undefined;
+    goalId?: string | undefined;
+    applied_entry_id?: string | undefined;
+    decided_at?: string | undefined;
+    decision_reason?: string | undefined;
+}, {
+    type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+    confidence: number;
+    reason: string;
+    proposal: string;
+    status?: "pending" | "applied" | "rejected" | "dismissed" | undefined;
+    name?: string | undefined;
+    id?: string | undefined;
+    trigger?: {
+        type: "cron";
+        expression: string;
+        timezone?: string | undefined;
+    } | {
+        type: "interval";
+        seconds: number;
+        jitter_factor?: number | undefined;
+    } | undefined;
+    goalId?: string | undefined;
+    applied_entry_id?: string | undefined;
+    decided_at?: string | undefined;
+    decision_reason?: string | undefined;
+}>;
+export type ScheduleSuggestionInput = z.input<typeof ScheduleSuggestionSchema>;
+export type ScheduleSuggestion = z.infer<typeof ScheduleSuggestionSchema>;
+export declare const ScheduleSuggestionFileSchema: z.ZodObject<{
+    generated_at: z.ZodString;
+    suggestions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["cron", "goal_trigger", "cleanup", "dream_cron"]>;
+        goalId: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"cron">;
+            expression: z.ZodString;
+            timezone: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        }, {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"interval">;
+            seconds: z.ZodNumber;
+            jitter_factor: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        }, {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        }>]>>;
+        confidence: z.ZodNumber;
+        reason: z.ZodString;
+        proposal: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["pending", "applied", "rejected", "dismissed"]>>;
+        applied_entry_id: z.ZodOptional<z.ZodString>;
+        decided_at: z.ZodOptional<z.ZodString>;
+        decision_reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        status: "pending" | "applied" | "rejected" | "dismissed";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }, {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        status?: "pending" | "applied" | "rejected" | "dismissed" | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    generated_at: string;
+    suggestions: {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        status: "pending" | "applied" | "rejected" | "dismissed";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }[];
+}, {
+    generated_at: string;
+    suggestions?: {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        status?: "pending" | "applied" | "rejected" | "dismissed" | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }[] | undefined;
+}>;
+export type ScheduleSuggestionFile = z.infer<typeof ScheduleSuggestionFileSchema>;
+export declare const DreamRunReportSchema: z.ZodObject<{
+    tier: z.ZodEnum<["light", "deep"]>;
+    phasesCompleted: z.ZodArray<z.ZodEnum<["A", "B", "C"]>, "many">;
+    goalsProcessed: z.ZodArray<z.ZodString, "many">;
+    patternsPersisted: z.ZodNumber;
+    scheduleSuggestions: z.ZodNumber;
+    tokensEstimated: z.ZodNumber;
+    partial: z.ZodDefault<z.ZodBoolean>;
+    stats: z.ZodObject<{
+        linesRead: z.ZodNumber;
+        malformedLines: z.ZodNumber;
+        batchesBuilt: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    }, {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    }>;
+    learnedPatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        pattern_id: z.ZodString;
+        type: z.ZodEnum<["observation_accuracy", "strategy_selection", "scope_sizing", "task_generation"]>;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        evidence_count: z.ZodNumber;
+        source_goal_ids: z.ZodArray<z.ZodString, "many">;
+        applicable_domains: z.ZodArray<z.ZodString, "many">;
+        embedding_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        last_applied_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "observation_accuracy" | "strategy_selection" | "scope_sizing" | "task_generation";
+        confidence: number;
+        description: string;
+        created_at: string;
+        embedding_id: string | null;
+        source_goal_ids: string[];
+        pattern_id: string;
+        evidence_count: number;
+        applicable_domains: string[];
+        last_applied_at: string | null;
+    }, {
+        type: "observation_accuracy" | "strategy_selection" | "scope_sizing" | "task_generation";
+        confidence: number;
+        description: string;
+        created_at: string;
+        source_goal_ids: string[];
+        pattern_id: string;
+        evidence_count: number;
+        applicable_domains: string[];
+        embedding_id?: string | null | undefined;
+        last_applied_at?: string | null | undefined;
+    }>, "many">>;
+    suggestions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["cron", "goal_trigger", "cleanup", "dream_cron"]>;
+        goalId: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        trigger: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"cron">;
+            expression: z.ZodString;
+            timezone: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        }, {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"interval">;
+            seconds: z.ZodNumber;
+            jitter_factor: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        }, {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        }>]>>;
+        confidence: z.ZodNumber;
+        reason: z.ZodString;
+        proposal: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["pending", "applied", "rejected", "dismissed"]>>;
+        applied_entry_id: z.ZodOptional<z.ZodString>;
+        decided_at: z.ZodOptional<z.ZodString>;
+        decision_reason: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        status: "pending" | "applied" | "rejected" | "dismissed";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }, {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        status?: "pending" | "applied" | "rejected" | "dismissed" | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    partial: boolean;
+    stats: {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    };
+    suggestions: {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        status: "pending" | "applied" | "rejected" | "dismissed";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone: string;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor: number;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }[];
+    tier: "light" | "deep";
+    phasesCompleted: ("A" | "B" | "C")[];
+    goalsProcessed: string[];
+    patternsPersisted: number;
+    scheduleSuggestions: number;
+    tokensEstimated: number;
+    learnedPatterns: {
+        type: "observation_accuracy" | "strategy_selection" | "scope_sizing" | "task_generation";
+        confidence: number;
+        description: string;
+        created_at: string;
+        embedding_id: string | null;
+        source_goal_ids: string[];
+        pattern_id: string;
+        evidence_count: number;
+        applicable_domains: string[];
+        last_applied_at: string | null;
+    }[];
+}, {
+    stats: {
+        linesRead: number;
+        malformedLines: number;
+        batchesBuilt: number;
+    };
+    tier: "light" | "deep";
+    phasesCompleted: ("A" | "B" | "C")[];
+    goalsProcessed: string[];
+    patternsPersisted: number;
+    scheduleSuggestions: number;
+    tokensEstimated: number;
+    partial?: boolean | undefined;
+    suggestions?: {
+        type: "cron" | "goal_trigger" | "cleanup" | "dream_cron";
+        confidence: number;
+        reason: string;
+        proposal: string;
+        status?: "pending" | "applied" | "rejected" | "dismissed" | undefined;
+        name?: string | undefined;
+        id?: string | undefined;
+        trigger?: {
+            type: "cron";
+            expression: string;
+            timezone?: string | undefined;
+        } | {
+            type: "interval";
+            seconds: number;
+            jitter_factor?: number | undefined;
+        } | undefined;
+        goalId?: string | undefined;
+        applied_entry_id?: string | undefined;
+        decided_at?: string | undefined;
+        decision_reason?: string | undefined;
+    }[] | undefined;
+    learnedPatterns?: {
+        type: "observation_accuracy" | "strategy_selection" | "scope_sizing" | "task_generation";
+        confidence: number;
+        description: string;
+        created_at: string;
+        source_goal_ids: string[];
+        pattern_id: string;
+        evidence_count: number;
+        applicable_domains: string[];
+        embedding_id?: string | null | undefined;
+        last_applied_at?: string | null | undefined;
+    }[] | undefined;
+}>;
+export type DreamRunReport = z.infer<typeof DreamRunReportSchema>;
+export declare const ConsolidationCategoryResultSchema: z.ZodObject<{
+    category: z.ZodString;
+    status: z.ZodEnum<["completed", "skipped", "failed"]>;
+    metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "completed" | "failed" | "skipped";
+    category: string;
+    metrics: Record<string, number>;
+    warnings: string[];
+    errors: string[];
+}, {
+    status: "completed" | "failed" | "skipped";
+    category: string;
+    metrics?: Record<string, number> | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+}>;
+export type ConsolidationCategoryResult = z.infer<typeof ConsolidationCategoryResultSchema>;
+export declare const DreamReportSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    tier: z.ZodEnum<["light", "deep"]>;
+    status: z.ZodEnum<["completed", "partial", "failed"]>;
+    categories: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        status: z.ZodEnum<["completed", "skipped", "failed"]>;
+        metrics: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: "completed" | "failed" | "skipped";
+        category: string;
+        metrics: Record<string, number>;
+        warnings: string[];
+        errors: string[];
+    }, {
+        status: "completed" | "failed" | "skipped";
+        category: string;
+        metrics?: Record<string, number> | undefined;
+        warnings?: string[] | undefined;
+        errors?: string[] | undefined;
+    }>, "many">>;
+    summary: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "partial" | "completed" | "failed";
+    timestamp: string;
+    summary: string;
+    tier: "light" | "deep";
+    categories: {
+        status: "completed" | "failed" | "skipped";
+        category: string;
+        metrics: Record<string, number>;
+        warnings: string[];
+        errors: string[];
+    }[];
+}, {
+    status: "partial" | "completed" | "failed";
+    timestamp: string;
+    summary: string;
+    tier: "light" | "deep";
+    categories?: {
+        status: "completed" | "failed" | "skipped";
+        category: string;
+        metrics?: Record<string, number> | undefined;
+        warnings?: string[] | undefined;
+        errors?: string[] | undefined;
+    }[] | undefined;
+}>;
+export type DreamReport = z.infer<typeof DreamReportSchema>;
+//# sourceMappingURL=dream-types.d.ts.map