oxe-cc 1.0.0 → 1.2.1

package/packages/runtime/src/decision/decision-engine.ts

@@ -0,0 +1,174 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import type { DecisionMemo } from './decision-memo';
+
+export type DecisionType =
+  | 'proceed'
+  | 'retry'
+  | 'escalate_gate'
+  | 'skip'
+  | 'abort'
+  | 'promote_lesson';
+
+export type DecisionSignal =
+  | 'policy_allowed'
+  | 'policy_denied'
+  | 'gate_pending'
+  | 'gate_approved'
+  | 'evidence_sufficient'
+  | 'evidence_missing'
+  | 'retry_budget_available'
+  | 'retry_budget_exhausted'
+  | 'lesson_match'
+  | 'risk_high';
+
+export type SeniorityLevel = 'junior' | 'standard' | 'senior' | 'expert';
+
+export interface DecisionRecord {
+  decision_id: string;
+  work_item_id: string | null;
+  run_id: string;
+  type: DecisionType;
+  seniority: SeniorityLevel;
+  confidence: number;
+  signals: DecisionSignal[];
+  rationale: string;
+  timestamp: string;
+  memo?: DecisionMemo;
+}
+
+export interface DecisionLog {
+  run_id: string;
+  decisions: DecisionRecord[];
+}
+
+export interface DecisionInput {
+  work_item_id?: string;
+  run_id: string;
+  policy_allowed: boolean;
+  gate_pending: boolean;
+  gate_approved: boolean;
+  retry_count: number;
+  max_retries: number;
+  evidence_count: number;
+  risk_level: 'none' | 'low' | 'medium' | 'high' | 'critical';
+  lesson_match: boolean;
+  memo?: DecisionMemo;
+}
+
+function computeSeniority(confidence: number): SeniorityLevel {
+  if (confidence >= 0.9) return 'expert';
+  if (confidence >= 0.75) return 'senior';
+  if (confidence >= 0.5) return 'standard';
+  return 'junior';
+}
+
+export class DecisionEngine {
+  evaluate(input: DecisionInput): DecisionRecord {
+    const signals: DecisionSignal[] = [];
+    let type: DecisionType = 'proceed';
+    let confidence = 0.8;
+    let rationale = '';
+
+    if (!input.policy_allowed) {
+      signals.push('policy_denied');
+      type = 'abort';
+      confidence = 1.0;
+      rationale = 'Policy denied execution — aborting without retry.';
+    } else {
+      signals.push('policy_allowed');
+
+      if (input.gate_pending && !input.gate_approved) {
+        signals.push('gate_pending');
+        type = 'escalate_gate';
+        confidence = 0.95;
+        rationale = 'Human gate pending — escalating for approval before proceeding.';
+      } else {
+        if (input.gate_approved) signals.push('gate_approved');
+
+        if (input.risk_level === 'high' || input.risk_level === 'critical') {
+          signals.push('risk_high');
+          confidence = Math.max(0.4, confidence - 0.3);
+          rationale += 'High residual risk detected. ';
+        }
+
+        if (input.retry_count >= input.max_retries) {
+          signals.push('retry_budget_exhausted');
+          type = 'abort';
+          confidence = 0.9;
+          rationale += `Retry budget exhausted (${input.retry_count}/${input.max_retries}).`;
+        } else if (input.retry_count > 0) {
+          signals.push('retry_budget_available');
+          type = 'retry';
+          confidence = 0.7;
+          rationale += `Retrying (attempt ${input.retry_count + 1}/${input.max_retries + 1}).`;
+        } else {
+          if (input.evidence_count > 0) {
+            signals.push('evidence_sufficient');
+            confidence = Math.min(1.0, confidence + 0.1);
+          } else {
+            signals.push('evidence_missing');
+            confidence = Math.max(0.3, confidence - 0.2);
+          }
+
+          if (input.lesson_match) {
+            signals.push('lesson_match');
+            type = 'promote_lesson';
+            confidence = Math.min(1.0, confidence + 0.05);
+          }
+
+          if (!rationale) rationale = 'All signals green — proceeding with execution.';
+        }
+      }
+    }
+
+    return {
+      decision_id: `dec-${crypto.randomBytes(4).toString('hex')}`,
+      work_item_id: input.work_item_id ?? null,
+      run_id: input.run_id,
+      type,
+      seniority: computeSeniority(confidence),
+      confidence: Math.round(confidence * 100) / 100,
+      signals,
+      rationale: rationale.trim(),
+      timestamp: new Date().toISOString(),
+      ...(input.memo !== undefined ? { memo: input.memo } : {}),
+    };
+  }
+}
+
+export function appendDecision(projectRoot: string, runId: string, record: DecisionRecord): void {
+  const p = logPath(projectRoot, runId);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+
+  const log = loadDecisionLog(projectRoot, runId) ?? { run_id: runId, decisions: [] };
+  log.decisions.push(record);
+  fs.writeFileSync(p, JSON.stringify(log, null, 2), 'utf8');
+}
+
+export function loadDecisionLog(projectRoot: string, runId: string): DecisionLog | null {
+  const p = logPath(projectRoot, runId);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as DecisionLog;
+  } catch {
+    return null;
+  }
+}
+
+export function queryDecisions(
+  log: DecisionLog,
+  filter: { type?: DecisionType; workItemId?: string; minConfidence?: number }
+): DecisionRecord[] {
+  return log.decisions.filter((d) => {
+    if (filter.type && d.type !== filter.type) return false;
+    if (filter.workItemId && d.work_item_id !== filter.workItemId) return false;
+    if (filter.minConfidence !== undefined && d.confidence < filter.minConfidence) return false;
+    return true;
+  });
+}
+
+function logPath(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'decisions.json');
+}

package/packages/runtime/src/decision/decision-memo.ts

@@ -0,0 +1,211 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+
+export type ChangeStrategy =
+  | 'minimal_patch'
+  | 'isolated_refactor'
+  | 'expand_contract'
+  | 'feature_flag'
+  | 'no_op';
+
+export interface BlastRadiusEstimate {
+  estimated_files: number;
+  subsystems: string[];
+  risk_score: number;
+  reversible: boolean;
+}
+
+export interface RollbackPlan {
+  strategy: 'revert_commit' | 'restore_workspace' | 'undo_patch' | 'no_rollback';
+  steps: string[];
+  estimated_cost: 'low' | 'medium' | 'high';
+  preconditions: string[];
+}
+
+export interface DecisionMemo {
+  memo_id: string;
+  work_item_id: string;
+  run_id: string;
+  problem_summary: string;
+  chosen_strategy: ChangeStrategy;
+  alternatives_rejected: Array<{ strategy: ChangeStrategy; reason: string }>;
+  blast_radius: BlastRadiusEstimate;
+  rollback_plan: RollbackPlan;
+  min_evidence_required: string[];
+  confidence: number;
+  created_at: string;
+}
+
+// ─── BlastRadius estimation ───────────────────────────────────────────────────
+
+function deriveSubsystems(mutationScope: string[]): string[] {
+  const seen = new Set<string>();
+  for (const p of mutationScope) {
+    const parts = p.replace(/\\/g, '/').split('/');
+    if (parts.length >= 2) seen.add(parts[0]);
+    else seen.add(p);
+  }
+  return [...seen];
+}
+
+function estimateRiskScore(mutationScope: string[], retryCount: number, riskLevel: string): number {
+  let score = 0;
+  score += Math.min(0.4, mutationScope.length * 0.05);
+  score += retryCount > 0 ? Math.min(0.2, retryCount * 0.05) : 0;
+  switch (riskLevel) {
+    case 'critical': score += 0.4; break;
+    case 'high': score += 0.3; break;
+    case 'medium': score += 0.15; break;
+    case 'low': score += 0.05; break;
+    default: break;
+  }
+  return Math.min(1, score);
+}
+
+export function buildBlastRadius(
+  mutationScope: string[],
+  retryCount: number,
+  riskLevel: string
+): BlastRadiusEstimate {
+  const risk_score = estimateRiskScore(mutationScope, retryCount, riskLevel);
+  return {
+    estimated_files: mutationScope.length,
+    subsystems: deriveSubsystems(mutationScope),
+    risk_score: Math.round(risk_score * 100) / 100,
+    reversible: riskLevel !== 'critical' && mutationScope.length <= 10,
+  };
+}
+
+// ─── RollbackPlan ─────────────────────────────────────────────────────────────
+
+export function buildRollbackPlan(
+  blastRadius: BlastRadiusEstimate,
+  retryCount: number
+): RollbackPlan {
+  if (blastRadius.risk_score >= 0.7 || !blastRadius.reversible) {
+    return {
+      strategy: 'restore_workspace',
+      steps: ['snapshot workspace before mutation', 'restore snapshot on failure', 'verify clean state'],
+      estimated_cost: 'high',
+      preconditions: ['workspace snapshot available', 'no shared-state mutations'],
+    };
+  }
+  if (retryCount > 1 || blastRadius.estimated_files > 5) {
+    return {
+      strategy: 'revert_commit',
+      steps: ['record commit SHA before change', 'git revert on failure'],
+      estimated_cost: 'medium',
+      preconditions: ['git repo initialized', 'changes committed atomically'],
+    };
+  }
+  return {
+    strategy: 'undo_patch',
+    steps: ['apply inverse patch'],
+    estimated_cost: 'low',
+    preconditions: ['original file state recorded'],
+  };
+}
+
+// ─── StrategySelector ────────────────────────────────────────────────────────
+
+export class StrategySelector {
+  select(mutationScope: string[], retryCount: number, riskLevel: string): ChangeStrategy {
+    if (riskLevel === 'critical') return 'feature_flag';
+    if (retryCount > 1) return 'minimal_patch';
+    if (mutationScope.length > 8) return 'isolated_refactor';
+    if (riskLevel === 'high') return 'feature_flag';
+    if (mutationScope.length > 3) return 'expand_contract';
+    if (mutationScope.length === 0) return 'no_op';
+    return 'minimal_patch';
+  }
+
+  alternatives(chosen: ChangeStrategy, mutationScope: string[], riskLevel: string): Array<{ strategy: ChangeStrategy; reason: string }> {
+    const all: ChangeStrategy[] = ['minimal_patch', 'isolated_refactor', 'expand_contract', 'feature_flag', 'no_op'];
+    return all
+      .filter((s) => s !== chosen)
+      .map((s) => ({ strategy: s, reason: this.rejectionReason(s, chosen, mutationScope, riskLevel) }));
+  }
+
+  private rejectionReason(s: ChangeStrategy, chosen: ChangeStrategy, mutationScope: string[], riskLevel: string): string {
+    switch (s) {
+      case 'no_op': return 'mutation scope is non-empty; no-op would not satisfy requirements';
+      case 'feature_flag': return riskLevel !== 'critical' && riskLevel !== 'high' ? 'risk level does not warrant feature flag overhead' : `${chosen} preferred for scope size`;
+      case 'isolated_refactor': return mutationScope.length <= 8 ? 'scope is small enough for simpler strategy' : `${chosen} preferred`;
+      case 'expand_contract': return 'expand-contract requires coordinated deployment; overhead not justified here';
+      case 'minimal_patch': return `${chosen} preferred due to scope or risk level`;
+      default: return 'not applicable';
+    }
+  }
+}
+
+// ─── Memo builder & persistence ──────────────────────────────────────────────
+
+export interface BuildMemoInput {
+  work_item_id: string;
+  run_id: string;
+  problem_summary: string;
+  mutation_scope: string[];
+  retry_count: number;
+  risk_level: string;
+  min_evidence_required?: string[];
+  confidence?: number;
+}
+
+export function buildMemo(input: BuildMemoInput): DecisionMemo {
+  const selector = new StrategySelector();
+  const chosen = selector.select(input.mutation_scope, input.retry_count, input.risk_level);
+  const blast_radius = buildBlastRadius(input.mutation_scope, input.retry_count, input.risk_level);
+  const rollback_plan = buildRollbackPlan(blast_radius, input.retry_count);
+  const alternatives_rejected = selector.alternatives(chosen, input.mutation_scope, input.risk_level);
+
+  return {
+    memo_id: `memo-${crypto.randomBytes(4).toString('hex')}`,
+    work_item_id: input.work_item_id,
+    run_id: input.run_id,
+    problem_summary: input.problem_summary,
+    chosen_strategy: chosen,
+    alternatives_rejected,
+    blast_radius,
+    rollback_plan,
+    min_evidence_required: input.min_evidence_required ?? [],
+    confidence: input.confidence ?? (1 - blast_radius.risk_score),
+    created_at: new Date().toISOString(),
+  };
+}
+
+function memoDir(projectRoot: string, runId: string): string {
+  return path.join(projectRoot, '.oxe', 'runs', runId, 'memos');
+}
+
+export function saveMemo(projectRoot: string, memo: DecisionMemo): void {
+  const dir = memoDir(projectRoot, memo.run_id);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${memo.memo_id}.json`), JSON.stringify(memo, null, 2), 'utf8');
+}
+
+export function loadMemo(projectRoot: string, runId: string, memoId: string): DecisionMemo | null {
+  const p = path.join(memoDir(projectRoot, runId), `${memoId}.json`);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as DecisionMemo;
+  } catch {
+    return null;
+  }
+}
+
+export function listMemos(projectRoot: string, runId: string): DecisionMemo[] {
+  const dir = memoDir(projectRoot, runId);
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')) as DecisionMemo;
+      } catch {
+        return null;
+      }
+    })
+    .filter((m): m is DecisionMemo => m !== null);
+}

package/packages/runtime/src/decision/index.ts

@@ -0,0 +1,2 @@
+export * from './decision-engine';
+export * from './decision-memo';

package/packages/runtime/src/delivery/index.ts

@@ -1,3 +1,4 @@
 export * from './branch-manager';
 export * from './pr-manager';
 export * from './ci-checks';
+export * from './promotion-pipeline';

package/packages/runtime/src/delivery/promotion-pipeline.ts

@@ -0,0 +1,180 @@
+import path from 'path';
+import fs from 'fs';
+import type { PRManager } from './pr-manager';
+import type { BranchManager } from './branch-manager';
+import type { VerificationManifest, ResidualRiskLedger } from '../verification/verification-manifest';
+import type { RunResult } from '../scheduler/scheduler';
+
+export interface RunPRLink {
+  run_id: string;
+  branch: string;
+  pr_url: string | null;
+  pr_number: number | null;
+  status: 'pending' | 'open' | 'merged' | 'closed' | 'blocked';
+  created_at: string;
+  merged_at: string | null;
+}
+
+export interface PromotionOptions {
+  baseBranch?: string;
+  draftPR?: boolean;
+  autoMerge?: boolean;
+  mergeMethod?: 'merge' | 'squash' | 'rebase';
+}
+
+export type MergeGateVerdict = 'approved' | 'blocked' | 'needs_review';
+
+export interface MergeGateReport {
+  verdict: MergeGateVerdict;
+  reasons: string[];
+  blocking_risks: string[];
+}
+
+export class MergeGateEvaluator {
+  evaluate(
+    runResult: RunResult,
+    manifest: VerificationManifest | null,
+    riskLedger: ResidualRiskLedger | null
+  ): MergeGateReport {
+    const reasons: string[] = [];
+    const blockingRisks: string[] = [];
+
+    if (runResult.failed.length > 0) {
+      reasons.push(`${runResult.failed.length} task(s) failed: ${runResult.failed.join(', ')}`);
+    }
+
+    if (runResult.blocked.length > 0) {
+      reasons.push(`${runResult.blocked.length} task(s) blocked: ${runResult.blocked.join(', ')}`);
+    }
+
+    if (manifest && !manifest.summary.all_passed) {
+      reasons.push(`Verification: ${manifest.summary.fail} check(s) failed, ${manifest.summary.error} error(s)`);
+    }
+
+    if (riskLedger) {
+      const critical = riskLedger.risks.filter((r) => r.severity === 'critical' || r.severity === 'high');
+      for (const risk of critical) {
+        blockingRisks.push(`[${risk.severity.toUpperCase()}] ${risk.description}`);
+      }
+    }
+
+    const hasBlockers = reasons.length > 0 || blockingRisks.length > 0;
+    const verdict: MergeGateVerdict = hasBlockers ? 'blocked' : 'approved';
+
+    return { verdict, reasons, blocking_risks: blockingRisks };
+  }
+}
+
+export class PromotionPipeline {
+  constructor(
+    private readonly projectRoot: string,
+    private readonly branchManager: BranchManager,
+    private readonly prManager: PRManager,
+    private readonly gateEvaluator: MergeGateEvaluator = new MergeGateEvaluator()
+  ) {}
+
+  buildPRBody(
+    runResult: RunResult,
+    manifest: VerificationManifest | null,
+    riskLedger: ResidualRiskLedger | null
+  ): string {
+    const lines: string[] = [];
+    lines.push('## OXE Run Summary');
+    lines.push('');
+    lines.push(`**Run ID:** \`${runResult.run_id}\``);
+    lines.push(`**Status:** ${runResult.status}`);
+    lines.push(`**Completed:** ${runResult.completed.length} tasks`);
+    if (runResult.failed.length > 0) {
+      lines.push(`**Failed:** ${runResult.failed.join(', ')}`);
+    }
+    if (runResult.blocked.length > 0) {
+      lines.push(`**Blocked:** ${runResult.blocked.join(', ')}`);
+    }
+
+    if (manifest) {
+      lines.push('');
+      lines.push('## Verification');
+      lines.push(`- Total: ${manifest.summary.total}`);
+      lines.push(`- Pass: ${manifest.summary.pass}`);
+      lines.push(`- Fail: ${manifest.summary.fail}`);
+      lines.push(`- Skip: ${manifest.summary.skip}`);
+    }
+
+    if (riskLedger && riskLedger.risks.length > 0) {
+      lines.push('');
+      lines.push('## Residual Risks');
+      for (const risk of riskLedger.risks) {
+        lines.push(`- [${risk.severity.toUpperCase()}] ${risk.description}`);
+        if (risk.mitigation) lines.push(`  - Mitigation: ${risk.mitigation}`);
+      }
+    }
+
+    lines.push('');
+    lines.push('---');
+    lines.push('*Generated by OXE Runtime*');
+
+    return lines.join('\n');
+  }
+
+  async promote(
+    runResult: RunResult,
+    manifest: VerificationManifest | null,
+    riskLedger: ResidualRiskLedger | null,
+    opts: PromotionOptions = {}
+  ): Promise<RunPRLink> {
+    const gateReport = this.gateEvaluator.evaluate(runResult, manifest, riskLedger);
+    const link: RunPRLink = {
+      run_id: runResult.run_id,
+      branch: this.branchManager.currentBranch(),
+      pr_url: null,
+      pr_number: null,
+      status: 'pending',
+      created_at: new Date().toISOString(),
+      merged_at: null,
+    };
+
+    if (gateReport.verdict === 'blocked') {
+      link.status = 'blocked';
+      this.savePRLink(runResult.run_id, link);
+      return link;
+    }
+
+    const body = this.buildPRBody(runResult, manifest, riskLedger);
+    const title = `oxe: run ${runResult.run_id} — ${runResult.completed.length} tasks`;
+
+    const prResult = this.prManager.createDraft({
+      title,
+      body,
+      base: opts.baseBranch ?? 'main',
+      draft: opts.draftPR !== false,
+    });
+
+    if (!prResult.success || !prResult.url) {
+      link.status = 'blocked';
+      this.savePRLink(runResult.run_id, link);
+      return link;
+    }
+
+    link.pr_url = prResult.url;
+    link.status = 'open';
+    this.savePRLink(runResult.run_id, link);
+
+    return link;
+  }
+
+  savePRLink(runId: string, link: RunPRLink): void {
+    const p = path.join(this.projectRoot, '.oxe', 'runs', runId, 'pr-link.json');
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(link, null, 2), 'utf8');
+  }
+
+  loadPRLink(runId: string): RunPRLink | null {
+    const p = path.join(this.projectRoot, '.oxe', 'runs', runId, 'pr-link.json');
+    if (!fs.existsSync(p)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(p, 'utf8')) as RunPRLink;
+    } catch {
+      return null;
+    }
+  }
+}

package/packages/runtime/src/index.ts

@@ -21,6 +21,7 @@ export type {
   AcceptanceCheckSuite,
   CheckResult,
 } from './verification/verification-compiler';
+export * from './verification/verification-manifest';
 export * from './policy/index';
 export * from './gate/index';
 export * from './projection/index';
@@ -30,3 +31,7 @@ export * from './plugins/index';
 export * from './delivery/index';
 export * from './context/index';
 export * from './scheduler/multi-agent-coordinator';
+
+// R4 Public ABI — Decision, Audit & Enterprise
+export * from './decision/index';
+export * from './audit/index';

package/packages/runtime/src/plugins/capability-matrix.ts

@@ -0,0 +1,83 @@
+import type { PluginRegistry } from './plugin-registry';
+import { CURRENT_ABI_VERSION } from './plugin-manifest';
+
+export type ApiStability = 'stable' | 'experimental' | 'deprecated';
+
+export interface ProviderCapabilityEntry {
+  name: string;
+  provider_type: 'tool' | 'workspace' | 'verifier' | 'context';
+  stability: ApiStability;
+  since_abi_version: string;
+  deprecated_in?: string;
+  replacement?: string;
+}
+
+export interface CapabilityMatrix {
+  abi_version: string;
+  entries: ProviderCapabilityEntry[];
+}
+
+export function buildMatrix(registry: PluginRegistry): CapabilityMatrix {
+  const entries: ProviderCapabilityEntry[] = [];
+
+  for (const plugin of registry.list()) {
+    const providers = plugin.providers ?? [];
+
+    for (const prov of providers) {
+      let provider_type: ProviderCapabilityEntry['provider_type'];
+      if (prov.startsWith('tool:')) provider_type = 'tool';
+      else if (prov.startsWith('workspace:')) provider_type = 'workspace';
+      else if (prov.startsWith('verifier:')) provider_type = 'verifier';
+      else if (prov.startsWith('context:')) provider_type = 'context';
+      else continue;
+
+      const name = prov.slice(prov.indexOf(':') + 1);
+      entries.push({
+        name,
+        provider_type,
+        stability: 'stable',
+        since_abi_version: CURRENT_ABI_VERSION,
+      });
+    }
+  }
+
+  return { abi_version: CURRENT_ABI_VERSION, entries };
+}
+
+export function getStableEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[] {
+  return matrix.entries.filter((e) => e.stability === 'stable');
+}
+
+export function getExperimentalEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[] {
+  return matrix.entries.filter((e) => e.stability === 'experimental');
+}
+
+export function getDeprecatedEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[] {
+  return matrix.entries.filter((e) => e.stability === 'deprecated');
+}
+
+export function markDeprecated(
+  matrix: CapabilityMatrix,
+  name: string,
+  deprecatedIn: string,
+  replacement?: string
+): CapabilityMatrix {
+  return {
+    ...matrix,
+    entries: matrix.entries.map((e) =>
+      e.name === name
+        ? { ...e, stability: 'deprecated', deprecated_in: deprecatedIn, replacement }
+        : e
+    ),
+  };
+}
+
+export function addEntry(
+  matrix: CapabilityMatrix,
+  entry: ProviderCapabilityEntry
+): CapabilityMatrix {
+  if (matrix.entries.some((e) => e.name === entry.name && e.provider_type === entry.provider_type)) {
+    return matrix;
+  }
+  return { ...matrix, entries: [...matrix.entries, entry] };
+}

package/packages/runtime/src/plugins/index.ts

@@ -1,2 +1,4 @@
 export * from './plugin-abi';
 export * from './plugin-registry';
+export * from './plugin-manifest';
+export * from './capability-matrix';