@ai-sdlc/orchestrator 0.1.0

package/dist/state/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * State store types for the SQLite-backed persistence layer.
+ */
+export interface ComplexityProfile {
+    id?: number;
+    repoPath: string;
+    score: number;
+    filesCount?: number;
+    modulesCount?: number;
+    dependencyCount?: number;
+    analyzedAt?: string;
+    rawData?: string;
+    /** JSON-serialized architectural patterns. */
+    architecturalPatterns?: string;
+    /** JSON-serialized hotspot data. */
+    hotspots?: string;
+    /** JSON-serialized module dependency graph. */
+    moduleGraph?: string;
+    /** JSON-serialized convention data. */
+    conventionsData?: string;
+}
+export interface EpisodicRecord {
+    id?: number;
+    issueNumber?: number;
+    prNumber?: number;
+    pipelineType: string;
+    outcome: string;
+    durationMs?: number;
+    filesChanged?: number;
+    errorMessage?: string;
+    metadata?: string;
+    createdAt?: string;
+    agentName?: string;
+    complexityScore?: number;
+    routingStrategy?: string;
+    gatePassCount?: number;
+    gateFailCount?: number;
+    costUsd?: number;
+    isRegression?: number;
+    relatedEpisodes?: string;
+}
+export interface AutonomyLedgerEntry {
+    id?: number;
+    agentName: string;
+    currentLevel: number;
+    totalTasks: number;
+    successCount: number;
+    failureCount: number;
+    lastTaskAt?: string;
+    metrics?: string;
+    prApprovalRate?: number;
+    rollbackCount?: number;
+    securityIncidents?: number;
+    promotedAt?: string;
+    demotedAt?: string;
+    timeAtLevelMs?: number;
+}
+export type PipelineRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface PipelineRun {
+    id?: number;
+    runId: string;
+    issueNumber?: number;
+    prNumber?: number;
+    pipelineType: string;
+    status: PipelineRunStatus;
+    currentStage?: string;
+    startedAt?: string;
+    completedAt?: string;
+    result?: string;
+    gateResults?: string;
+    costUsd?: number;
+    tokensUsed?: number;
+    model?: string;
+    agentName?: string;
+    complexityScore?: number;
+}
+export interface Convention {
+    id?: number;
+    category: string;
+    pattern: string;
+    confidence?: number;
+    examples?: string;
+    detectedAt?: string;
+}
+export interface HotspotRecord {
+    id?: number;
+    repoPath: string;
+    filePath: string;
+    churnRate: number;
+    complexity: number;
+    commitCount?: number;
+    lastModified?: string;
+    note?: string;
+    analyzedAt?: string;
+}
+export interface RoutingDecision {
+    id?: number;
+    issueNumber?: number;
+    taskComplexity: number;
+    codebaseComplexity: number;
+    routingStrategy: string;
+    agentName?: string;
+    reason?: string;
+    decidedAt?: string;
+}
+export interface CostLedgerEntry {
+    id?: number;
+    runId: string;
+    agentName: string;
+    pipelineType: string;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    costUsd?: number;
+    issueNumber?: number;
+    prNumber?: number;
+    stageName?: string;
+    cacheReadTokens?: number;
+    createdAt?: string;
+}
+export interface GateThresholdOverride {
+    id?: number;
+    gateName: string;
+    complexityBand: string;
+    enforcementLevel: string;
+    thresholdOverrides?: string;
+    active?: number;
+    createdAt?: string;
+}
+export type AutonomyEventType = 'promotion' | 'demotion' | 'evaluation' | 'reset';
+export interface AutonomyEvent {
+    id?: number;
+    agentName: string;
+    eventType: AutonomyEventType;
+    fromLevel: number;
+    toLevel: number;
+    trigger?: string;
+    metricsSnapshot?: string;
+    unmetConditions?: string;
+    createdAt?: string;
+}
+export interface HandoffEvent {
+    id?: number;
+    runId: string;
+    fromAgent: string;
+    toAgent: string;
+    payloadHash?: string;
+    validationResult: string;
+    errorMessage?: string;
+    createdAt?: string;
+}
+export type DeploymentRecordState = 'pending' | 'deploying' | 'healthy' | 'unhealthy' | 'rolled-back' | 'failed';
+export interface DeploymentRecord {
+    id?: number;
+    deploymentId: string;
+    targetName: string;
+    provider: string;
+    version: string;
+    environment: string;
+    state: DeploymentRecordState;
+    url?: string;
+    error?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface RolloutStepRecord {
+    id?: number;
+    deploymentId: string;
+    stepNumber: number;
+    weightPercent: number;
+    state: string;
+    metricsSnapshot?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface AuditEntryRecord {
+    id?: number;
+    entryId: string;
+    actor: string;
+    action: string;
+    resourceType?: string;
+    resourceId?: string;
+    detail?: string;
+    hash?: string;
+    previousHash?: string;
+    signature?: string;
+    createdAt?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/state/types.js

@@ -0,0 +1,5 @@
+/**
+ * State store types for the SQLite-backed persistence layer.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/structured-logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Structured logger adapter — wraps the reference implementation's
+ * structured loggers to satisfy the Logger interface with timing.
+ */
+import { createConsoleLogger, createBufferLogger, type LogEntry } from '@ai-sdlc/reference';
+import type { Logger } from './logger.js';
+/**
+ * Create a Logger backed by the reference createConsoleLogger.
+ */
+export declare function createStructuredConsoleLogger(name?: string): Logger;
+/**
+ * Create a Logger backed by the reference createBufferLogger.
+ * Captured entries can be retrieved for assertions.
+ */
+export declare function createStructuredBufferLogger(name?: string): Logger & {
+    getEntries(): LogEntry[];
+    clear(): void;
+};
+export { createConsoleLogger, createBufferLogger };
+//# sourceMappingURL=structured-logger.d.ts.map

package/dist/structured-logger.js

@@ -0,0 +1,64 @@
+/**
+ * Structured logger adapter — wraps the reference implementation's
+ * structured loggers to satisfy the Logger interface with timing.
+ */
+import { createConsoleLogger, createBufferLogger, } from '@ai-sdlc/reference';
+/**
+ * Create a Logger backed by the reference createConsoleLogger.
+ */
+export function createStructuredConsoleLogger(name = 'ai-sdlc') {
+    const structured = createConsoleLogger(name);
+    return wrapStructuredLogger(structured);
+}
+/**
+ * Create a Logger backed by the reference createBufferLogger.
+ * Captured entries can be retrieved for assertions.
+ */
+export function createStructuredBufferLogger(name = 'ai-sdlc') {
+    const buffer = createBufferLogger(name);
+    const logger = wrapStructuredLogger(buffer);
+    return {
+        ...logger,
+        getEntries() {
+            return [...buffer.getEntries()];
+        },
+        clear() {
+            buffer.clear();
+        },
+    };
+}
+function wrapStructuredLogger(structured) {
+    const starts = new Map();
+    const durations = new Map();
+    const pipelineStart = performance.now();
+    return {
+        stage(name) {
+            starts.set(name, performance.now());
+            structured.info(`stage:start:${name}`, { stage: name });
+        },
+        stageEnd(name) {
+            const start = starts.get(name);
+            if (start !== undefined) {
+                const duration = Math.round(performance.now() - start);
+                durations.set(name, duration);
+                structured.info(`stage:end:${name}`, { stage: name, durationMs: duration });
+            }
+        },
+        info(msg) {
+            structured.info(msg);
+        },
+        error(msg) {
+            structured.error(msg);
+        },
+        summary() {
+            const total = Math.round(performance.now() - pipelineStart);
+            const stageTimings = {};
+            for (const [name, ms] of durations) {
+                stageTimings[name] = ms;
+            }
+            structured.info('pipeline-summary', { stages: stageTimings, totalMs: total });
+        },
+    };
+}
+export { createConsoleLogger, createBufferLogger };
+//# sourceMappingURL=structured-logger.js.map

package/dist/task-decomposer.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Task decomposition — splits complex issues into parallelizable subtasks
+ * using deterministic rules based on module boundaries, file type, and concern.
+ *
+ * Design decision D1: Rule-based, not LLM-based. Complexity >= 6 triggers decomposition.
+ */
+import type { ModuleGraph } from './analysis/types.js';
+export interface SubTask {
+    id: string;
+    title: string;
+    description: string;
+    /** Module boundary this subtask targets, if any. */
+    module?: string;
+    /** File patterns this subtask should touch. */
+    filePatterns: string[];
+    /** Concern category. */
+    concern: 'code' | 'test' | 'docs' | 'config' | 'refactor';
+    /** Estimated relative complexity (1-5). */
+    estimatedComplexity: number;
+    /** IDs of subtasks this depends on. */
+    dependsOn: string[];
+}
+export interface TaskGraph {
+    issueNumber: number;
+    issueTitle: string;
+    complexity: number;
+    subtasks: SubTask[];
+    /** Whether decomposition was triggered. */
+    decomposed: boolean;
+}
+export interface DecompositionContext {
+    issueNumber: number;
+    issueTitle: string;
+    issueBody: string;
+    complexity: number;
+    /** Module graph from codebase analysis. */
+    moduleGraph?: ModuleGraph;
+    /** Files mentioned or likely affected. */
+    affectedFiles?: string[];
+}
+export interface DecompositionOptions {
+    /** Minimum complexity score to trigger decomposition. Defaults to 6. */
+    complexityThreshold?: number;
+    /** Maximum subtasks to generate. Defaults to 8. */
+    maxSubtasks?: number;
+}
+/**
+ * Decompose an issue into a task graph of subtasks.
+ * Returns a single-task graph if complexity is below threshold.
+ */
+export declare function decomposeTask(ctx: DecompositionContext, options?: DecompositionOptions): TaskGraph;
+/**
+ * Validate a TaskGraph for consistency (no dangling deps, no cycles).
+ */
+export declare function validateTaskGraph(graph: TaskGraph): string[];
+/**
+ * Get subtasks in execution order (respecting dependencies).
+ * Returns layers: each layer contains tasks that can run in parallel.
+ */
+export declare function getExecutionLayers(graph: TaskGraph): SubTask[][];
+//# sourceMappingURL=task-decomposer.d.ts.map

package/dist/task-decomposer.js

@@ -0,0 +1,265 @@
+/**
+ * Task decomposition — splits complex issues into parallelizable subtasks
+ * using deterministic rules based on module boundaries, file type, and concern.
+ *
+ * Design decision D1: Rule-based, not LLM-based. Complexity >= 6 triggers decomposition.
+ */
+// ── Decomposition Engine ─────────────────────────────────────────────
+const DEFAULT_COMPLEXITY_THRESHOLD = 6;
+const DEFAULT_MAX_SUBTASKS = 8;
+/**
+ * Decompose an issue into a task graph of subtasks.
+ * Returns a single-task graph if complexity is below threshold.
+ */
+export function decomposeTask(ctx, options = {}) {
+    const threshold = options.complexityThreshold ?? DEFAULT_COMPLEXITY_THRESHOLD;
+    const maxSubtasks = options.maxSubtasks ?? DEFAULT_MAX_SUBTASKS;
+    // Below threshold: no decomposition
+    if (ctx.complexity < threshold) {
+        return {
+            issueNumber: ctx.issueNumber,
+            issueTitle: ctx.issueTitle,
+            complexity: ctx.complexity,
+            decomposed: false,
+            subtasks: [
+                {
+                    id: `${ctx.issueNumber}-main`,
+                    title: ctx.issueTitle,
+                    description: ctx.issueBody,
+                    filePatterns: ['**/*'],
+                    concern: 'code',
+                    estimatedComplexity: ctx.complexity,
+                    dependsOn: [],
+                },
+            ],
+        };
+    }
+    const subtasks = [];
+    let taskCounter = 0;
+    const nextId = () => {
+        taskCounter++;
+        return `${ctx.issueNumber}-${taskCounter}`;
+    };
+    // Strategy 1: Split by module boundary
+    if (ctx.moduleGraph && ctx.moduleGraph.modules.length > 1) {
+        const affectedModules = findAffectedModules(ctx.moduleGraph, ctx.affectedFiles);
+        if (affectedModules.length > 1) {
+            // Order modules by dependency: upstream first
+            const ordered = topologicalSort(affectedModules, ctx.moduleGraph);
+            for (const mod of ordered) {
+                if (subtasks.length >= maxSubtasks)
+                    break;
+                const deps = findModuleDependencyTasks(mod, ordered, subtasks, ctx.moduleGraph);
+                subtasks.push({
+                    id: nextId(),
+                    title: `Implement changes in ${mod.name}`,
+                    description: `Apply changes to module "${mod.name}" at ${mod.path}`,
+                    module: mod.name,
+                    filePatterns: [`${mod.path}/**/*`],
+                    concern: 'code',
+                    estimatedComplexity: Math.min(5, Math.ceil(ctx.complexity / ordered.length) + 1),
+                    dependsOn: deps,
+                });
+            }
+        }
+    }
+    // Strategy 2: Split by concern (code vs test vs docs)
+    if (subtasks.length === 0) {
+        const concerns = classifyConcerns(ctx.issueBody, ctx.affectedFiles);
+        for (const concern of concerns) {
+            if (subtasks.length >= maxSubtasks)
+                break;
+            const deps = concern.concern === 'test'
+                ? subtasks.filter((s) => s.concern === 'code').map((s) => s.id)
+                : concern.concern === 'docs'
+                    ? subtasks.filter((s) => s.concern === 'code' || s.concern === 'test').map((s) => s.id)
+                    : [];
+            subtasks.push({
+                id: nextId(),
+                ...concern,
+                dependsOn: deps,
+            });
+        }
+    }
+    // Fallback: single task if strategies yielded nothing
+    if (subtasks.length === 0) {
+        subtasks.push({
+            id: nextId(),
+            title: ctx.issueTitle,
+            description: ctx.issueBody,
+            filePatterns: ['**/*'],
+            concern: 'code',
+            estimatedComplexity: ctx.complexity,
+            dependsOn: [],
+        });
+    }
+    return {
+        issueNumber: ctx.issueNumber,
+        issueTitle: ctx.issueTitle,
+        complexity: ctx.complexity,
+        decomposed: subtasks.length > 1,
+        subtasks,
+    };
+}
+/**
+ * Validate a TaskGraph for consistency (no dangling deps, no cycles).
+ */
+export function validateTaskGraph(graph) {
+    const errors = [];
+    const ids = new Set(graph.subtasks.map((s) => s.id));
+    for (const task of graph.subtasks) {
+        for (const dep of task.dependsOn) {
+            if (!ids.has(dep)) {
+                errors.push(`Task "${task.id}" depends on unknown task "${dep}"`);
+            }
+        }
+    }
+    // Check for cycles
+    const visited = new Set();
+    const visiting = new Set();
+    const taskMap = new Map(graph.subtasks.map((s) => [s.id, s]));
+    function hasCycle(id) {
+        if (visiting.has(id))
+            return true;
+        if (visited.has(id))
+            return false;
+        visiting.add(id);
+        const task = taskMap.get(id);
+        if (task) {
+            for (const dep of task.dependsOn) {
+                if (hasCycle(dep))
+                    return true;
+            }
+        }
+        visiting.delete(id);
+        visited.add(id);
+        return false;
+    }
+    for (const task of graph.subtasks) {
+        visited.clear();
+        visiting.clear();
+        if (hasCycle(task.id)) {
+            errors.push(`Cycle detected involving task "${task.id}"`);
+            break;
+        }
+    }
+    return errors;
+}
+/**
+ * Get subtasks in execution order (respecting dependencies).
+ * Returns layers: each layer contains tasks that can run in parallel.
+ */
+export function getExecutionLayers(graph) {
+    const layers = [];
+    const completed = new Set();
+    const remaining = new Map(graph.subtasks.map((s) => [s.id, s]));
+    while (remaining.size > 0) {
+        const layer = [];
+        for (const [_id, task] of remaining) {
+            if (task.dependsOn.every((dep) => completed.has(dep))) {
+                layer.push(task);
+            }
+        }
+        if (layer.length === 0)
+            break; // No progress = cycle
+        for (const task of layer) {
+            remaining.delete(task.id);
+            completed.add(task.id);
+        }
+        layers.push(layer);
+    }
+    return layers;
+}
+// ── Internal Helpers ──────────────────────────────────────────────────
+function findAffectedModules(graph, files) {
+    if (!files || files.length === 0)
+        return graph.modules;
+    return graph.modules.filter((mod) => files.some((f) => f.startsWith(mod.path) || f.includes(`/${mod.name}/`)));
+}
+function topologicalSort(modules, graph) {
+    const nameSet = new Set(modules.map((m) => m.name));
+    const adjacency = new Map();
+    for (const mod of modules) {
+        adjacency.set(mod.name, []);
+    }
+    for (const edge of graph.edges) {
+        if (nameSet.has(edge.from) && nameSet.has(edge.to)) {
+            adjacency.get(edge.from)?.push(edge.to);
+        }
+    }
+    const sorted = [];
+    const visited = new Set();
+    const modMap = new Map(modules.map((m) => [m.name, m]));
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        for (const dep of adjacency.get(name) ?? []) {
+            visit(dep);
+        }
+        const mod = modMap.get(name);
+        if (mod)
+            sorted.push(mod);
+    }
+    for (const mod of modules) {
+        visit(mod.name);
+    }
+    return sorted;
+}
+function findModuleDependencyTasks(mod, _orderedModules, existingTasks, graph) {
+    const deps = [];
+    for (const edge of graph.edges) {
+        if (edge.from === mod.name) {
+            const depTask = existingTasks.find((t) => t.module === edge.to);
+            if (depTask)
+                deps.push(depTask.id);
+        }
+    }
+    return deps;
+}
+function classifyConcerns(issueBody, files) {
+    const results = [];
+    const hasTests = files?.some((f) => /\.(test|spec)\.[jt]sx?$/.test(f) || f.includes('__tests__'));
+    const hasDocs = files?.some((f) => /\.(md|mdx|rst)$/.test(f) || f.startsWith('docs/'));
+    const hasConfig = files?.some((f) => /\.(json|yaml|yml|toml)$/.test(f) && !f.includes('test'));
+    // Code implementation subtask
+    results.push({
+        title: 'Implement code changes',
+        description: `Implement the core changes described in the issue.\n\n${issueBody.slice(0, 500)}`,
+        filePatterns: ['src/**/*'],
+        concern: 'code',
+        estimatedComplexity: 3,
+    });
+    // Test subtask
+    if (hasTests || issueBody.toLowerCase().includes('test')) {
+        results.push({
+            title: 'Write/update tests',
+            description: 'Write or update tests to cover the code changes.',
+            filePatterns: ['**/*.test.*', '**/*.spec.*', '**/__tests__/**'],
+            concern: 'test',
+            estimatedComplexity: 2,
+        });
+    }
+    // Docs subtask
+    if (hasDocs || issueBody.toLowerCase().includes('document')) {
+        results.push({
+            title: 'Update documentation',
+            description: 'Update documentation to reflect the changes.',
+            filePatterns: ['docs/**/*', '**/*.md'],
+            concern: 'docs',
+            estimatedComplexity: 1,
+        });
+    }
+    // Config subtask
+    if (hasConfig) {
+        results.push({
+            title: 'Update configuration',
+            description: 'Update configuration files as needed.',
+            filePatterns: ['**/*.json', '**/*.yaml', '**/*.yml'],
+            concern: 'config',
+            estimatedComplexity: 1,
+        });
+    }
+    return results;
+}
+//# sourceMappingURL=task-decomposer.js.map

package/dist/telemetry-extended.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extended telemetry integration — covers remaining OTel primitives,
+ * no-op logger, synchronous spans, and core utilities not yet integrated.
+ */
+import { getTracer, getMeter, withSpan, withSpanSync, createNoOpLogger, createConsoleLogger, createBufferLogger, SPAN_NAMES, METRIC_NAMES, ATTRIBUTE_KEYS, AI_SDLC_PREFIX, validate, compareMetric, exceedsSeverity, type StructuredLogger, type BufferLogger, type LogEntry, type LogLevel } from '@ai-sdlc/reference';
+/**
+ * Create a no-op logger (useful for suppressing output in tests).
+ */
+export declare function createSilentLogger(): StructuredLogger;
+/**
+ * Execute a function within a named span synchronously.
+ */
+export declare function withPipelineSpanSync<T>(name: string, attrs: Record<string, string | number | boolean>, fn: () => T): T;
+/**
+ * Get the OpenTelemetry tracer for custom spans.
+ */
+export declare function getPipelineTracer(): import("@opentelemetry/api").Tracer;
+/**
+ * Validate a resource against its JSON Schema.
+ */
+export { validate as validateResourceSchema } from '@ai-sdlc/reference';
+export { getTracer, getMeter, withSpan, withSpanSync, createNoOpLogger, createConsoleLogger, createBufferLogger, SPAN_NAMES, METRIC_NAMES, ATTRIBUTE_KEYS, AI_SDLC_PREFIX, validate, compareMetric, exceedsSeverity, };
+export type { StructuredLogger, BufferLogger, LogEntry, LogLevel };
+//# sourceMappingURL=telemetry-extended.d.ts.map

package/dist/telemetry-extended.js

@@ -0,0 +1,31 @@
+/**
+ * Extended telemetry integration — covers remaining OTel primitives,
+ * no-op logger, synchronous spans, and core utilities not yet integrated.
+ */
+import { getTracer, getMeter, withSpan, withSpanSync, createNoOpLogger, createConsoleLogger, createBufferLogger, SPAN_NAMES, METRIC_NAMES, ATTRIBUTE_KEYS, AI_SDLC_PREFIX, 
+// Core utilities
+validate, compareMetric, exceedsSeverity, } from '@ai-sdlc/reference';
+/**
+ * Create a no-op logger (useful for suppressing output in tests).
+ */
+export function createSilentLogger() {
+    return createNoOpLogger();
+}
+/**
+ * Execute a function within a named span synchronously.
+ */
+export function withPipelineSpanSync(name, attrs, fn) {
+    return withSpanSync(name, attrs, fn);
+}
+/**
+ * Get the OpenTelemetry tracer for custom spans.
+ */
+export function getPipelineTracer() {
+    return getTracer();
+}
+/**
+ * Validate a resource against its JSON Schema.
+ */
+export { validate as validateResourceSchema } from '@ai-sdlc/reference';
+export { getTracer, getMeter, withSpan, withSpanSync, createNoOpLogger, createConsoleLogger, createBufferLogger, SPAN_NAMES, METRIC_NAMES, ATTRIBUTE_KEYS, AI_SDLC_PREFIX, validate, compareMetric, exceedsSeverity, };
+//# sourceMappingURL=telemetry-extended.js.map

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive type re-exports from @ai-sdlc/reference.
+ * Ensures all reference types are accessible through the orchestrator package
+ * for downstream consumers without direct reference dependency.
+ */
+export type { ApiVersion, Metadata, Condition, SecretRef, MetricCondition, Duration, Resource, TriggerFilter, Trigger, Provider, RoutingStrategy, ComplexityThreshold, Routing, Stage, PipelineSpec, PipelinePhase, PipelineStatus, Pipeline, AgentConstraints, HandoffContractRef, Handoff, SkillExample, Skill, AgentCard, AgentRoleSpec, AgentRoleStatus, AgentRole, GateScope, MetricRule, ToolRule, ReviewerRule, DocumentationRule, ProvenanceRule, ExpressionRule, GateRule, EnforcementLevel, Override, RetryPolicy, Evaluation, Gate, QualityGateSpec, QualityGateStatus, QualityGate, Permissions, ApprovalRequirement, Guardrails, MonitoringLevel, AutonomyLevel, PromotionCriteria, DemotionTrigger, AgentAutonomyStatus, AutonomyPolicySpec, AutonomyPolicyStatus, AutonomyPolicy, AdapterInterface, HealthCheck, AdapterBindingSpec, AdapterBindingStatus, AdapterBinding, AnyResource, ResourceKind, ValidationError, } from '@ai-sdlc/reference';
+export type { GateVerdict, DemotionResult, ComplexityFactor, AuthorizationContext, AuthorizationResult, AuthIdentity, AuthenticationResult, Authenticator, MutatingGateContext, ExpressionEvaluator, ExpressionVerdict, LLMEvaluationDimension, LLMEvaluationResult, LLMGateVerdict, } from '@ai-sdlc/reference';
+export type { AgentExecutionState, HandoffValidationError, SchemaResolver, SchemaValidationError, MemoryTier, MemoryEntry, WorkingMemory, ShortTermMemory, LongTermMemory, SharedMemory, EpisodicMemory, } from '@ai-sdlc/reference';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Comprehensive type re-exports from @ai-sdlc/reference.
+ * Ensures all reference types are accessible through the orchestrator package
+ * for downstream consumers without direct reference dependency.
+ */
+export {};
+//# sourceMappingURL=types.js.map