oxe-cc 1.0.0 → 1.3.0

package/lib/runtime/gate/gate-manager.d.ts

@@ -2,13 +2,25 @@ import type { GateScope, GateDecisionValue } from '../models/gate-decision';
 export interface GateContext {
     work_item_id?: string;
     run_id?: string;
+    action?: string;
     description: string;
     evidence_refs: string[];
     risks: string[];
+    rationale?: string;
+    policy_decision_id?: string | null;
+}
+export interface GateResolutionRecord {
+    decision: GateDecisionValue;
+    actor: string;
+    reason?: string;
+    resolved_at: string;
 }
 export interface GateToken {
     gate_id: string;
     scope: GateScope;
+    run_id: string | null;
+    work_item_id: string | null;
+    action: string | null;
     requested_at: string;
     context: GateContext;
     status: 'pending' | 'resolved';
@@ -16,12 +28,32 @@ export interface GateToken {
     actor?: string;
     reason?: string;
     resolved_at?: string;
+    resolution_history?: GateResolutionRecord[];
 }
 export interface GateResolution {
     decision: GateDecisionValue;
     actor: string;
     reason?: string;
 }
+export interface GateQuery {
+    run_id?: string | null;
+    status?: 'pending' | 'stale' | 'resolved' | 'all';
+    scope?: GateScope;
+    work_item_id?: string | null;
+    action?: string | null;
+    gate_sla_hours?: number;
+}
+export interface GateQueueSnapshot {
+    total: number;
+    gate_sla_hours: number;
+    pending: GateToken[];
+    stale_pending: GateToken[];
+    staleCount: number;
+    resolved_recent: GateToken[];
+    byRun: Record<string, number>;
+    byScope: Record<string, number>;
+    all: GateToken[];
+}
 export declare class GateManager {
     private readonly projectRoot;
     private readonly sessionId;
@@ -34,6 +66,15 @@ export declare class GateManager {
     resolve(token: GateToken, resolution: GateResolution): Promise<GateToken>;
     isPending(scope: GateScope): boolean;
     listPending(): GateToken[];
+    listResolved(): GateToken[];
+    listPendingByRun(runId?: string): GateToken[];
+    listPendingForWorkItem(workItemId: string): GateToken[];
+    stalePending(maxAgeHours?: number): GateToken[];
+    listRecentResolved(maxAgeHours?: number): GateToken[];
     listAll(): GateToken[];
     get(gateId: string): GateToken | null;
+    filter(query?: GateQuery): GateToken[];
+    snapshot(maxAgeHours?: number, query?: Omit<GateQuery, 'gate_sla_hours'>): GateQueueSnapshot;
 }
+export declare function listPendingGates(manager: GateManager, runId?: string, query?: Omit<GateQuery, 'run_id'>): GateQueueSnapshot;
+export declare function resolveGate(manager: GateManager, gateId: string, resolution: GateResolution): Promise<GateToken>;

package/lib/runtime/gate/gate-manager.js

@@ -4,10 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GateManager = void 0;
+exports.listPendingGates = listPendingGates;
+exports.resolveGate = resolveGate;
 const crypto_1 = __importDefault(require("crypto"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const bus_1 = require("../events/bus");
+function isStaleGate(gate, maxAgeHours) {
+    const cutoff = Date.now() - maxAgeHours * 60 * 60 * 1000;
+    const requested = Date.parse(gate.requested_at);
+    return Number.isFinite(requested) && requested <= cutoff;
+}
+function wasResolvedRecently(gate, maxAgeHours) {
+    const cutoff = Date.now() - maxAgeHours * 60 * 60 * 1000;
+    const resolved = Date.parse(gate.resolved_at || '');
+    return Number.isFinite(resolved) && resolved >= cutoff;
+}
 class GateManager {
     constructor(projectRoot, sessionId, runId) {
         this.projectRoot = projectRoot;
@@ -40,9 +52,13 @@ class GateManager {
         const token = {
             gate_id: `gate-${crypto_1.default.randomBytes(4).toString('hex')}`,
             scope,
+            run_id: ctx.run_id ?? this.runId,
+            work_item_id: ctx.work_item_id ?? null,
+            action: ctx.action ?? null,
             requested_at: new Date().toISOString(),
             context: ctx,
             status: 'pending',
+            resolution_history: [],
         };
         const gates = this.readGates();
         gates.push(token);
@@ -54,9 +70,12 @@ class GateManager {
             payload: {
                 gate_id: token.gate_id,
                 scope,
+                action: token.action,
                 description: ctx.description,
                 evidence_refs: ctx.evidence_refs,
                 risks: ctx.risks,
+                rationale: ctx.rationale ?? null,
+                policy_decision_id: ctx.policy_decision_id ?? null,
             },
         });
         return token;
@@ -66,13 +85,23 @@ class GateManager {
         const idx = gates.findIndex((g) => g.gate_id === token.gate_id);
         if (idx === -1)
             throw new Error(`Gate ${token.gate_id} not found`);
+        const resolvedAt = new Date().toISOString();
         const resolved = {
             ...gates[idx],
             status: 'resolved',
             decision: resolution.decision,
             actor: resolution.actor,
             reason: resolution.reason ?? undefined,
-            resolved_at: new Date().toISOString(),
+            resolved_at: resolvedAt,
+            resolution_history: [
+                ...(Array.isArray(gates[idx].resolution_history) ? gates[idx].resolution_history : []),
+                {
+                    decision: resolution.decision,
+                    actor: resolution.actor,
+                    reason: resolution.reason ?? undefined,
+                    resolved_at: resolvedAt,
+                },
+            ],
         };
         gates[idx] = resolved;
         this.writeGates(gates);
@@ -82,8 +111,10 @@ class GateManager {
             payload: {
                 gate_id: token.gate_id,
                 scope: token.scope,
+                action: token.action,
                 decision: resolution.decision,
                 actor: resolution.actor,
+                reason: resolution.reason ?? null,
             },
         });
         return resolved;
@@ -94,11 +125,87 @@ class GateManager {
     listPending() {
         return this.readGates().filter((g) => g.status === 'pending');
     }
+    listResolved() {
+        return this.readGates().filter((g) => g.status === 'resolved');
+    }
+    listPendingByRun(runId = this.runId) {
+        return this.readGates().filter((g) => g.status === 'pending' && g.run_id === runId);
+    }
+    listPendingForWorkItem(workItemId) {
+        return this.readGates().filter((g) => g.status === 'pending' && g.work_item_id === workItemId);
+    }
+    stalePending(maxAgeHours = 24) {
+        return this.listPending().filter((gate) => isStaleGate(gate, maxAgeHours));
+    }
+    listRecentResolved(maxAgeHours = 24) {
+        return this.listResolved().filter((gate) => wasResolvedRecently(gate, maxAgeHours));
+    }
     listAll() {
         return this.readGates();
     }
     get(gateId) {
         return this.readGates().find((g) => g.gate_id === gateId) ?? null;
     }
+    filter(query = {}) {
+        const all = this.readGates();
+        const sla = query.gate_sla_hours ?? 24;
+        return all.filter((gate) => {
+            if (query.run_id && gate.run_id !== query.run_id)
+                return false;
+            if (query.scope && gate.scope !== query.scope)
+                return false;
+            if (query.work_item_id && gate.work_item_id !== query.work_item_id)
+                return false;
+            if (query.action && gate.action !== query.action)
+                return false;
+            if (query.status && query.status !== 'all') {
+                if (query.status === 'stale') {
+                    if (!(gate.status === 'pending' && isStaleGate(gate, sla)))
+                        return false;
+                }
+                else if (gate.status !== query.status) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    snapshot(maxAgeHours = 24, query = {}) {
+        const all = this.filter({ ...query, gate_sla_hours: maxAgeHours });
+        const pending = all.filter((gate) => gate.status === 'pending');
+        const stale_pending = pending.filter((gate) => isStaleGate(gate, maxAgeHours));
+        const resolved_recent = all.filter((gate) => gate.status === 'resolved' && wasResolvedRecently(gate, maxAgeHours));
+        const byRun = {};
+        const byScope = {};
+        for (const gate of all) {
+            const runKey = gate.run_id || 'unscoped';
+            const scopeKey = gate.scope || 'unknown';
+            byRun[runKey] = (byRun[runKey] || 0) + 1;
+            byScope[scopeKey] = (byScope[scopeKey] || 0) + 1;
+        }
+        return {
+            total: all.length,
+            gate_sla_hours: maxAgeHours,
+            pending,
+            stale_pending,
+            staleCount: stale_pending.length,
+            resolved_recent,
+            byRun,
+            byScope,
+            all,
+        };
+    }
 }
 exports.GateManager = GateManager;
+function listPendingGates(manager, runId, query = {}) {
+    return manager.snapshot(query.gate_sla_hours ?? 24, {
+        ...query,
+        run_id: runId ?? undefined,
+    });
+}
+async function resolveGate(manager, gateId, resolution) {
+    const token = manager.get(gateId);
+    if (!token)
+        throw new Error(`Gate ${gateId} not found`);
+    return manager.resolve(token, resolution);
+}

package/lib/runtime/index.d.ts

@@ -5,8 +5,9 @@ export * from './compiler/index';
 export * from './scheduler/index';
 export * from './workspace/index';
 export * from './evidence/index';
-export { compile as compileVerification, runCheck, runSuite, summarizeSuite, } from './verification/verification-compiler';
-export type { CheckType, AcceptanceCheck, AcceptanceCheckSuite, CheckResult, } from './verification/verification-compiler';
+export { compile as compileVerification, runCheck, runSuite, executeSuite, verifyRun, summarizeSuite, } from './verification/verification-compiler';
+export type { CheckType, AcceptanceCheck, AcceptanceCheckSuite, CheckResult, ExecutedVerificationSuite, VerifyRunResult, } from './verification/verification-compiler';
+export * from './verification/verification-manifest';
 export * from './policy/index';
 export * from './gate/index';
 export * from './projection/index';
@@ -14,3 +15,5 @@ export * from './plugins/index';
 export * from './delivery/index';
 export * from './context/index';
 export * from './scheduler/multi-agent-coordinator';
+export * from './decision/index';
+export * from './audit/index';

package/lib/runtime/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeSuite = exports.runSuite = exports.runCheck = exports.compileVerification = void 0;
+exports.summarizeSuite = exports.verifyRun = exports.executeSuite = exports.runSuite = exports.runCheck = exports.compileVerification = void 0;
 // R1 Public ABI — OXE Runtime Foundation
 __exportStar(require("./models/index"), exports);
 __exportStar(require("./events/index"), exports);
@@ -29,7 +29,10 @@ var verification_compiler_1 = require("./verification/verification-compiler");
 Object.defineProperty(exports, "compileVerification", { enumerable: true, get: function () { return verification_compiler_1.compile; } });
 Object.defineProperty(exports, "runCheck", { enumerable: true, get: function () { return verification_compiler_1.runCheck; } });
 Object.defineProperty(exports, "runSuite", { enumerable: true, get: function () { return verification_compiler_1.runSuite; } });
+Object.defineProperty(exports, "executeSuite", { enumerable: true, get: function () { return verification_compiler_1.executeSuite; } });
+Object.defineProperty(exports, "verifyRun", { enumerable: true, get: function () { return verification_compiler_1.verifyRun; } });
 Object.defineProperty(exports, "summarizeSuite", { enumerable: true, get: function () { return verification_compiler_1.summarizeSuite; } });
+__exportStar(require("./verification/verification-manifest"), exports);
 __exportStar(require("./policy/index"), exports);
 __exportStar(require("./gate/index"), exports);
 __exportStar(require("./projection/index"), exports);
@@ -38,3 +41,6 @@ __exportStar(require("./plugins/index"), exports);
 __exportStar(require("./delivery/index"), exports);
 __exportStar(require("./context/index"), exports);
 __exportStar(require("./scheduler/multi-agent-coordinator"), exports);
+// R4 Public ABI — Decision, Audit & Enterprise
+__exportStar(require("./decision/index"), exports);
+__exportStar(require("./audit/index"), exports);

package/lib/runtime/models/gate-decision.d.ts

@@ -1,8 +1,11 @@
 export type GateDecisionValue = 'approved' | 'rejected' | 'approved_with_caveats' | 'needs_more_evidence';
-export type GateScope = 'plan_approval' | 'critical_mutation' | 'security' | 'pr_promotion' | 'merge';
+export type GateScope = 'plan_approval' | 'critical_mutation' | 'security' | 'pr_promotion' | 'remote_promotion' | 'merge';
 export interface GateDecision {
     gate_id: string;
     scope: GateScope;
+    run_id?: string | null;
+    work_item_id?: string | null;
+    action?: string | null;
     decision: GateDecisionValue;
     actor: string;
     reason: string | null;

package/lib/runtime/models/workspace.d.ts

@@ -1,8 +1,10 @@
 export type WorkspaceStrategy = 'inplace' | 'git_worktree' | 'ephemeral_container';
 export type WorkspaceStatus = 'allocating' | 'ready' | 'dirty' | 'disposed' | 'error';
+export type WorkspaceIsolationLevel = 'shared' | 'isolated';
 export interface Workspace {
     workspace_id: string;
     strategy: WorkspaceStrategy;
+    isolation_level: WorkspaceIsolationLevel;
     base_commit: string | null;
     branch: string | null;
     container_ref: string | null;
@@ -12,6 +14,7 @@ export interface Workspace {
 export interface WorkspaceLease {
     workspace_id: string;
     strategy: WorkspaceStrategy;
+    isolation_level: WorkspaceIsolationLevel;
     branch: string | null;
     base_commit: string | null;
     root_path: string;

package/lib/runtime/plugins/capability-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { OxePlugin } from './plugin-abi';
+interface CapabilityManifest {
+    id: string;
+    entrypoint: string | null;
+    sideEffects: string[];
+    evidenceOutputs: string[];
+    checkTypes: string[];
+    dir: string;
+}
+export declare function createCapabilityPlugin(projectRoot: string, manifest: CapabilityManifest): OxePlugin;
+export declare function loadCapabilityPlugins(projectRoot: string): OxePlugin[];
+export {};

package/lib/runtime/plugins/capability-adapter.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCapabilityPlugin = createCapabilityPlugin;
+exports.loadCapabilityPlugins = loadCapabilityPlugins;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const plugin_manifest_1 = require("./plugin-manifest");
+function parseFrontmatter(text) {
+    const match = String(text || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const out = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const idx = trimmed.indexOf(':');
+        if (idx === -1)
+            continue;
+        out[trimmed.slice(0, idx).trim()] = trimmed.slice(idx + 1).trim();
+    }
+    return out;
+}
+function parseArrayField(value) {
+    const raw = String(value || '').trim();
+    if (!raw || raw === '[]')
+        return [];
+    if (/^\[.*\]$/.test(raw)) {
+        return raw
+            .slice(1, -1)
+            .split(',')
+            .map((item) => item.trim().replace(/^['"`]|['"`]$/g, ''))
+            .filter(Boolean);
+    }
+    return raw.split(',').map((item) => item.trim()).filter(Boolean);
+}
+function loadCapabilityManifests(projectRoot) {
+    const capabilitiesDir = path_1.default.join(projectRoot, '.oxe', 'capabilities');
+    if (!fs_1.default.existsSync(capabilitiesDir))
+        return [];
+    return fs_1.default
+        .readdirSync(capabilitiesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
+        const dir = path_1.default.join(capabilitiesDir, entry.name);
+        const manifestPath = path_1.default.join(dir, 'CAPABILITY.md');
+        if (!fs_1.default.existsSync(manifestPath))
+            return null;
+        const raw = fs_1.default.readFileSync(manifestPath, 'utf8');
+        const fm = parseFrontmatter(raw);
+        const id = String(fm.id || '').trim();
+        if (!id)
+            return null;
+        return {
+            id,
+            entrypoint: String(fm.entrypoint || '').trim() || null,
+            sideEffects: parseArrayField(fm.side_effects),
+            evidenceOutputs: parseArrayField(fm.evidence_outputs),
+            checkTypes: parseArrayField(fm.check_types || fm.supports_checks),
+            dir,
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+function resolveEntrypoint(projectRoot, manifest) {
+    if (!manifest.entrypoint)
+        return null;
+    if (path_1.default.isAbsolute(manifest.entrypoint))
+        return manifest.entrypoint;
+    const capabilityRelative = path_1.default.join(manifest.dir, manifest.entrypoint);
+    if (fs_1.default.existsSync(capabilityRelative))
+        return capabilityRelative;
+    const projectRelative = path_1.default.join(projectRoot, manifest.entrypoint);
+    if (fs_1.default.existsSync(projectRelative))
+        return projectRelative;
+    return capabilityRelative;
+}
+function resolveEvidencePaths(projectRoot, manifest) {
+    return manifest.evidenceOutputs
+        .map((entry) => {
+        const capabilityRelative = path_1.default.join(manifest.dir, entry);
+        if (fs_1.default.existsSync(capabilityRelative))
+            return path_1.default.relative(projectRoot, capabilityRelative);
+        const projectRelative = path_1.default.join(projectRoot, entry);
+        if (fs_1.default.existsSync(projectRelative))
+            return path_1.default.relative(projectRoot, projectRelative);
+        return path_1.default.relative(projectRoot, projectRelative);
+    })
+        .map((entry) => entry.replace(/\\/g, '/'));
+}
+function inferToolKind(sideEffects) {
+    if (sideEffects.some((effect) => /db|infra|network|external/i.test(effect)))
+        return 'external_operation';
+    if (sideEffects.some((effect) => /write|mutat|git/i.test(effect)))
+        return 'mutation';
+    if (sideEffects.some((effect) => /verify|test|evidence/i.test(effect)))
+        return 'verification';
+    if (sideEffects.some((effect) => /analysis|scan|read/i.test(effect)))
+        return 'analysis';
+    return 'read';
+}
+function buildToolProvider(projectRoot, manifest) {
+    return {
+        name: manifest.id,
+        kind: inferToolKind(manifest.sideEffects),
+        idempotent: !manifest.sideEffects.some((effect) => /write|mutat|git|db|infra/i.test(effect)),
+        supports(actionType) {
+            return actionType === manifest.id || actionType === `capability:${manifest.id}`;
+        },
+        async invoke(input) {
+            const entrypoint = resolveEntrypoint(projectRoot, manifest);
+            if (!entrypoint) {
+                return {
+                    success: false,
+                    output: '',
+                    evidence_paths: [],
+                    side_effects_applied: [],
+                    error: `Capability ${manifest.id} does not declare an entrypoint`,
+                };
+            }
+            const ext = path_1.default.extname(entrypoint).toLowerCase();
+            const env = {
+                ...process.env,
+                OXE_CAPABILITY_INPUT: JSON.stringify(input.params || {}),
+                OXE_CAPABILITY_RUN_ID: input.run_id,
+                OXE_CAPABILITY_WORK_ITEM_ID: input.work_item_id,
+                OXE_CAPABILITY_ATTEMPT_ID: input.attempt_id,
+                OXE_CAPABILITY_WORKSPACE_ROOT: input.workspace_root,
+            };
+            let program = entrypoint;
+            let args = [];
+            if (ext === '.js' || ext === '.cjs' || ext === '.mjs') {
+                program = process.execPath;
+                args = [entrypoint];
+            }
+            else if (ext === '.ps1') {
+                program = 'powershell';
+                args = ['-File', entrypoint];
+            }
+            const result = (0, child_process_1.spawnSync)(program, args, {
+                cwd: projectRoot,
+                encoding: 'utf8',
+                env,
+            });
+            return {
+                success: result.status === 0 && !result.error,
+                output: [result.stdout || '', result.stderr || ''].filter(Boolean).join('\n').trim(),
+                evidence_paths: resolveEvidencePaths(projectRoot, manifest),
+                side_effects_applied: manifest.sideEffects,
+                error: result.error ? String(result.error) : result.status === 0 ? undefined : (result.stderr || result.stdout || `Capability exited with status ${result.status}`),
+            };
+        },
+    };
+}
+function buildVerifierProvider(projectRoot, manifest) {
+    if (!manifest.checkTypes.length)
+        return null;
+    return {
+        name: `${manifest.id}-verifier`,
+        supports(checkType) {
+            return manifest.checkTypes.includes(checkType);
+        },
+        async execute(input) {
+            const tool = await buildToolProvider(projectRoot, manifest).invoke({
+                action_type: `verify:${input.check_type}`,
+                work_item_id: input.work_item_id,
+                run_id: input.work_item_id,
+                attempt_id: `${input.work_item_id}-verify`,
+                params: {
+                    check_id: input.check_id,
+                    check_type: input.check_type,
+                    command: input.command,
+                    evidence_dir: input.evidence_dir,
+                },
+                workspace_root: input.workspace_root,
+            });
+            return {
+                verification_id: `vr-${manifest.id}-${input.check_id}`,
+                work_item_id: input.work_item_id,
+                check_id: input.check_id,
+                status: tool.success ? 'pass' : 'fail',
+                evidence_refs: tool.evidence_paths,
+                summary: tool.error || tool.output || null,
+            };
+        },
+    };
+}
+function createCapabilityPlugin(projectRoot, manifest) {
+    const verifierProvider = buildVerifierProvider(projectRoot, manifest);
+    return {
+        name: `capability:${manifest.id}`,
+        version: '0.0.0',
+        abi_version: plugin_manifest_1.CURRENT_ABI_VERSION,
+        toolProviders: [buildToolProvider(projectRoot, manifest)],
+        verifierProviders: verifierProvider ? [verifierProvider] : [],
+    };
+}
+function loadCapabilityPlugins(projectRoot) {
+    return loadCapabilityManifests(projectRoot).map((manifest) => createCapabilityPlugin(projectRoot, manifest));
+}

package/lib/runtime/plugins/capability-matrix.d.ts

@@ -0,0 +1,25 @@
+import type { PluginRegistry } from './plugin-registry';
+export type ApiStability = 'stable' | 'experimental' | 'deprecated';
+export interface ProviderCapabilityEntry {
+    plugin: string;
+    name: string;
+    capability: string;
+    provider_type: 'tool' | 'workspace' | 'verifier' | 'context';
+    stability: ApiStability;
+    abi_version: string;
+    since_abi_version: string;
+    supported: string[];
+    fallback_available: boolean;
+    deprecated_in?: string;
+    replacement?: string;
+}
+export interface CapabilityMatrix {
+    abi_version: string;
+    entries: ProviderCapabilityEntry[];
+}
+export declare function buildMatrix(registry: PluginRegistry): CapabilityMatrix;
+export declare function getStableEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[];
+export declare function getExperimentalEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[];
+export declare function getDeprecatedEntries(matrix: CapabilityMatrix): ProviderCapabilityEntry[];
+export declare function markDeprecated(matrix: CapabilityMatrix, name: string, deprecatedIn: string, replacement?: string): CapabilityMatrix;
+export declare function addEntry(matrix: CapabilityMatrix, entry: ProviderCapabilityEntry): CapabilityMatrix;

package/lib/runtime/plugins/capability-matrix.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMatrix = buildMatrix;
+exports.getStableEntries = getStableEntries;
+exports.getExperimentalEntries = getExperimentalEntries;
+exports.getDeprecatedEntries = getDeprecatedEntries;
+exports.markDeprecated = markDeprecated;
+exports.addEntry = addEntry;
+const plugin_manifest_1 = require("./plugin-manifest");
+function buildMatrix(registry) {
+    const entries = [];
+    for (const plugin of registry.snapshot()) {
+        for (const provider of plugin.toolProviders) {
+            entries.push({
+                plugin: plugin.name,
+                name: provider.name,
+                capability: provider.name,
+                provider_type: 'tool',
+                stability: 'stable',
+                abi_version: plugin.abi_version ?? plugin_manifest_1.CURRENT_ABI_VERSION,
+                since_abi_version: plugin_manifest_1.CURRENT_ABI_VERSION,
+                supported: ['read_code', 'generate_patch', 'run_tests', 'collect_evidence', 'custom'].filter((action) => registry.toolProviderFor(action)?.name === provider.name),
+                fallback_available: true,
+            });
+        }
+        for (const provider of plugin.workspaceProviders) {
+            entries.push({
+                plugin: plugin.name,
+                name: provider.name,
+                capability: provider.name,
+                provider_type: 'workspace',
+                stability: 'stable',
+                abi_version: plugin.abi_version ?? plugin_manifest_1.CURRENT_ABI_VERSION,
+                since_abi_version: plugin_manifest_1.CURRENT_ABI_VERSION,
+                supported: [provider.name],
+                fallback_available: true,
+            });
+        }
+        for (const provider of plugin.verifierProviders) {
+            entries.push({
+                plugin: plugin.name,
+                name: provider.name,
+                capability: provider.name,
+                provider_type: 'verifier',
+                stability: 'stable',
+                abi_version: plugin.abi_version ?? plugin_manifest_1.CURRENT_ABI_VERSION,
+                since_abi_version: plugin_manifest_1.CURRENT_ABI_VERSION,
+                supported: ['unit', 'integration', 'smoke', 'policy', 'security', 'custom'].filter((checkType) => registry.verifierProviderFor(checkType)?.name === provider.name),
+                fallback_available: true,
+            });
+        }
+        for (const provider of plugin.contextProviders) {
+            entries.push({
+                plugin: plugin.name,
+                name: provider.name,
+                capability: provider.name,
+                provider_type: 'context',
+                stability: 'stable',
+                abi_version: plugin.abi_version ?? plugin_manifest_1.CURRENT_ABI_VERSION,
+                since_abi_version: plugin_manifest_1.CURRENT_ABI_VERSION,
+                supported: [provider.name],
+                fallback_available: false,
+            });
+        }
+    }
+    return { abi_version: plugin_manifest_1.CURRENT_ABI_VERSION, entries };
+}
+function getStableEntries(matrix) {
+    return matrix.entries.filter((e) => e.stability === 'stable');
+}
+function getExperimentalEntries(matrix) {
+    return matrix.entries.filter((e) => e.stability === 'experimental');
+}
+function getDeprecatedEntries(matrix) {
+    return matrix.entries.filter((e) => e.stability === 'deprecated');
+}
+function markDeprecated(matrix, name, deprecatedIn, replacement) {
+    return {
+        ...matrix,
+        entries: matrix.entries.map((e) => e.name === name
+            ? { ...e, stability: 'deprecated', deprecated_in: deprecatedIn, replacement }
+            : e),
+    };
+}
+function addEntry(matrix, entry) {
+    if (matrix.entries.some((e) => e.name === entry.name && e.provider_type === entry.provider_type)) {
+        return matrix;
+    }
+    return { ...matrix, entries: [...matrix.entries, entry] };
+}

package/lib/runtime/plugins/index.d.ts

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

package/lib/runtime/plugins/index.js

@@ -16,3 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./plugin-abi"), exports);
 __exportStar(require("./plugin-registry"), exports);
+__exportStar(require("./plugin-manifest"), exports);
+__exportStar(require("./capability-matrix"), exports);
+__exportStar(require("./capability-adapter"), exports);