@ai-dev-orchestrator/schemas 0.1.1

package/dist/persistence/execution-analytics.d.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod/v4';
+export declare const distributionSummarySchema: z.ZodObject<{
+    p50: z.ZodNumber;
+    p75: z.ZodNumber;
+    p90: z.ZodNumber;
+    max: z.ZodNumber;
+    ema: z.ZodNumber;
+}, z.core.$strip>;
+export type DistributionSummary = z.infer<typeof distributionSummarySchema>;
+export declare const errorFrequencySchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        timeout: "timeout";
+        agent_error: "agent_error";
+        invalid_output: "invalid_output";
+        schema_violation: "schema_violation";
+        ownership_violation: "ownership_violation";
+        cancelled: "cancelled";
+    }>;
+    frequency: z.ZodNumber;
+}, z.core.$strip>;
+export type ErrorFrequency = z.infer<typeof errorFrequencySchema>;
+export declare const executionProfileSchema: z.ZodObject<{
+    roleId: z.ZodString;
+    model: z.ZodString;
+    sampleSize: z.ZodNumber;
+    lastUpdated: z.ZodString;
+    tokenUsage: z.ZodObject<{
+        inputTokens: z.ZodObject<{
+            p50: z.ZodNumber;
+            p75: z.ZodNumber;
+            p90: z.ZodNumber;
+            max: z.ZodNumber;
+            ema: z.ZodNumber;
+        }, z.core.$strip>;
+        outputTokens: z.ZodObject<{
+            p50: z.ZodNumber;
+            p75: z.ZodNumber;
+            p90: z.ZodNumber;
+            max: z.ZodNumber;
+            ema: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    reliability: z.ZodObject<{
+        successRate: z.ZodNumber;
+        failureRate: z.ZodNumber;
+        avgRetries: z.ZodNumber;
+        retryableFailureRate: z.ZodNumber;
+        commonErrorTypes: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                timeout: "timeout";
+                agent_error: "agent_error";
+                invalid_output: "invalid_output";
+                schema_violation: "schema_violation";
+                ownership_violation: "ownership_violation";
+                cancelled: "cancelled";
+            }>;
+            frequency: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    timing: z.ZodObject<{
+        durationMs: z.ZodObject<{
+            p50: z.ZodNumber;
+            p75: z.ZodNumber;
+            p90: z.ZodNumber;
+            max: z.ZodNumber;
+            ema: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    confidence: z.ZodObject<{
+        avgConfidence: z.ZodNumber;
+        escalationRate: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ExecutionProfile = z.infer<typeof executionProfileSchema>;
+export declare const workerOutcomeRecordSchema: z.ZodObject<{
+    roleId: z.ZodString;
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    retryCount: z.ZodNumber;
+    status: z.ZodEnum<{
+        success: "success";
+        failure: "failure";
+    }>;
+    errorType: z.ZodNullable<z.ZodEnum<{
+        timeout: "timeout";
+        agent_error: "agent_error";
+        invalid_output: "invalid_output";
+        schema_violation: "schema_violation";
+        ownership_violation: "ownership_violation";
+        cancelled: "cancelled";
+    }>>;
+    confidenceScore: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type WorkerOutcomeRecord = z.infer<typeof workerOutcomeRecordSchema>;
+export declare const executionProfileStoreSchema: z.ZodObject<{
+    profiles: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodString;
+        model: z.ZodString;
+        sampleSize: z.ZodNumber;
+        lastUpdated: z.ZodString;
+        tokenUsage: z.ZodObject<{
+            inputTokens: z.ZodObject<{
+                p50: z.ZodNumber;
+                p75: z.ZodNumber;
+                p90: z.ZodNumber;
+                max: z.ZodNumber;
+                ema: z.ZodNumber;
+            }, z.core.$strip>;
+            outputTokens: z.ZodObject<{
+                p50: z.ZodNumber;
+                p75: z.ZodNumber;
+                p90: z.ZodNumber;
+                max: z.ZodNumber;
+                ema: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        reliability: z.ZodObject<{
+            successRate: z.ZodNumber;
+            failureRate: z.ZodNumber;
+            avgRetries: z.ZodNumber;
+            retryableFailureRate: z.ZodNumber;
+            commonErrorTypes: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    timeout: "timeout";
+                    agent_error: "agent_error";
+                    invalid_output: "invalid_output";
+                    schema_violation: "schema_violation";
+                    ownership_violation: "ownership_violation";
+                    cancelled: "cancelled";
+                }>;
+                frequency: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        timing: z.ZodObject<{
+            durationMs: z.ZodObject<{
+                p50: z.ZodNumber;
+                p75: z.ZodNumber;
+                p90: z.ZodNumber;
+                max: z.ZodNumber;
+                ema: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        confidence: z.ZodObject<{
+            avgConfidence: z.ZodNumber;
+            escalationRate: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    lastUpdated: z.ZodString;
+}, z.core.$strip>;
+export type ExecutionProfileStore = z.infer<typeof executionProfileStoreSchema>;
+export declare const staticConfigBaselineSchema: z.ZodObject<{
+    maxOutputTokens: z.ZodNumber;
+    maxRetries: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+    modelMaxTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type StaticConfigBaseline = z.infer<typeof staticConfigBaselineSchema>;
+export declare const adaptiveConfigSchema: z.ZodObject<{
+    recommendedMaxOutputTokens: z.ZodNullable<z.ZodNumber>;
+    recommendedMaxRetries: z.ZodNullable<z.ZodNumber>;
+    recommendedTimeoutMs: z.ZodNullable<z.ZodNumber>;
+    modelEscalation: z.ZodObject<{
+        recommended: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    basis: z.ZodObject<{
+        sampleSize: z.ZodNumber;
+        profileAge: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AdaptiveConfig = z.infer<typeof adaptiveConfigSchema>;

package/dist/persistence/execution-analytics.js

@@ -0,0 +1,71 @@
+import { z } from 'zod/v4';
+import { workerErrorTypeSchema } from '../runner/runner-system';
+export const distributionSummarySchema = z.object({
+    p50: z.number(),
+    p75: z.number(),
+    p90: z.number(),
+    max: z.number(),
+    ema: z.number(),
+});
+export const errorFrequencySchema = z.object({
+    type: workerErrorTypeSchema,
+    frequency: z.number().min(0).max(1),
+});
+export const executionProfileSchema = z.object({
+    roleId: z.string(),
+    model: z.string(),
+    sampleSize: z.number().int().nonnegative(),
+    lastUpdated: z.string(),
+    tokenUsage: z.object({
+        inputTokens: distributionSummarySchema,
+        outputTokens: distributionSummarySchema,
+    }),
+    reliability: z.object({
+        successRate: z.number().min(0).max(1),
+        failureRate: z.number().min(0).max(1),
+        avgRetries: z.number().nonnegative(),
+        retryableFailureRate: z.number().min(0).max(1),
+        commonErrorTypes: z.array(errorFrequencySchema),
+    }),
+    timing: z.object({
+        durationMs: distributionSummarySchema,
+    }),
+    confidence: z.object({
+        avgConfidence: z.number().min(0).max(1),
+        escalationRate: z.number().min(0).max(1),
+    }),
+});
+export const workerOutcomeRecordSchema = z.object({
+    roleId: z.string(),
+    model: z.string(),
+    inputTokens: z.number().nonnegative(),
+    outputTokens: z.number().nonnegative(),
+    durationMs: z.number().nonnegative(),
+    retryCount: z.number().int().nonnegative(),
+    status: z.enum(['success', 'failure']),
+    errorType: workerErrorTypeSchema.nullable(),
+    confidenceScore: z.number().min(0).max(1).nullable(),
+});
+export const executionProfileStoreSchema = z.object({
+    profiles: z.array(executionProfileSchema),
+    lastUpdated: z.string(),
+});
+export const staticConfigBaselineSchema = z.object({
+    maxOutputTokens: z.number(),
+    maxRetries: z.number(),
+    timeoutMs: z.number(),
+    modelMaxTokens: z.number(),
+});
+export const adaptiveConfigSchema = z.object({
+    recommendedMaxOutputTokens: z.number().nullable(),
+    recommendedMaxRetries: z.number().nullable(),
+    recommendedTimeoutMs: z.number().nullable(),
+    modelEscalation: z.object({
+        recommended: z.boolean(),
+        reason: z.string().nullable(),
+    }),
+    basis: z.object({
+        sampleSize: z.number(),
+        profileAge: z.string(),
+    }),
+});

package/dist/persistence/index.d.ts

@@ -0,0 +1,5 @@
+export * from './execution-analytics';
+export * from './project-context';
+export * from './state-persistence';
+export * from './run-manifest';
+export * from './repository-model';

package/dist/persistence/index.js

@@ -0,0 +1,5 @@
+export * from './execution-analytics';
+export * from './project-context';
+export * from './state-persistence';
+export * from './run-manifest';
+export * from './repository-model';

package/dist/persistence/project-context.d.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod/v4';
+export declare const contextCategorySchema: z.ZodEnum<{
+    codebase: "codebase";
+    run_history: "run_history";
+    preferences: "preferences";
+    analytics: "analytics";
+}>;
+export type ContextCategory = z.infer<typeof contextCategorySchema>;
+export declare const moduleInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    purpose: z.ZodString;
+    keyAbstractions: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ModuleInfo = z.infer<typeof moduleInfoSchema>;
+export declare const patternInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    discoveredInRun: z.ZodString;
+}, z.core.$strip>;
+export type PatternInfo = z.infer<typeof patternInfoSchema>;
+export declare const conventionInfoSchema: z.ZodObject<{
+    rule: z.ZodString;
+    evidence: z.ZodString;
+    discoveredInRun: z.ZodString;
+}, z.core.$strip>;
+export type ConventionInfo = z.infer<typeof conventionInfoSchema>;
+export declare const codebaseContextSchema: z.ZodObject<{
+    projectName: z.ZodString;
+    lastUpdated: z.ZodString;
+    lastRunId: z.ZodString;
+    architecture: z.ZodObject<{
+        summary: z.ZodString;
+        modules: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            purpose: z.ZodString;
+            keyAbstractions: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        patterns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            discoveredInRun: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    conventions: z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        evidence: z.ZodString;
+        discoveredInRun: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CodebaseContext = z.infer<typeof codebaseContextSchema>;
+export declare const runHistoryEntrySchema: z.ZodObject<{
+    runId: z.ZodString;
+    timestamp: z.ZodString;
+    workflowVariant: z.ZodString;
+    taskSummary: z.ZodString;
+    outcome: z.ZodEnum<{
+        escalated: "escalated";
+        completed: "completed";
+        failed: "failed";
+        aborted: "aborted";
+    }>;
+    compressed: z.ZodBoolean;
+    keyFindings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    confidenceScore: z.ZodOptional<z.ZodNumber>;
+    modelUsed: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunHistoryEntry = z.infer<typeof runHistoryEntrySchema>;
+export declare const runHistorySchema: z.ZodObject<{
+    lastUpdated: z.ZodString;
+    runs: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        timestamp: z.ZodString;
+        workflowVariant: z.ZodString;
+        taskSummary: z.ZodString;
+        outcome: z.ZodEnum<{
+            escalated: "escalated";
+            completed: "completed";
+            failed: "failed";
+            aborted: "aborted";
+        }>;
+        compressed: z.ZodBoolean;
+        keyFindings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        confidenceScore: z.ZodOptional<z.ZodNumber>;
+        modelUsed: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunHistory = z.infer<typeof runHistorySchema>;
+export declare const modelCalibrationEntrySchema: z.ZodObject<{
+    roleId: z.ZodString;
+    model: z.ZodString;
+    successRate: z.ZodNumber;
+    avgConfidence: z.ZodNumber;
+    escalationRate: z.ZodNumber;
+    sampleSize: z.ZodNumber;
+}, z.core.$strip>;
+export type ModelCalibrationEntry = z.infer<typeof modelCalibrationEntrySchema>;
+export declare const failurePatternSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    frequency: z.ZodNumber;
+    lastSeen: z.ZodString;
+}, z.core.$strip>;
+export type FailurePattern = z.infer<typeof failurePatternSchema>;
+export declare const projectPreferenceSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodString;
+    discoveredInRun: z.ZodString;
+}, z.core.$strip>;
+export type ProjectPreference = z.infer<typeof projectPreferenceSchema>;
+export declare const learnedPreferencesSchema: z.ZodObject<{
+    lastUpdated: z.ZodString;
+    modelCalibration: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodString;
+        model: z.ZodString;
+        successRate: z.ZodNumber;
+        avgConfidence: z.ZodNumber;
+        escalationRate: z.ZodNumber;
+        sampleSize: z.ZodNumber;
+    }, z.core.$strip>>;
+    failurePatterns: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        frequency: z.ZodNumber;
+        lastSeen: z.ZodString;
+    }, z.core.$strip>>;
+    projectPreferences: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        discoveredInRun: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LearnedPreferences = z.infer<typeof learnedPreferencesSchema>;
+export declare const contextDocumentSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        codebase: "codebase";
+        run_history: "run_history";
+        preferences: "preferences";
+        analytics: "analytics";
+    }>;
+    content: z.ZodUnknown;
+    lastUpdated: z.ZodString;
+    lastRunId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ContextDocument = z.infer<typeof contextDocumentSchema>;
+export declare const contextQuerySchema: z.ZodObject<{
+    categories: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        codebase: "codebase";
+        run_history: "run_history";
+        preferences: "preferences";
+        analytics: "analytics";
+    }>>>;
+    role: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ContextQuery = z.infer<typeof contextQuerySchema>;
+export declare const contextFragmentSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        codebase: "codebase";
+        run_history: "run_history";
+        preferences: "preferences";
+        analytics: "analytics";
+    }>;
+    content: z.ZodString;
+    relevanceScore: z.ZodNumber;
+}, z.core.$strip>;
+export type ContextFragment = z.infer<typeof contextFragmentSchema>;

package/dist/persistence/project-context.js

@@ -0,0 +1,88 @@
+import { z } from 'zod/v4';
+export const contextCategorySchema = z.enum([
+    'codebase',
+    'run_history',
+    'preferences',
+    'analytics',
+]);
+export const moduleInfoSchema = z.object({
+    name: z.string(),
+    purpose: z.string(),
+    keyAbstractions: z.array(z.string()),
+});
+export const patternInfoSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    discoveredInRun: z.string(),
+});
+export const conventionInfoSchema = z.object({
+    rule: z.string(),
+    evidence: z.string(),
+    discoveredInRun: z.string(),
+});
+export const codebaseContextSchema = z.object({
+    projectName: z.string(),
+    lastUpdated: z.string(),
+    lastRunId: z.string(),
+    architecture: z.object({
+        summary: z.string(),
+        modules: z.array(moduleInfoSchema),
+        patterns: z.array(patternInfoSchema),
+    }),
+    conventions: z.array(conventionInfoSchema),
+});
+export const runHistoryEntrySchema = z.object({
+    runId: z.string(),
+    timestamp: z.string(),
+    workflowVariant: z.string(),
+    taskSummary: z.string(),
+    outcome: z.enum(['completed', 'failed', 'aborted', 'escalated']),
+    compressed: z.boolean(),
+    keyFindings: z.array(z.string()).optional(),
+    confidenceScore: z.number().min(0).max(1).optional(),
+    modelUsed: z.string().optional(),
+});
+export const runHistorySchema = z.object({
+    lastUpdated: z.string(),
+    runs: z.array(runHistoryEntrySchema),
+});
+export const modelCalibrationEntrySchema = z.object({
+    roleId: z.string(),
+    model: z.string(),
+    successRate: z.number().min(0).max(1),
+    avgConfidence: z.number().min(0).max(1),
+    escalationRate: z.number().min(0).max(1),
+    sampleSize: z.number().int().nonnegative(),
+});
+export const failurePatternSchema = z.object({
+    pattern: z.string(),
+    frequency: z.number().int().nonnegative(),
+    lastSeen: z.string(),
+});
+export const projectPreferenceSchema = z.object({
+    key: z.string(),
+    value: z.string(),
+    discoveredInRun: z.string(),
+});
+export const learnedPreferencesSchema = z.object({
+    lastUpdated: z.string(),
+    modelCalibration: z.array(modelCalibrationEntrySchema),
+    failurePatterns: z.array(failurePatternSchema),
+    projectPreferences: z.array(projectPreferenceSchema),
+});
+export const contextDocumentSchema = z.object({
+    category: contextCategorySchema,
+    content: z.unknown(),
+    lastUpdated: z.string(),
+    lastRunId: z.string().optional(),
+});
+export const contextQuerySchema = z.object({
+    categories: z.array(contextCategorySchema).optional(),
+    role: z.string().optional(),
+    maxTokens: z.number().optional(),
+});
+export const contextFragmentSchema = z.object({
+    category: contextCategorySchema,
+    content: z.string(),
+    relevanceScore: z.number().min(0).max(1),
+});

package/dist/persistence/repository-model.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod/v4';
+export declare const discoveredRunStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    aborted: "aborted";
+    active: "active";
+}>;
+export type DiscoveredRunStatus = z.infer<typeof discoveredRunStatusSchema>;
+export declare const discoveryResultSchema: z.ZodObject<{
+    found: z.ZodBoolean;
+    repoRoot: z.ZodOptional<z.ZodString>;
+    aiConfigDir: z.ZodOptional<z.ZodString>;
+    gitRoot: z.ZodOptional<z.ZodString>;
+    errors: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type DiscoveryResult = z.infer<typeof discoveryResultSchema>;
+export declare const runDirectoryInfoSchema: z.ZodObject<{
+    runId: z.ZodString;
+    path: z.ZodString;
+    createdAt: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    status: z.ZodEnum<{
+        completed: "completed";
+        aborted: "aborted";
+        active: "active";
+    }>;
+}, z.core.$strip>;
+export type RunDirectoryInfo = z.infer<typeof runDirectoryInfoSchema>;

package/dist/persistence/repository-model.js

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+export const discoveredRunStatusSchema = z.enum(['active', 'completed', 'aborted']);
+export const discoveryResultSchema = z.object({
+    found: z.boolean(),
+    repoRoot: z.string().optional(),
+    aiConfigDir: z.string().optional(),
+    gitRoot: z.string().optional(),
+    errors: z.array(z.string()).readonly().optional(),
+});
+export const runDirectoryInfoSchema = z.object({
+    runId: z.string(),
+    path: z.string(),
+    createdAt: z.string(),
+    sizeBytes: z.number(),
+    status: discoveredRunStatusSchema,
+});