cogmem 3.6.2

package/dist/meta/ProposalApplier.js

@@ -0,0 +1,91 @@
+import { mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+export class ProposalApplier {
+    ledger;
+    traceWriter;
+    workspaceDir;
+    constructor(ledger, traceWriter, workspaceDir) {
+        this.ledger = ledger;
+        this.traceWriter = traceWriter;
+        this.workspaceDir = workspaceDir;
+    }
+    async apply(proposalId) {
+        const proposal = this.ledger.get(proposalId);
+        if (!proposal) {
+            throw new Error(`Unknown proposal: ${proposalId}`);
+        }
+        if (proposal.status !== 'approved') {
+            throw new Error('Must be approved before apply');
+        }
+        if (proposal.applyMode === 'config') {
+            const target = resolve(this.workspaceDir, 'cogmem.config.json');
+            const file = Bun.file(target);
+            const previousValue = await file.exists()
+                ? JSON.parse(await file.text())
+                : {};
+            const merged = {
+                ...(previousValue && typeof previousValue === 'object' && !Array.isArray(previousValue) ? previousValue : {}),
+                ...proposal.suggestedChange
+            };
+            await Bun.write(target, JSON.stringify(merged, null, 2));
+            this.ledger.apply(proposalId, previousValue);
+            this.traceWriter.emit({
+                eventType: 'proposal.apply',
+                payload: {
+                    proposalId,
+                    applyMode: 'config',
+                    target
+                }
+            });
+            return {
+                proposalId,
+                applyMode: 'config',
+                target,
+                previousValue,
+                skippedTrace: false
+            };
+        }
+        const target = resolve(this.workspaceDir, 'proposals', `${proposalId}.patch`);
+        mkdirSync(resolve(this.workspaceDir, 'proposals'), { recursive: true });
+        await Bun.write(target, JSON.stringify(proposal.suggestedChange, null, 2));
+        this.ledger.apply(proposalId, null);
+        return {
+            proposalId,
+            applyMode: 'patch_only',
+            target,
+            previousValue: null,
+            skippedTrace: true
+        };
+    }
+    async rollback(proposalId) {
+        const proposal = this.ledger.get(proposalId);
+        if (!proposal) {
+            throw new Error(`Unknown proposal: ${proposalId}`);
+        }
+        if (proposal.status !== 'applied') {
+            throw new Error(`Proposal ${proposalId} must be applied before rollback`);
+        }
+        if (proposal.applyMode === 'patch_only') {
+            this.ledger.rollback(proposalId);
+            this.traceWriter.emit({
+                eventType: 'proposal.rollback',
+                payload: {
+                    proposalId,
+                    applyMode: 'patch_only'
+                }
+            });
+            return;
+        }
+        const target = resolve(this.workspaceDir, 'cogmem.config.json');
+        await Bun.write(target, JSON.stringify(proposal.previousValue ?? {}, null, 2));
+        this.ledger.rollback(proposalId);
+        this.traceWriter.emit({
+            eventType: 'proposal.rollback',
+            payload: {
+                proposalId,
+                applyMode: 'config',
+                target
+            }
+        });
+    }
+}

package/dist/meta/ProposalConfigOverlay.d.ts

@@ -0,0 +1,13 @@
+export interface OverlayEntry {
+    key: string;
+    value: unknown;
+}
+export declare class ProposalConfigOverlay {
+    private store;
+    set(key: string, value: unknown): void;
+    get(key: string): unknown;
+    entries(): OverlayEntry[];
+    clear(): void;
+    withOverlay<T>(entries: OverlayEntry[], fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=ProposalConfigOverlay.d.ts.map

package/dist/meta/ProposalConfigOverlay.js

@@ -0,0 +1,27 @@
+export class ProposalConfigOverlay {
+    store = new Map();
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    entries() {
+        return Array.from(this.store.entries(), ([key, value]) => ({ key, value }));
+    }
+    clear() {
+        this.store.clear();
+    }
+    async withOverlay(entries, fn) {
+        this.clear();
+        for (const entry of entries) {
+            this.set(entry.key, entry.value);
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            this.clear();
+        }
+    }
+}

package/dist/meta/ProposalEvalRunner.d.ts

@@ -0,0 +1,31 @@
+import { EvalRunner, type EvalSuiteResult } from '../eval/runners/EvalRunner.js';
+import { BenchmarkRunner, type BenchmarkGroupResult } from '../benchmark/BenchmarkRunner.js';
+import { ProposalConfigOverlay } from './ProposalConfigOverlay.js';
+import { ProposalLedger } from './ProposalLedger.js';
+export interface RegressionDetail {
+    groupName: string;
+    metricLabel: string;
+    currentValue: number;
+    threshold: number;
+    operator: string;
+}
+export interface ProposalVerdict {
+    proposalId: string;
+    ranAt: number;
+    evalResults: EvalSuiteResult[];
+    benchmarkResults: BenchmarkGroupResult[];
+    regressions: RegressionDetail[];
+    passed: boolean;
+    reportText: string;
+    reportPath?: string;
+}
+export declare class ProposalEvalRunner {
+    private ledger;
+    private evalRunner;
+    private readonly benchmarkRunner;
+    private readonly report;
+    constructor(ledger: ProposalLedger, evalRunner: EvalRunner, benchmarkRunner?: BenchmarkRunner);
+    evaluate(proposalId: string, overlay?: ProposalConfigOverlay): Promise<ProposalVerdict>;
+    private resolveGroupsToRun;
+}
+//# sourceMappingURL=ProposalEvalRunner.d.ts.map

package/dist/meta/ProposalEvalRunner.js

@@ -0,0 +1,62 @@
+import { BenchmarkReport } from '../benchmark/BenchmarkReport.js';
+import { BenchmarkRunner } from '../benchmark/BenchmarkRunner.js';
+import { BENCHMARK_GROUPS } from '../benchmark/BenchmarkRegistry.js';
+const DEFAULT_SUITES = [
+    'memory_recall',
+];
+export class ProposalEvalRunner {
+    ledger;
+    evalRunner;
+    benchmarkRunner;
+    report = new BenchmarkReport();
+    constructor(ledger, evalRunner, benchmarkRunner) {
+        this.ledger = ledger;
+        this.evalRunner = evalRunner;
+        this.benchmarkRunner = benchmarkRunner ?? new BenchmarkRunner(this.evalRunner);
+    }
+    async evaluate(proposalId, overlay) {
+        const proposal = this.ledger.get(proposalId);
+        if (!proposal) {
+            throw new Error(`Unknown proposal: ${proposalId}`);
+        }
+        this.ledger.updateStatus(proposalId, 'under_eval');
+        const groupsToRun = this.resolveGroupsToRun(proposal.evalPlan);
+        const runBenchmarks = async () => Promise.all(groupsToRun.map((group) => this.benchmarkRunner.runGroup(group.name)));
+        const benchmarkResults = proposal.applyMode === 'patch_only' || !overlay
+            ? await runBenchmarks()
+            : await overlay.withOverlay(overlay.entries(), runBenchmarks);
+        const evalResults = benchmarkResults.map((result) => result.suiteResult);
+        const regressions = benchmarkResults.flatMap((result) => result.baselineResults
+            .filter((baseline) => !baseline.passed)
+            .map((baseline) => ({
+            groupName: result.group.name,
+            metricLabel: baseline.label,
+            currentValue: baseline.value,
+            threshold: baseline.threshold,
+            operator: baseline.operator
+        })));
+        const passed = regressions.length === 0;
+        const reportText = this.report.formatConsole(benchmarkResults);
+        const ranAt = Math.max(...evalResults.map((result) => result.runAt));
+        this.ledger.updateStatus(proposalId, passed ? 'passed_eval' : 'failed_eval', {
+            evalReport: reportText
+        });
+        return {
+            proposalId,
+            ranAt,
+            evalResults,
+            benchmarkResults,
+            regressions,
+            passed,
+            reportText
+        };
+    }
+    resolveGroupsToRun(evalPlan) {
+        const suites = evalPlan && evalPlan.length > 0 ? evalPlan : DEFAULT_SUITES;
+        const groups = BENCHMARK_GROUPS.filter((group) => suites.includes(group.suiteName));
+        if (groups.length === 0) {
+            return [...BENCHMARK_GROUPS];
+        }
+        return groups;
+    }
+}

package/dist/meta/ProposalLedger.d.ts

@@ -0,0 +1,34 @@
+import type Database from 'bun:sqlite';
+import type { PolicyProposal, ProposalCategory, ProposalStatus } from './types.js';
+export declare class ProposalLedger {
+    private db;
+    constructor(db: Database);
+    initSchema(): void;
+    save(proposal: PolicyProposal): void;
+    get(id: string): PolicyProposal | null;
+    list(filter?: {
+        status?: ProposalStatus;
+        category?: ProposalCategory;
+    }): PolicyProposal[];
+    updateStatus(id: string, status: ProposalStatus, extras?: {
+        evalReport?: string;
+        approvedAt?: number;
+        appliedAt?: number;
+        rolledBackAt?: number;
+        rejectedAt?: number;
+        previousValue?: unknown;
+        predictedImpact?: PolicyProposal['predictedImpact'];
+        actualOutcomeVerifiedAt?: number;
+        verificationResult?: PolicyProposal['verificationResult'];
+    }): void;
+    approve(id: string): void;
+    apply(id: string, previousValue: unknown): void;
+    rollback(id: string): void;
+    reject(id: string): void;
+    private mapRow;
+    private ensureColumn;
+    private parseEvalPlan;
+    private parseJson;
+    private requireProposal;
+}
+//# sourceMappingURL=ProposalLedger.d.ts.map

package/dist/meta/ProposalLedger.js

@@ -0,0 +1,242 @@
+const DEFAULT_EVAL_PLAN = ['memory_recall'];
+const DEFAULT_EVAL_PLAN_JSON = '["memory_recall"]';
+const DEFAULT_RISK_LEVEL = 'medium';
+const DEFAULT_APPLY_MODE = 'patch_only';
+export class ProposalLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta_proposals (
+        id TEXT PRIMARY KEY,
+        proposed_at INTEGER NOT NULL,
+        category TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        evidence TEXT NOT NULL,
+        suggested_change TEXT NOT NULL,
+        status TEXT NOT NULL,
+        eval_report TEXT,
+        approved_at INTEGER,
+        applied_at INTEGER,
+        rolled_back_at INTEGER,
+        rejected_at INTEGER,
+        previous_value TEXT,
+        eval_plan TEXT DEFAULT '["memory_recall"]',
+        risk_level TEXT DEFAULT 'medium',
+        apply_mode TEXT DEFAULT 'patch_only',
+        predicted_impact TEXT,
+        actual_outcome_verified_at INTEGER,
+        verification_result TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_meta_proposals_status
+        ON meta_proposals(status, proposed_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_meta_proposals_category
+        ON meta_proposals(category, proposed_at DESC);
+    `);
+        this.ensureColumn('eval_plan', `ALTER TABLE meta_proposals ADD COLUMN eval_plan TEXT DEFAULT '${DEFAULT_EVAL_PLAN_JSON}'`);
+        this.ensureColumn('risk_level', `ALTER TABLE meta_proposals ADD COLUMN risk_level TEXT DEFAULT '${DEFAULT_RISK_LEVEL}'`);
+        this.ensureColumn('apply_mode', `ALTER TABLE meta_proposals ADD COLUMN apply_mode TEXT DEFAULT '${DEFAULT_APPLY_MODE}'`);
+        this.ensureColumn('approved_at', 'ALTER TABLE meta_proposals ADD COLUMN approved_at INTEGER');
+        this.ensureColumn('rolled_back_at', 'ALTER TABLE meta_proposals ADD COLUMN rolled_back_at INTEGER');
+        this.ensureColumn('previous_value', 'ALTER TABLE meta_proposals ADD COLUMN previous_value TEXT');
+        this.ensureColumn('predicted_impact', 'ALTER TABLE meta_proposals ADD COLUMN predicted_impact TEXT');
+        this.ensureColumn('actual_outcome_verified_at', 'ALTER TABLE meta_proposals ADD COLUMN actual_outcome_verified_at INTEGER');
+        this.ensureColumn('verification_result', 'ALTER TABLE meta_proposals ADD COLUMN verification_result TEXT');
+        this.db.exec(`
+      UPDATE meta_proposals
+      SET eval_plan = COALESCE(eval_plan, '${DEFAULT_EVAL_PLAN_JSON}'),
+          risk_level = COALESCE(risk_level, '${DEFAULT_RISK_LEVEL}'),
+          apply_mode = COALESCE(apply_mode, '${DEFAULT_APPLY_MODE}')
+    `);
+    }
+    save(proposal) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO meta_proposals (
+        id,
+        proposed_at,
+        category,
+        summary,
+        evidence,
+        suggested_change,
+        status,
+        eval_report,
+        approved_at,
+        applied_at,
+        rolled_back_at,
+        rejected_at,
+        previous_value,
+        eval_plan,
+        risk_level,
+        apply_mode,
+        predicted_impact,
+        actual_outcome_verified_at,
+        verification_result
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(proposal.id, proposal.proposedAt, proposal.category, proposal.summary, JSON.stringify(proposal.evidence), JSON.stringify(proposal.suggestedChange), proposal.status, proposal.evalReport ?? null, proposal.approvedAt ?? null, proposal.appliedAt ?? null, proposal.rolledBackAt ?? null, proposal.rejectedAt ?? null, typeof proposal.previousValue === 'undefined' ? null : JSON.stringify(proposal.previousValue), JSON.stringify(proposal.evalPlan ?? DEFAULT_EVAL_PLAN), proposal.riskLevel ?? DEFAULT_RISK_LEVEL, proposal.applyMode ?? DEFAULT_APPLY_MODE, proposal.predictedImpact ? JSON.stringify(proposal.predictedImpact) : null, proposal.actualOutcomeVerifiedAt ?? null, proposal.verificationResult ? JSON.stringify(proposal.verificationResult) : null);
+    }
+    get(id) {
+        const row = this.db.prepare(`
+      SELECT
+        id,
+        proposed_at,
+        category,
+        summary,
+        evidence,
+        suggested_change,
+        status,
+        eval_report,
+        approved_at,
+        applied_at,
+        rolled_back_at,
+        rejected_at,
+        previous_value,
+        eval_plan,
+        risk_level,
+        apply_mode,
+        predicted_impact,
+        actual_outcome_verified_at,
+        verification_result
+      FROM meta_proposals
+      WHERE id = ?
+    `).get(id);
+        return row ? this.mapRow(row) : null;
+    }
+    list(filter = {}) {
+        const clauses = [];
+        const params = [];
+        if (filter.status) {
+            clauses.push('status = ?');
+            params.push(filter.status);
+        }
+        if (filter.category) {
+            clauses.push('category = ?');
+            params.push(filter.category);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT
+        id,
+        proposed_at,
+        category,
+        summary,
+        evidence,
+        suggested_change,
+        status,
+        eval_report,
+        approved_at,
+        applied_at,
+        rolled_back_at,
+        rejected_at,
+        previous_value,
+        eval_plan,
+        risk_level,
+        apply_mode,
+        predicted_impact,
+        actual_outcome_verified_at,
+        verification_result
+      FROM meta_proposals
+      ${where}
+      ORDER BY proposed_at DESC, id DESC
+    `).all(...params);
+        return rows.map((row) => this.mapRow(row));
+    }
+    updateStatus(id, status, extras = {}) {
+        this.db.prepare(`
+      UPDATE meta_proposals
+      SET status = ?,
+          eval_report = COALESCE(?, eval_report),
+          approved_at = COALESCE(?, approved_at),
+          applied_at = COALESCE(?, applied_at),
+          rolled_back_at = COALESCE(?, rolled_back_at),
+          rejected_at = COALESCE(?, rejected_at),
+          previous_value = COALESCE(?, previous_value),
+          predicted_impact = COALESCE(?, predicted_impact),
+          actual_outcome_verified_at = COALESCE(?, actual_outcome_verified_at),
+          verification_result = COALESCE(?, verification_result)
+      WHERE id = ?
+    `).run(status, extras.evalReport ?? null, extras.approvedAt ?? null, extras.appliedAt ?? null, extras.rolledBackAt ?? null, extras.rejectedAt ?? null, typeof extras.previousValue === 'undefined' ? null : JSON.stringify(extras.previousValue), typeof extras.predictedImpact === 'undefined' ? null : JSON.stringify(extras.predictedImpact), extras.actualOutcomeVerifiedAt ?? null, typeof extras.verificationResult === 'undefined' ? null : JSON.stringify(extras.verificationResult), id);
+    }
+    approve(id) {
+        const proposal = this.requireProposal(id);
+        if (proposal.status !== 'passed_eval') {
+            throw new Error(`Proposal ${id} must be passed_eval before approve`);
+        }
+        this.updateStatus(id, 'approved', { approvedAt: Date.now() });
+    }
+    apply(id, previousValue) {
+        const proposal = this.requireProposal(id);
+        if (proposal.status !== 'approved') {
+            throw new Error(`Proposal ${id} must be approved before apply`);
+        }
+        this.updateStatus(id, 'applied', {
+            appliedAt: Date.now(),
+            previousValue
+        });
+    }
+    rollback(id) {
+        const proposal = this.requireProposal(id);
+        if (proposal.status !== 'applied') {
+            throw new Error(`Proposal ${id} must be applied before rollback`);
+        }
+        this.updateStatus(id, 'rolled_back', { rolledBackAt: Date.now() });
+    }
+    reject(id) {
+        this.requireProposal(id);
+        this.updateStatus(id, 'rejected', { rejectedAt: Date.now() });
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            proposedAt: row.proposed_at,
+            category: row.category,
+            summary: row.summary,
+            evidence: this.parseJson(row.evidence),
+            suggestedChange: this.parseJson(row.suggested_change),
+            status: row.status,
+            evalReport: row.eval_report ?? undefined,
+            approvedAt: row.approved_at ?? undefined,
+            appliedAt: row.applied_at ?? undefined,
+            rolledBackAt: row.rolled_back_at ?? undefined,
+            rejectedAt: row.rejected_at ?? undefined,
+            previousValue: row.previous_value === null ? undefined : this.parseJson(row.previous_value),
+            evalPlan: this.parseEvalPlan(row.eval_plan),
+            riskLevel: row.risk_level ?? DEFAULT_RISK_LEVEL,
+            applyMode: row.apply_mode ?? DEFAULT_APPLY_MODE,
+            predictedImpact: row.predicted_impact ? this.parseJson(row.predicted_impact) : undefined,
+            actualOutcomeVerifiedAt: row.actual_outcome_verified_at ?? undefined,
+            verificationResult: row.verification_result ? this.parseJson(row.verification_result) : undefined
+        };
+    }
+    ensureColumn(columnName, alterSql) {
+        const columns = this.db.prepare('PRAGMA table_info(meta_proposals)').all();
+        if (!columns.some((column) => column.name === columnName)) {
+            this.db.exec(alterSql);
+        }
+    }
+    parseEvalPlan(value) {
+        if (!value) {
+            return DEFAULT_EVAL_PLAN;
+        }
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) && parsed.length > 0 ? parsed : DEFAULT_EVAL_PLAN;
+        }
+        catch {
+            return DEFAULT_EVAL_PLAN;
+        }
+    }
+    parseJson(value) {
+        return JSON.parse(value);
+    }
+    requireProposal(id) {
+        const proposal = this.get(id);
+        if (!proposal) {
+            throw new Error(`Unknown proposal: ${id}`);
+        }
+        return proposal;
+    }
+}

package/dist/meta/types.d.ts

@@ -0,0 +1,63 @@
+import type { EvalSuiteName } from '../eval/runners/EvalRunner.js';
+export type ProposalCategory = 'risk_rule' | 'observation_filter' | 'memory_promotion' | 'approval_policy' | 'context_pack_policy' | 'system_intent_pattern' | 'capability_config' | 'workspace_preference' | 'benchmark_threshold' | 'skill_recovery' | 'SkillRefinement' | 'SkillBootstrap';
+export type ProposalStatus = 'pending' | 'under_eval' | 'passed_eval' | 'failed_eval' | 'approved' | 'applied' | 'rolled_back' | 'rejected';
+export interface ProposalEvidence {
+    traceEventId: string;
+    note: string;
+}
+export interface PolicyProposal {
+    id: string;
+    proposedAt: number;
+    category: ProposalCategory;
+    summary: string;
+    evidence: ProposalEvidence[];
+    suggestedChange: Record<string, unknown>;
+    status: ProposalStatus;
+    evalReport?: string;
+    approvedAt?: number;
+    appliedAt?: number;
+    rolledBackAt?: number;
+    rejectedAt?: number;
+    previousValue?: unknown;
+    evalPlan?: EvalSuiteName[];
+    riskLevel?: 'low' | 'medium' | 'high';
+    applyMode?: 'config' | 'patch_only';
+    predictedImpact?: PredictedImpact;
+    actualOutcomeVerifiedAt?: number;
+    verificationResult?: EvolutionVerificationResult;
+}
+export interface PredictedImpact {
+    improvedTags: string[];
+    potentialRegressionTags: string[];
+    rationale: string;
+}
+export interface EvolutionVerificationResult {
+    verifiedAt: number;
+    improvedTagsActual: Record<string, {
+        before: number;
+        after: number;
+    }>;
+    regressionTagsActual: Record<string, {
+        before: number;
+        after: number;
+    }>;
+    verdict: 'confirmed' | 'partial' | 'regressed' | 'insufficient_data';
+}
+export interface ObservationPattern {
+    type: 'repeated_approval_reject' | 'repeated_url_filter' | 'flip_flop_supersede' | 'repeated_decay_after_promote' | 'fast_path_miss_pattern' | 'llm_fallback_pattern' | 'capability_failure_pattern' | 'benchmark_regression' | 'TopicReclassified';
+    capabilityId?: string;
+    url?: string;
+    factId?: string;
+    neuronId?: string;
+    projectId?: string;
+    from?: string;
+    to?: string;
+    content?: string;
+    metricName?: string;
+    currentValue?: number;
+    baselineValue?: number;
+    failureRate?: number;
+    occurrenceCount: number;
+    evidenceEventIds: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/meta/types.js

@@ -0,0 +1 @@
+export {};

package/dist/migrations/0001_init.d.ts

@@ -0,0 +1,4 @@
+import type { Migration } from '../types/Migration.js';
+export declare const V0_5_BASELINE_TABLES: readonly ["agent_approval_queue", "agent_task_records", "anchors", "background_jobs", "belief_evidence", "beliefs", "branch_entries", "branch_links", "cognitive_edges", "cognitive_nodes", "compiled_events", "compiler_confidence_runs", "entities", "entity_alias_conflicts", "entity_aliases", "entity_attributes", "entity_instances", "entity_mentions", "entity_relations", "event_cluster_entries", "event_clusters", "fact_access_log", "fact_supersede_chain", "facts", "graph_signals", "ingestion_processed_records", "ingestion_source_cursors", "interaction_units", "memory_events", "meta_proposals", "neurons", "pending_bindings", "pending_entity_resolution", "plasticity_graph_edge_audit", "plasticity_graph_edges", "plasticity_proposal_review_decisions", "plasticity_proposals", "policy_executions", "policy_projection_state", "project_branches", "projection_observability_rollups", "projection_observability_samples", "reasoning_chains", "reasoning_steps", "runtime_projection_state", "runtime_states", "runtime_transitions", "sandbox_snapshots", "synapses", "task_branch_entries", "task_branches", "temporal_adjacency", "time_bucket_entries", "time_buckets", "topology_membership", "trace_events", "user_session_scopes", "user_sessions", "vector_projection_state"];
+export declare const migration_0001: Migration;
+//# sourceMappingURL=0001_init.d.ts.map

package/dist/migrations/0001_init.js

@@ -0,0 +1,67 @@
+export const V0_5_BASELINE_TABLES = [
+    'agent_approval_queue',
+    'agent_task_records',
+    'anchors',
+    'background_jobs',
+    'belief_evidence',
+    'beliefs',
+    'branch_entries',
+    'branch_links',
+    'cognitive_edges',
+    'cognitive_nodes',
+    'compiled_events',
+    'compiler_confidence_runs',
+    'entities',
+    'entity_alias_conflicts',
+    'entity_aliases',
+    'entity_attributes',
+    'entity_instances',
+    'entity_mentions',
+    'entity_relations',
+    'event_cluster_entries',
+    'event_clusters',
+    'fact_access_log',
+    'fact_supersede_chain',
+    'facts',
+    'graph_signals',
+    'ingestion_processed_records',
+    'ingestion_source_cursors',
+    'interaction_units',
+    'memory_events',
+    'meta_proposals',
+    'neurons',
+    'pending_bindings',
+    'pending_entity_resolution',
+    'plasticity_graph_edge_audit',
+    'plasticity_graph_edges',
+    'plasticity_proposal_review_decisions',
+    'plasticity_proposals',
+    'policy_executions',
+    'policy_projection_state',
+    'project_branches',
+    'projection_observability_rollups',
+    'projection_observability_samples',
+    'reasoning_chains',
+    'reasoning_steps',
+    'runtime_projection_state',
+    'runtime_states',
+    'runtime_transitions',
+    'sandbox_snapshots',
+    'synapses',
+    'task_branch_entries',
+    'task_branches',
+    'temporal_adjacency',
+    'time_bucket_entries',
+    'time_buckets',
+    'topology_membership',
+    'trace_events',
+    'user_session_scopes',
+    'user_sessions',
+    'vector_projection_state'
+];
+export const migration_0001 = {
+    version: '0001',
+    description: 'v0.5 baseline schema snapshot',
+    up(_db) { },
+    down(_db) { }
+};

package/dist/migrations/0002_v06_platform.d.ts

@@ -0,0 +1,10 @@
+import type { Migration } from '../types/Migration.js';
+/**
+ * v0.6 Platform Delivery additions
+ * - Scheduler: scheduled_jobs + scheduled_job_runs
+ * - Notifications: notification_rules + notification_records
+ * - Workspaces: workspaces + workspace_settings
+ * - Health monitoring: agent_brain_health_checks
+ */
+export declare const migration_0002: Migration;
+//# sourceMappingURL=0002_v06_platform.d.ts.map