@ai-dev-orchestrator/schemas 0.1.1

package/dist/governance/review-resolution.js

@@ -0,0 +1,67 @@
+import { z } from 'zod/v4';
+import { artifactRefSchema } from '../artifacts/artifact-system';
+export const findingBlockingSchema = z.enum(['must_fix', 'should_fix', 'nit']);
+export const findingCategorySchema = z.enum([
+    'correctness',
+    'completeness',
+    'consistency',
+    'security',
+    'performance',
+    'maintainability',
+    'style',
+    'documentation',
+    'test_coverage',
+    'architecture',
+    'other',
+]);
+export const findingStatusSchema = z.enum([
+    'open',
+    'addressed',
+    'accepted',
+    'rejected',
+    'escalated',
+]);
+export const findingLocationSchema = z.object({
+    artifactRef: artifactRefSchema,
+    section: z.string().optional(),
+    line: z.number().optional(),
+    snippet: z.string().optional(),
+});
+export const findingResolutionSchema = z.object({
+    status: findingStatusSchema,
+    resolvedInArtifact: artifactRefSchema.optional(),
+    resolvedBy: z.string(),
+    rationale: z.string(),
+    timestamp: z.string(),
+});
+export const findingSchema = z.object({
+    id: z.string(),
+    severity: z.string(),
+    blocking: findingBlockingSchema,
+    category: findingCategorySchema,
+    title: z.string(),
+    description: z.string(),
+    location: findingLocationSchema.optional(),
+    suggestedFix: z.string().optional(),
+    status: findingStatusSchema,
+    resolution: findingResolutionSchema.optional(),
+    supersedes: z.string().optional(),
+});
+export const aggregatedFindingsSchema = z.object({
+    total: z.number(),
+    bySeverity: z.record(z.string(), z.number()),
+    byStatus: z.record(z.string(), z.number()),
+    byCategory: z.record(z.string(), z.number()),
+    blocking: z.array(findingSchema).readonly(),
+    nonBlocking: z.array(findingSchema).readonly(),
+});
+export const correlatedFindingSchema = z.object({
+    finding: findingSchema,
+    producedIn: artifactRefSchema,
+    addressedIn: artifactRefSchema.optional(),
+    verifiedIn: artifactRefSchema.optional(),
+});
+export const correlatedFindingsSchema = z.object({
+    findings: z.array(correlatedFindingSchema).readonly(),
+    resolutionRate: z.number(),
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './shared';
+export * from './artifacts';
+export * from './workflow';
+export * from './specification';
+export * from './governance';
+export * from './runner';
+export * from './dashboard';
+export * from './config';
+export * from './observability';
+export * from './persistence';

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from './shared';
+export * from './artifacts';
+export * from './workflow';
+export * from './specification';
+export * from './governance';
+export * from './runner';
+export * from './dashboard';
+export * from './config';
+export * from './observability';
+export * from './persistence';

package/dist/observability/diagnostics.d.ts

@@ -0,0 +1,185 @@
+import { z } from 'zod/v4';
+export declare const diagnosticSeveritySchema: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warning: "warning";
+    hint: "hint";
+}>;
+export type DiagnosticSeverity = z.infer<typeof diagnosticSeveritySchema>;
+export declare const diagnosticEntrySchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+        hint: "hint";
+    }>;
+    code: z.ZodString;
+    message: z.ZodString;
+    subsystem: z.ZodString;
+    context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    timestamp: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DiagnosticEntry = z.infer<typeof diagnosticEntrySchema>;
+export declare const diagnosticReportSummarySchema: z.ZodObject<{
+    totalEntries: z.ZodNumber;
+    errorCount: z.ZodNumber;
+    warningCount: z.ZodNumber;
+    infoCount: z.ZodNumber;
+    hintCount: z.ZodNumber;
+    subsystemsAffected: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DiagnosticReportSummary = z.infer<typeof diagnosticReportSummarySchema>;
+export declare const errorChainEntrySchema: z.ZodObject<{
+    source: z.ZodString;
+    code: z.ZodString;
+    message: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type ErrorChainEntry = z.infer<typeof errorChainEntrySchema>;
+export declare const failureAnalysisSchema: z.ZodObject<{
+    runId: z.ZodString;
+    failedAt: z.ZodString;
+    failedState: z.ZodString;
+    rootCause: z.ZodString;
+    contributingFactors: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    errorChain: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        code: z.ZodString;
+        message: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+    recommendation: z.ZodString;
+}, z.core.$strip>;
+export type FailureAnalysis = z.infer<typeof failureAnalysisSchema>;
+export declare const configurationIssueSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+        hint: "hint";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+    currentValue: z.ZodUnknown;
+    expectedValue: z.ZodOptional<z.ZodUnknown>;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ConfigurationIssue = z.infer<typeof configurationIssueSchema>;
+export declare const configurationInspectionSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+            hint: "hint";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        currentValue: z.ZodUnknown;
+        expectedValue: z.ZodOptional<z.ZodUnknown>;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    checkedAt: z.ZodString;
+}, z.core.$strip>;
+export type ConfigurationInspection = z.infer<typeof configurationInspectionSchema>;
+export declare const subsystemDiagnosticSchema: z.ZodObject<{
+    subsystem: z.ZodString;
+    status: z.ZodString;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+            hint: "hint";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+        subsystem: z.ZodString;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timestamp: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    checkedAt: z.ZodString;
+}, z.core.$strip>;
+export type SubsystemDiagnostic = z.infer<typeof subsystemDiagnosticSchema>;
+export declare const diagnosticReportSchema: z.ZodObject<{
+    generatedAt: z.ZodString;
+    runId: z.ZodNullable<z.ZodString>;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+            hint: "hint";
+        }>;
+        code: z.ZodString;
+        message: z.ZodString;
+        subsystem: z.ZodString;
+        context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timestamp: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    summary: z.ZodObject<{
+        totalEntries: z.ZodNumber;
+        errorCount: z.ZodNumber;
+        warningCount: z.ZodNumber;
+        infoCount: z.ZodNumber;
+        hintCount: z.ZodNumber;
+        subsystemsAffected: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    failureAnalysis: z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        failedAt: z.ZodString;
+        failedState: z.ZodString;
+        rootCause: z.ZodString;
+        contributingFactors: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        errorChain: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>>;
+        recommendation: z.ZodString;
+    }, z.core.$strip>>;
+    configurationInspection: z.ZodNullable<z.ZodObject<{
+        valid: z.ZodBoolean;
+        entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+                hint: "hint";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            currentValue: z.ZodUnknown;
+            expectedValue: z.ZodOptional<z.ZodUnknown>;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        checkedAt: z.ZodString;
+    }, z.core.$strip>>;
+    subsystemDiagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        subsystem: z.ZodString;
+        status: z.ZodString;
+        entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+                hint: "hint";
+            }>;
+            code: z.ZodString;
+            message: z.ZodString;
+            subsystem: z.ZodString;
+            context: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            timestamp: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        checkedAt: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type DiagnosticReport = z.infer<typeof diagnosticReportSchema>;

package/dist/observability/diagnostics.js

@@ -0,0 +1,63 @@
+import { z } from 'zod/v4';
+export const diagnosticSeveritySchema = z.enum(['error', 'warning', 'info', 'hint']);
+export const diagnosticEntrySchema = z.object({
+    severity: diagnosticSeveritySchema,
+    code: z.string(),
+    message: z.string(),
+    subsystem: z.string(),
+    context: z.record(z.string(), z.unknown()),
+    timestamp: z.string(),
+    suggestion: z.string().optional(),
+});
+export const diagnosticReportSummarySchema = z.object({
+    totalEntries: z.number(),
+    errorCount: z.number(),
+    warningCount: z.number(),
+    infoCount: z.number(),
+    hintCount: z.number(),
+    subsystemsAffected: z.array(z.string()).readonly(),
+});
+export const errorChainEntrySchema = z.object({
+    source: z.string(),
+    code: z.string(),
+    message: z.string(),
+    timestamp: z.string(),
+});
+export const failureAnalysisSchema = z.object({
+    runId: z.string(),
+    failedAt: z.string(),
+    failedState: z.string(),
+    rootCause: z.string(),
+    contributingFactors: z.array(z.string()).readonly(),
+    errorChain: z.array(errorChainEntrySchema).readonly(),
+    recommendation: z.string(),
+});
+export const configurationIssueSchema = z.object({
+    severity: diagnosticSeveritySchema,
+    path: z.string(),
+    message: z.string(),
+    currentValue: z.unknown(),
+    expectedValue: z.unknown().optional(),
+    suggestion: z.string().optional(),
+});
+export const configurationInspectionSchema = z.object({
+    valid: z.boolean(),
+    entries: z.array(configurationIssueSchema).readonly(),
+    checkedAt: z.string(),
+});
+export const subsystemDiagnosticSchema = z.object({
+    subsystem: z.string(),
+    status: z.string(),
+    entries: z.array(diagnosticEntrySchema).readonly(),
+    metrics: z.record(z.string(), z.number()),
+    checkedAt: z.string(),
+});
+export const diagnosticReportSchema = z.object({
+    generatedAt: z.string(),
+    runId: z.string().nullable(),
+    entries: z.array(diagnosticEntrySchema).readonly(),
+    summary: diagnosticReportSummarySchema,
+    failureAnalysis: failureAnalysisSchema.nullable(),
+    configurationInspection: configurationInspectionSchema.nullable(),
+    subsystemDiagnostics: z.array(subsystemDiagnosticSchema).readonly(),
+});

package/dist/observability/index.d.ts

@@ -0,0 +1,2 @@
+export * from './metrics';
+export * from './diagnostics';

package/dist/observability/index.js

@@ -0,0 +1,2 @@
+export * from './metrics';
+export * from './diagnostics';

package/dist/observability/metrics.d.ts

@@ -0,0 +1,187 @@
+import { z } from 'zod/v4';
+export declare const metricTypeSchema: z.ZodEnum<{
+    counter: "counter";
+    gauge: "gauge";
+    histogram: "histogram";
+    timer: "timer";
+}>;
+export type MetricType = z.infer<typeof metricTypeSchema>;
+export declare const healthStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    healthy: "healthy";
+    degraded: "degraded";
+    unhealthy: "unhealthy";
+}>;
+export type HealthStatus = z.infer<typeof healthStatusSchema>;
+export declare const metricEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        counter: "counter";
+        gauge: "gauge";
+        histogram: "histogram";
+        timer: "timer";
+    }>;
+    value: z.ZodNumber;
+    timestamp: z.ZodString;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type MetricEntry = z.infer<typeof metricEntrySchema>;
+export declare const metricSeriesSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        counter: "counter";
+        gauge: "gauge";
+        histogram: "histogram";
+        timer: "timer";
+    }>;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            counter: "counter";
+            gauge: "gauge";
+            histogram: "histogram";
+            timer: "timer";
+        }>;
+        value: z.ZodNumber;
+        timestamp: z.ZodString;
+        labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MetricSeries = z.infer<typeof metricSeriesSchema>;
+export declare const metricSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        counter: "counter";
+        gauge: "gauge";
+        histogram: "histogram";
+        timer: "timer";
+    }>;
+    count: z.ZodNumber;
+    total: z.ZodNumber;
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+    mean: z.ZodNumber;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type MetricSummary = z.infer<typeof metricSummarySchema>;
+export declare const healthCheckResultSchema: z.ZodObject<{
+    subsystem: z.ZodString;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>;
+    message: z.ZodString;
+    checkedAt: z.ZodString;
+    durationMs: z.ZodNumber;
+    details: z.ZodObject<{
+        error: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$strip>;
+export type HealthCheckResult = z.infer<typeof healthCheckResultSchema>;
+export declare const subsystemHealthSchema: z.ZodObject<{
+    subsystem: z.ZodString;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>;
+    lastCheckedAt: z.ZodString;
+    consecutiveFailures: z.ZodNumber;
+    checks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        subsystem: z.ZodString;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            healthy: "healthy";
+            degraded: "degraded";
+            unhealthy: "unhealthy";
+        }>;
+        message: z.ZodString;
+        checkedAt: z.ZodString;
+        durationMs: z.ZodNumber;
+        details: z.ZodObject<{
+            error: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SubsystemHealth = z.infer<typeof subsystemHealthSchema>;
+export declare const metricsSnapshotSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    metrics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            counter: "counter";
+            gauge: "gauge";
+            histogram: "histogram";
+            timer: "timer";
+        }>;
+        count: z.ZodNumber;
+        total: z.ZodNumber;
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        mean: z.ZodNumber;
+        labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>>;
+    subsystemHealth: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        subsystem: z.ZodString;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            healthy: "healthy";
+            degraded: "degraded";
+            unhealthy: "unhealthy";
+        }>;
+        lastCheckedAt: z.ZodString;
+        consecutiveFailures: z.ZodNumber;
+        checks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            subsystem: z.ZodString;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                healthy: "healthy";
+                degraded: "degraded";
+                unhealthy: "unhealthy";
+            }>;
+            message: z.ZodString;
+            checkedAt: z.ZodString;
+            durationMs: z.ZodNumber;
+            details: z.ZodObject<{
+                error: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            }, z.core.$catchall<z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MetricsSnapshot = z.infer<typeof metricsSnapshotSchema>;
+export declare const timingMetricSchema: z.ZodObject<{
+    operation: z.ZodString;
+    subsystem: z.ZodString;
+    durationMs: z.ZodNumber;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export type TimingMetric = z.infer<typeof timingMetricSchema>;
+export declare const performanceSnapshotSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    timings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        operation: z.ZodString;
+        subsystem: z.ZodString;
+        durationMs: z.ZodNumber;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>>>;
+    workflowLatencyMs: z.ZodNullable<z.ZodNumber>;
+    stageLatencies: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    eventThroughput: z.ZodNumber;
+    memoryUsageBytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type PerformanceSnapshot = z.infer<typeof performanceSnapshotSchema>;
+export interface HealthProbeConfig {
+    subsystem: string;
+    check: () => Promise<HealthCheckResult>;
+}

package/dist/observability/metrics.js

@@ -0,0 +1,67 @@
+import { z } from 'zod/v4';
+export const metricTypeSchema = z.enum(['counter', 'gauge', 'histogram', 'timer']);
+export const healthStatusSchema = z.enum(['healthy', 'degraded', 'unhealthy', 'unknown']);
+export const metricEntrySchema = z.object({
+    name: z.string(),
+    type: metricTypeSchema,
+    value: z.number(),
+    timestamp: z.string(),
+    labels: z.record(z.string(), z.string()),
+});
+export const metricSeriesSchema = z.object({
+    name: z.string(),
+    type: metricTypeSchema,
+    labels: z.record(z.string(), z.string()),
+    entries: z.array(metricEntrySchema).readonly(),
+});
+export const metricSummarySchema = z.object({
+    name: z.string(),
+    type: metricTypeSchema,
+    count: z.number(),
+    total: z.number(),
+    min: z.number(),
+    max: z.number(),
+    mean: z.number(),
+    labels: z.record(z.string(), z.string()),
+});
+export const healthCheckResultSchema = z.object({
+    subsystem: z.string(),
+    status: healthStatusSchema,
+    message: z.string(),
+    checkedAt: z.string(),
+    durationMs: z.number(),
+    details: z
+        .object({
+        error: z.string().optional(),
+        version: z.union([z.string(), z.number()]).optional(),
+    })
+        .catchall(z.unknown()),
+});
+export const subsystemHealthSchema = z.object({
+    subsystem: z.string(),
+    status: healthStatusSchema,
+    lastCheckedAt: z.string(),
+    consecutiveFailures: z.number(),
+    checks: z.array(healthCheckResultSchema).readonly(),
+});
+export const metricsSnapshotSchema = z.object({
+    timestamp: z.string(),
+    metrics: z.array(metricSummarySchema).readonly(),
+    subsystemHealth: z.array(subsystemHealthSchema).readonly(),
+});
+export const timingMetricSchema = z.object({
+    operation: z.string(),
+    subsystem: z.string(),
+    durationMs: z.number(),
+    startedAt: z.string(),
+    completedAt: z.string(),
+    labels: z.record(z.string(), z.string()),
+});
+export const performanceSnapshotSchema = z.object({
+    timestamp: z.string(),
+    timings: z.array(timingMetricSchema).readonly(),
+    workflowLatencyMs: z.number().nullable(),
+    stageLatencies: z.record(z.string(), z.number()),
+    eventThroughput: z.number(),
+    memoryUsageBytes: z.number().nullable(),
+});