oxe-cc 1.0.0 → 1.2.1

package/lib/runtime/audit/audit-trail.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditTrail = void 0;
+exports.createQuota = createQuota;
+exports.checkQuota = checkQuota;
+exports.consumeQuota = consumeQuota;
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const ACTION_SEVERITY = {
+    run_started: 'info',
+    run_completed: 'info',
+    run_paused: 'info',
+    run_recovered: 'warn',
+    gate_requested: 'warn',
+    gate_resolved: 'info',
+    policy_denied: 'warn',
+    plugin_registered: 'info',
+    plugin_invoked: 'info',
+    secret_accessed: 'critical',
+    infra_mutation: 'critical',
+    pr_created: 'info',
+    merge_approved: 'warn',
+    merge_blocked: 'warn',
+};
+class AuditTrail {
+    constructor(projectRoot, remoteSink) {
+        this.projectRoot = projectRoot;
+        this.remoteSink = remoteSink;
+    }
+    record(action, actor, options = {}) {
+        const entry = {
+            audit_id: `aud-${crypto_1.default.randomBytes(4).toString('hex')}`,
+            action,
+            severity: ACTION_SEVERITY[action],
+            run_id: options.runId ?? null,
+            work_item_id: options.workItemId ?? null,
+            actor,
+            resource: options.resource ?? null,
+            detail: options.detail ?? {},
+            timestamp: new Date().toISOString(),
+        };
+        this.append(entry);
+        return entry;
+    }
+    query(filter = {}) {
+        return this.load().filter((e) => {
+            if (filter.action && e.action !== filter.action)
+                return false;
+            if (filter.severity && e.severity !== filter.severity)
+                return false;
+            if (filter.runId && e.run_id !== filter.runId)
+                return false;
+            if (filter.since && e.timestamp < filter.since)
+                return false;
+            return true;
+        });
+    }
+    critical() {
+        return this.query({ severity: 'critical' });
+    }
+    metrics() {
+        const entries = this.load();
+        const by_action = {};
+        const actorSet = new Set();
+        let oldest = null;
+        let newest = null;
+        let critical_count = 0;
+        let warn_count = 0;
+        for (const e of entries) {
+            by_action[e.action] = (by_action[e.action] ?? 0) + 1;
+            actorSet.add(e.actor);
+            if (e.severity === 'critical')
+                critical_count++;
+            if (e.severity === 'warn')
+                warn_count++;
+            if (!oldest || e.timestamp < oldest)
+                oldest = e.timestamp;
+            if (!newest || e.timestamp > newest)
+                newest = e.timestamp;
+        }
+        return {
+            total_entries: entries.length,
+            critical_count,
+            warn_count,
+            by_action,
+            actors: [...actorSet],
+            oldest,
+            newest,
+        };
+    }
+    append(entry) {
+        const p = this.trailPath();
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.appendFileSync(p, JSON.stringify(entry) + '\n', 'utf8');
+        // Fire-and-forget remote sink (failures are non-fatal)
+        if (this.remoteSink) {
+            this.remoteSink.write(entry).catch(() => { });
+        }
+    }
+    load() {
+        const p = this.trailPath();
+        if (!fs_1.default.existsSync(p))
+            return [];
+        try {
+            return fs_1.default
+                .readFileSync(p, 'utf8')
+                .split('\n')
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+    trailPath() {
+        return path_1.default.join(this.projectRoot, '.oxe', 'AUDIT-TRAIL.ndjson');
+    }
+}
+exports.AuditTrail = AuditTrail;
+// ─── RunQuota ─────────────────────────────────────────────────────────────────
+function createQuota(runId, limits = {}) {
+    return {
+        run_id: runId,
+        max_work_items: limits.max_work_items ?? Infinity,
+        max_mutations: limits.max_mutations ?? Infinity,
+        max_retries_total: limits.max_retries_total ?? Infinity,
+        consumed_work_items: 0,
+        consumed_mutations: 0,
+        consumed_retries: 0,
+    };
+}
+function checkQuota(quota) {
+    if (quota.consumed_work_items > quota.max_work_items) {
+        return { quota_type: 'work_items', limit: quota.max_work_items, consumed: quota.consumed_work_items };
+    }
+    if (quota.consumed_mutations > quota.max_mutations) {
+        return { quota_type: 'mutations', limit: quota.max_mutations, consumed: quota.consumed_mutations };
+    }
+    if (quota.consumed_retries > quota.max_retries_total) {
+        return { quota_type: 'retries', limit: quota.max_retries_total, consumed: quota.consumed_retries };
+    }
+    return null;
+}
+function consumeQuota(quota, type, amount = 1) {
+    switch (type) {
+        case 'work_items': return { ...quota, consumed_work_items: quota.consumed_work_items + amount };
+        case 'mutations': return { ...quota, consumed_mutations: quota.consumed_mutations + amount };
+        case 'retries': return { ...quota, consumed_retries: quota.consumed_retries + amount };
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './audit-trail';
+export * from './policy-pack';

package/lib/runtime/audit/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./audit-trail"), exports);
+__exportStar(require("./policy-pack"), exports);

package/lib/runtime/audit/policy-pack.d.ts

@@ -0,0 +1,15 @@
+import type { PolicyRule, EnvironmentGuardrail } from '../policy/policy-engine';
+import { PolicyEngine } from '../policy/policy-engine';
+export interface PolicyPack {
+    pack_id: string;
+    org_id: string;
+    name: string;
+    version: string;
+    policies: PolicyRule[];
+    guardrail: EnvironmentGuardrail;
+    created_at: string;
+}
+export declare function savePolicyPack(projectRoot: string, pack: PolicyPack): void;
+export declare function loadPolicyPack(projectRoot: string, packId: string): PolicyPack | null;
+export declare function listPolicyPacks(projectRoot: string): PolicyPack[];
+export declare function applyPolicyPack(engine: PolicyEngine, pack: PolicyPack): PolicyEngine;

package/lib/runtime/audit/policy-pack.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePolicyPack = savePolicyPack;
+exports.loadPolicyPack = loadPolicyPack;
+exports.listPolicyPacks = listPolicyPacks;
+exports.applyPolicyPack = applyPolicyPack;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function packDir(projectRoot) {
+    return path_1.default.join(projectRoot, '.oxe', 'policy-packs');
+}
+function packFilePath(projectRoot, packId) {
+    return path_1.default.join(packDir(projectRoot), `${packId}.json`);
+}
+function savePolicyPack(projectRoot, pack) {
+    const dir = packDir(projectRoot);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(packFilePath(projectRoot, pack.pack_id), JSON.stringify(pack, null, 2), 'utf8');
+}
+function loadPolicyPack(projectRoot, packId) {
+    const p = packFilePath(projectRoot, packId);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function listPolicyPacks(projectRoot) {
+    const dir = packDir(projectRoot);
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((f) => f.endsWith('.json'))
+        .map((f) => {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, f), 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((p) => p !== null);
+}
+function applyPolicyPack(engine, pack) {
+    let result = engine.withGuardrail(pack.guardrail);
+    for (const rule of pack.policies) {
+        result = result.withRule(rule);
+    }
+    return result;
+}

package/lib/runtime/context/context-pack-builder.d.ts

@@ -1,6 +1,8 @@
 import type { WorkItem } from '../models/work-item';
 import type { Evidence } from '../models/evidence';
 import type { RunState } from '../reducers/run-state-reducer';
+import type { ContextProfile } from './context-profiles';
+import type { AutonomyTier } from '../policy/policy-engine';
 export interface ContextArtifact {
     id: string;
     kind: 'evidence' | 'lesson' | 'file' | 'summary';
@@ -27,10 +29,23 @@ export interface ContextPack {
     redundancy_removed: number;
     built_at: string;
 }
+export interface ContextQualityScore {
+    completeness: number;
+    relevance_mean: number;
+    redundancy: number;
+    recency_score: number;
+    overall: number;
+}
+export declare function scorePackQuality(pack: ContextPack, profile: ContextProfile): ContextQualityScore;
 export declare class ContextPackBuilder {
     private readonly opts;
     constructor(opts?: ContextPackOptions);
     build(workItem: WorkItem, state: RunState, evidenceItems: Evidence[], evidenceContents: Map<string, string>, lessons: LessonMetric[]): ContextPack;
     /** Convenience: build with no evidence, just lessons and state summary */
     buildLightweight(workItem: WorkItem, state: RunState, lessons: LessonMetric[]): ContextPack;
+    /**
+     * Filter artifacts to those whose path-like tags are within mutation_scope.
+     * L0/L1 tiers apply the filter; L2/L3 skip it (full access).
+     */
+    filterByMutationScope(artifacts: ContextArtifact[], mutationScope: string[], autonomyTier: AutonomyTier): ContextArtifact[];
 }

package/lib/runtime/context/context-pack-builder.js

@@ -1,6 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextPackBuilder = void 0;
+exports.scorePackQuality = scorePackQuality;
+function scorePackQuality(pack, profile) {
+    const expectedKinds = Object.keys(profile.artifact_kind_weights);
+    const presentKinds = new Set(pack.artifacts.map((a) => a.kind));
+    const completeness = expectedKinds.length > 0
+        ? expectedKinds.filter((k) => presentKinds.has(k)).length / expectedKinds.length
+        : 0;
+    const relevance_mean = pack.artifacts.length > 0
+        ? pack.artifacts.reduce((sum, a) => sum + a.relevanceScore, 0) / pack.artifacts.length
+        : 0;
+    const total = pack.total_artifacts_considered;
+    const redundancy = total > 0 ? 1 - (pack.artifacts.length / total) : 0;
+    const ageMs = Date.now() - new Date(pack.built_at).getTime();
+    const maxAgeMs = 24 * 60 * 60 * 1000;
+    const recency_score = Math.max(0, 1 - ageMs / maxAgeMs);
+    const overall = Math.min(1, 0.3 * completeness +
+        0.35 * relevance_mean +
+        0.1 * (1 - redundancy) +
+        0.25 * recency_score);
+    return {
+        completeness: Math.round(completeness * 100) / 100,
+        relevance_mean: Math.round(relevance_mean * 100) / 100,
+        redundancy: Math.round(redundancy * 100) / 100,
+        recency_score: Math.round(recency_score * 100) / 100,
+        overall: Math.round(overall * 100) / 100,
+    };
+}
 // ─── Relevance scoring ────────────────────────────────────────────────────────
 function scoreEvidenceRelevance(evidence, workItem) {
     let score = 0.5;
@@ -132,5 +159,20 @@ class ContextPackBuilder {
     buildLightweight(workItem, state, lessons) {
         return this.build(workItem, state, [], new Map(), lessons);
     }
+    /**
+     * Filter artifacts to those whose path-like tags are within mutation_scope.
+     * L0/L1 tiers apply the filter; L2/L3 skip it (full access).
+     */
+    filterByMutationScope(artifacts, mutationScope, autonomyTier) {
+        if (autonomyTier === 'L2' || autonomyTier === 'L3')
+            return artifacts;
+        const scope = mutationScope.map((s) => s.toLowerCase());
+        return artifacts.filter((a) => {
+            const pathTags = a.tags.filter((t) => t.includes('/') || t.includes('\\'));
+            if (pathTags.length === 0)
+                return true;
+            return pathTags.some((tag) => scope.some((s) => tag.toLowerCase().includes(s) || s.includes(tag.toLowerCase())));
+        });
+    }
 }
 exports.ContextPackBuilder = ContextPackBuilder;

package/lib/runtime/context/context-pack-store.d.ts

@@ -0,0 +1,38 @@
+import type { ContextPack, ContextQualityScore } from './context-pack-builder';
+export interface ContextPackMeta {
+    pack_id: string;
+    work_item_id: string;
+    run_id: string;
+    built_at: string;
+    artifact_count: number;
+    estimated_tokens: number;
+    stale: boolean;
+    stale_reason: string | null;
+}
+export interface ContextPackDiff {
+    added: string[];
+    removed: string[];
+    score_changed: Array<{
+        id: string;
+        before: number;
+        after: number;
+    }>;
+}
+export declare function savePack(projectRoot: string, runId: string, pack: ContextPack): ContextPackMeta;
+export declare function loadPack(projectRoot: string, runId: string, workItemId: string): ContextPack | null;
+export declare function markStale(projectRoot: string, runId: string, workItemId: string, reason: string): void;
+export declare function isStale(projectRoot: string, runId: string, workItemId: string): boolean;
+export declare function diffPacks(before: ContextPack, after: ContextPack): ContextPackDiff;
+export declare function listPackMeta(projectRoot: string, runId: string): ContextPackMeta[];
+export interface ContextPackRef {
+    ref_id: string;
+    pack_id: string;
+    attempt_id: string;
+    work_item_id: string;
+    run_id: string;
+    artifacts_used: string[];
+    quality: ContextQualityScore;
+    linked_at: string;
+}
+export declare function linkPackToAttempt(projectRoot: string, runId: string, attemptId: string, pack: ContextPack, quality: ContextQualityScore): ContextPackRef;
+export declare function getPackRefForAttempt(projectRoot: string, runId: string, attemptId: string): ContextPackRef | null;

package/lib/runtime/context/context-pack-store.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePack = savePack;
+exports.loadPack = loadPack;
+exports.markStale = markStale;
+exports.isStale = isStale;
+exports.diffPacks = diffPacks;
+exports.listPackMeta = listPackMeta;
+exports.linkPackToAttempt = linkPackToAttempt;
+exports.getPackRefForAttempt = getPackRefForAttempt;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function packPath(projectRoot, runId, workItemId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, `context-pack-${workItemId}.json`);
+}
+function metaIndexPath(projectRoot, runId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, 'context-packs.index.json');
+}
+function estimateTokens(pack) {
+    return Math.ceil(pack.artifacts.reduce((sum, a) => sum + a.content.length, 0) / 4);
+}
+function savePack(projectRoot, runId, pack) {
+    const p = packPath(projectRoot, runId, pack.work_item_id);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(pack, null, 2), 'utf8');
+    const meta = {
+        pack_id: `cp-${runId}-${pack.work_item_id}`,
+        work_item_id: pack.work_item_id,
+        run_id: runId,
+        built_at: pack.built_at,
+        artifact_count: pack.artifacts.length,
+        estimated_tokens: estimateTokens(pack),
+        stale: false,
+        stale_reason: null,
+    };
+    updateMetaIndex(projectRoot, runId, meta);
+    return meta;
+}
+function loadPack(projectRoot, runId, workItemId) {
+    const p = packPath(projectRoot, runId, workItemId);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function markStale(projectRoot, runId, workItemId, reason) {
+    const index = loadMetaIndex(projectRoot, runId);
+    const meta = index.find((m) => m.work_item_id === workItemId);
+    if (!meta)
+        return;
+    meta.stale = true;
+    meta.stale_reason = reason;
+    saveMetaIndex(projectRoot, runId, index);
+}
+function isStale(projectRoot, runId, workItemId) {
+    const index = loadMetaIndex(projectRoot, runId);
+    return index.find((m) => m.work_item_id === workItemId)?.stale ?? false;
+}
+function diffPacks(before, after) {
+    const beforeIds = new Set(before.artifacts.map((a) => a.id));
+    const afterIds = new Set(after.artifacts.map((a) => a.id));
+    const beforeMap = new Map(before.artifacts.map((a) => [a.id, a]));
+    const afterMap = new Map(after.artifacts.map((a) => [a.id, a]));
+    const added = [...afterIds].filter((id) => !beforeIds.has(id));
+    const removed = [...beforeIds].filter((id) => !afterIds.has(id));
+    const score_changed = [];
+    for (const id of afterIds) {
+        if (!beforeIds.has(id))
+            continue;
+        const bScore = beforeMap.get(id).relevanceScore;
+        const aScore = afterMap.get(id).relevanceScore;
+        if (Math.abs(bScore - aScore) > 0.05) {
+            score_changed.push({ id, before: bScore, after: aScore });
+        }
+    }
+    return { added, removed, score_changed };
+}
+function listPackMeta(projectRoot, runId) {
+    return loadMetaIndex(projectRoot, runId);
+}
+function packRefPath(projectRoot, runId, attemptId) {
+    return path_1.default.join(projectRoot, '.oxe', 'runs', runId, `context-ref-${attemptId}.json`);
+}
+function linkPackToAttempt(projectRoot, runId, attemptId, pack, quality) {
+    const ref = {
+        ref_id: `ref-${runId}-${attemptId}`,
+        pack_id: `cp-${runId}-${pack.work_item_id}`,
+        attempt_id: attemptId,
+        work_item_id: pack.work_item_id,
+        run_id: runId,
+        artifacts_used: pack.artifacts.map((a) => a.id),
+        quality,
+        linked_at: new Date().toISOString(),
+    };
+    const p = packRefPath(projectRoot, runId, attemptId);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(ref, null, 2), 'utf8');
+    return ref;
+}
+function getPackRefForAttempt(projectRoot, runId, attemptId) {
+    const p = packRefPath(projectRoot, runId, attemptId);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function loadMetaIndex(projectRoot, runId) {
+    const p = metaIndexPath(projectRoot, runId);
+    if (!fs_1.default.existsSync(p))
+        return [];
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveMetaIndex(projectRoot, runId, index) {
+    const p = metaIndexPath(projectRoot, runId);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(index, null, 2), 'utf8');
+}
+function updateMetaIndex(projectRoot, runId, meta) {
+    const index = loadMetaIndex(projectRoot, runId);
+    const idx = index.findIndex((m) => m.work_item_id === meta.work_item_id);
+    if (idx >= 0)
+        index[idx] = meta;
+    else
+        index.push(meta);
+    saveMetaIndex(projectRoot, runId, index);
+}

package/lib/runtime/context/context-profiles.d.ts

@@ -0,0 +1,11 @@
+import type { ContextArtifact } from './context-pack-builder';
+export type ContextDecisionType = 'execute' | 'verify' | 'plan' | 'review' | 'debug' | 'migration';
+export interface ContextProfile {
+    decision_type: ContextDecisionType;
+    artifact_kind_weights: Record<ContextArtifact['kind'], number>;
+    quality_threshold: number;
+    max_artifacts: number;
+    max_tokens: number;
+}
+export declare const DEFAULT_PROFILES: Record<ContextDecisionType, ContextProfile>;
+export declare function getProfile(decisionType: ContextDecisionType): ContextProfile;

package/lib/runtime/context/context-profiles.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROFILES = void 0;
+exports.getProfile = getProfile;
+exports.DEFAULT_PROFILES = {
+    execute: {
+        decision_type: 'execute',
+        artifact_kind_weights: { evidence: 0.8, lesson: 0.3, file: 0.6, summary: 0.4 },
+        quality_threshold: 0.6,
+        max_artifacts: 20,
+        max_tokens: 8000,
+    },
+    verify: {
+        decision_type: 'verify',
+        artifact_kind_weights: { evidence: 0.9, lesson: 0.2, file: 0.5, summary: 0.5 },
+        quality_threshold: 0.7,
+        max_artifacts: 15,
+        max_tokens: 6000,
+    },
+    plan: {
+        decision_type: 'plan',
+        artifact_kind_weights: { evidence: 0.4, lesson: 0.9, file: 0.7, summary: 0.6 },
+        quality_threshold: 0.5,
+        max_artifacts: 25,
+        max_tokens: 10000,
+    },
+    review: {
+        decision_type: 'review',
+        artifact_kind_weights: { evidence: 0.6, lesson: 0.5, file: 0.8, summary: 0.5 },
+        quality_threshold: 0.55,
+        max_artifacts: 20,
+        max_tokens: 8000,
+    },
+    debug: {
+        decision_type: 'debug',
+        artifact_kind_weights: { evidence: 0.9, lesson: 0.6, file: 0.7, summary: 0.4 },
+        quality_threshold: 0.6,
+        max_artifacts: 20,
+        max_tokens: 8000,
+    },
+    migration: {
+        decision_type: 'migration',
+        artifact_kind_weights: { evidence: 0.7, lesson: 0.7, file: 0.9, summary: 0.5 },
+        quality_threshold: 0.65,
+        max_artifacts: 30,
+        max_tokens: 12000,
+    },
+};
+function getProfile(decisionType) {
+    return exports.DEFAULT_PROFILES[decisionType];
+}

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

@@ -1 +1,3 @@
 export * from './context-pack-builder';
+export * from './context-pack-store';
+export * from './context-profiles';

package/lib/runtime/context/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./context-pack-builder"), exports);
+__exportStar(require("./context-pack-store"), exports);
+__exportStar(require("./context-profiles"), exports);

package/lib/runtime/decision/decision-engine.d.ts

@@ -0,0 +1,43 @@
+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;
+}
+export declare class DecisionEngine {
+    evaluate(input: DecisionInput): DecisionRecord;
+}
+export declare function appendDecision(projectRoot: string, runId: string, record: DecisionRecord): void;
+export declare function loadDecisionLog(projectRoot: string, runId: string): DecisionLog | null;
+export declare function queryDecisions(log: DecisionLog, filter: {
+    type?: DecisionType;
+    workItemId?: string;
+    minConfidence?: number;
+}): DecisionRecord[];