cogmem 3.6.2

package/dist/migrations/0025_memory_atlas.js

@@ -0,0 +1,268 @@
+export const migration_0025 = {
+    version: '0025',
+    description: 'source-anchored memory atlas projection and activation state',
+    up(db) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_atlas_documents (
+        node_id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        node_type TEXT NOT NULL,
+        memory_kind TEXT,
+        source_id TEXT NOT NULL,
+        label TEXT NOT NULL,
+        summary TEXT,
+        topic_path TEXT,
+        confidence REAL NOT NULL DEFAULT 1,
+        support_count INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'active',
+        occurred_at INTEGER,
+        evidence_event_ids_json TEXT NOT NULL DEFAULT '[]',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_atlas_documents_project_type
+        ON memory_atlas_documents(project_id, node_type, updated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_memory_atlas_documents_project_topic
+        ON memory_atlas_documents(project_id, topic_path, updated_at DESC);
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_atlas_fts USING fts5(
+        node_id UNINDEXED,
+        project_id UNINDEXED,
+        node_type UNINDEXED,
+        label,
+        summary,
+        topic_path,
+        tokenize='unicode61'
+      );
+      CREATE TABLE IF NOT EXISTS memory_action_frames (
+        action_id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        frame_type TEXT NOT NULL,
+        action TEXT NOT NULL,
+        actor TEXT NOT NULL,
+        target_entity_id TEXT,
+        target_label TEXT,
+        topic_path TEXT,
+        episode_id TEXT,
+        occurred_at INTEGER NOT NULL,
+        confidence REAL NOT NULL,
+        source_authority TEXT NOT NULL DEFAULT 'raw_evidence',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_action_frames_query
+        ON memory_action_frames(project_id, target_label, occurred_at DESC);
+      CREATE TABLE IF NOT EXISTS memory_action_frame_evidence (
+        action_id TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (action_id, event_id),
+        FOREIGN KEY(action_id) REFERENCES memory_action_frames(action_id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_action_evidence_event
+        ON memory_action_frame_evidence(project_id, event_id);
+      CREATE TABLE IF NOT EXISTS memory_atlas_access (
+        access_id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        access_kind TEXT NOT NULL,
+        query_hash TEXT,
+        accessed_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memory_atlas_access_node
+        ON memory_atlas_access(project_id, node_id, accessed_at DESC);
+      CREATE TABLE IF NOT EXISTS memory_atlas_activation (
+        project_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        activation REAL NOT NULL DEFAULT 0,
+        usage_count INTEGER NOT NULL DEFAULT 0,
+        last_accessed_at INTEGER,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (project_id, node_id)
+      );
+      CREATE TABLE IF NOT EXISTS memory_atlas_projection_state (
+        project_id TEXT NOT NULL,
+        projection_name TEXT NOT NULL,
+        cursor_value TEXT,
+        status TEXT NOT NULL,
+        last_rebuild_at INTEGER,
+        last_error TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        PRIMARY KEY (project_id, projection_name)
+      );
+    `);
+        installAtlasProjectionDirtyTriggers(db);
+        backfillAtlasDocuments(db);
+    },
+    down(db) {
+        dropAtlasProjectionDirtyTriggers(db);
+        db.exec(`
+      DROP TABLE IF EXISTS memory_atlas_projection_state;
+      DROP TABLE IF EXISTS memory_atlas_activation;
+      DROP TABLE IF EXISTS memory_atlas_access;
+      DROP TABLE IF EXISTS memory_action_frame_evidence;
+      DROP TABLE IF EXISTS memory_action_frames;
+      DROP TABLE IF EXISTS memory_atlas_fts;
+      DROP TABLE IF EXISTS memory_atlas_documents;
+    `);
+    },
+};
+export function backfillAtlasDocuments(db, projectId) {
+    const now = Date.now();
+    const scoped = projectId !== undefined;
+    const projectWhere = scoped ? ` WHERE COALESCE(project_id, '') = ?` : '';
+    const projectParams = scoped ? [projectId] : [];
+    if (tableExists(db, 'memory_entities')) {
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, confidence,
+        support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'entity:' || entity_id, COALESCE(project_id, ''), 'entity', entity_id,
+        canonical_name, NULL, 1, 0, 'active', created_at, '[]',
+        json_object('entityType', entity_type, 'aliases', aliases_json, 'stablePath', stable_path),
+        COALESCE(updated_at, ?)
+      FROM memory_entities${projectWhere}
+    `).run(now, ...projectParams);
+    }
+    if (tableExists(db, 'memory_topics')) {
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, topic_path,
+        confidence, support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'topic:' || COALESCE(project_id, '') || ':' || topic_path, COALESCE(project_id, ''),
+        'topic', topic_path, topic_path, summary, topic_path, 1, 0, 'active', created_at, '[]',
+        json_object('topicType', topic_type, 'parentPath', parent_path), COALESCE(updated_at, ?)
+      FROM memory_topics${projectWhere}
+    `).run(now, ...projectParams);
+    }
+    if (tableExists(db, 'topic_nodes')) {
+        const legacySummary = tableExists(db, 'memory_topics')
+            ? `(SELECT mt.summary FROM memory_topics mt WHERE mt.project_id=topic_nodes.project_id AND mt.topic_path=topic_nodes.topic_path LIMIT 1)`
+            : 'NULL';
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, topic_path,
+        confidence, support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'topic:' || project_id || ':' || topic_path, project_id, 'topic', topic_path,
+        canonical_name,
+        TRIM(COALESCE(${legacySummary}, '') || ' ' || COALESCE((
+          SELECT group_concat(alias, ' ') FROM topic_aliases a
+          WHERE a.project_id=topic_nodes.project_id AND a.topic_id=topic_nodes.topic_id AND a.status='active'
+        ), '')),
+        topic_path, confidence, 0, status, last_used_at, evidence_event_ids_json,
+        json_object('topicId', topic_id, 'ontologyClass', ontology_class, 'createdBy', created_by), updated_at
+      FROM topic_nodes${projectWhere}
+    `).run(...projectParams);
+    }
+    if (tableExists(db, 'memory_clusters')) {
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, topic_path,
+        confidence, support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'cluster:' || cluster_id, COALESCE(project_id, ''), 'cluster', cluster_id,
+        title, summary, topic_path, confidence, support_count, status, created_at,
+        evidence_event_ids_json, json_object('clusterType', cluster_type, 'claimKey', claim_key),
+        COALESCE(updated_at, ?)
+      FROM memory_clusters${projectWhere}
+    `).run(now, ...projectParams);
+    }
+    if (tableExists(db, 'memory_episodes')) {
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, topic_path,
+        confidence, support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'episode:' || episode_id, project_id, 'episode', episode_id,
+        COALESCE(summary, topic_path, episode_type || ' episode'), summary, topic_path,
+        importance, event_count, status, started_at,
+        json_array(start_event_id, end_event_id),
+        json_object('episodeType', episode_type, 'sessionId', session_id), updated_at
+      FROM memory_episodes${projectWhere}
+    `).run(...projectParams);
+    }
+    if (tableExists(db, 'beliefs')) {
+        db.prepare(`
+      INSERT OR REPLACE INTO memory_atlas_documents (
+        node_id, project_id, node_type, source_id, label, summary, confidence,
+        support_count, status, occurred_at, evidence_event_ids_json, metadata_json, updated_at
+      )
+      SELECT 'belief:' || id, COALESCE(project_id, ''), 'belief', id,
+        subject || ' ' || predicate, object_value, confidence, 1, status, valid_from,
+        CASE WHEN source_event_id IS NULL THEN '[]' ELSE json_array(source_event_id) END,
+        json_object('canonicalKey', canonical_key, 'scope', scope), updated_at
+      FROM beliefs${projectWhere}
+    `).run(...projectParams);
+    }
+    if (scoped)
+        db.prepare(`DELETE FROM memory_atlas_fts WHERE project_id=?`).run(projectId);
+    else
+        db.exec(`DELETE FROM memory_atlas_fts;`);
+    const ftsWhere = scoped ? ' WHERE project_id=?' : '';
+    db.prepare(`
+    INSERT INTO memory_atlas_fts (node_id, project_id, node_type, label, summary, topic_path)
+    SELECT node_id, project_id, node_type, label, COALESCE(summary, ''), COALESCE(topic_path, '')
+    FROM memory_atlas_documents${ftsWhere};
+  `).run(...projectParams);
+    db.exec(`
+    UPDATE memory_atlas_documents SET memory_kind = CASE
+      WHEN node_type IN ('action','project','event','time') THEN node_type
+      WHEN lower(json_extract(metadata_json, '$.clusterType')) IN ('decision','correction','goal','preference','plan','event','evidence')
+        THEN lower(json_extract(metadata_json, '$.clusterType'))
+      WHEN lower(json_extract(metadata_json, '$.episodeType')) IN ('decision','correction','goal','preference','plan','event','evidence')
+        THEN lower(json_extract(metadata_json, '$.episodeType'))
+      WHEN lower(json_extract(metadata_json, '$.ontologyClass')) IN ('person','place','project','object','decision','correction','goal','preference','plan','event','evidence')
+        THEN lower(json_extract(metadata_json, '$.ontologyClass'))
+      WHEN lower(json_extract(metadata_json, '$.entityType')) IN ('person','place','project','object')
+        THEN lower(json_extract(metadata_json, '$.entityType'))
+      ELSE NULL
+    END
+    WHERE memory_kind IS NULL;
+  `);
+}
+export function installAtlasProjectionDirtyTriggers(db) {
+    const sources = [
+        ['memory_entities', 'project_id'], ['memory_topics', 'project_id'], ['memory_clusters', 'project_id'],
+        ['memory_episodes', 'project_id'], ['beliefs', 'project_id'], ['memory_bindings', 'project_id'],
+        ['topic_nodes', 'project_id'], ['topic_aliases', 'project_id'], ['topic_relations', 'project_id'],
+    ];
+    for (const [table, projectColumn] of sources) {
+        if (!tableExists(db, table))
+            continue;
+        for (const operation of ['INSERT', 'UPDATE', 'DELETE']) {
+            const ref = operation === 'DELETE' ? 'OLD' : 'NEW';
+            const trigger = `trg_memory_atlas_dirty_${table}_${operation.toLowerCase()}`;
+            const markOldProject = operation === 'UPDATE' ? `
+          INSERT INTO memory_atlas_projection_state(
+            project_id, projection_name, cursor_value, status, last_rebuild_at, last_error, metadata_json
+          ) VALUES(COALESCE(OLD.${projectColumn}, ''), 'memory_atlas.v1', NULL, 'dirty', NULL, NULL, '{}')
+          ON CONFLICT(project_id, projection_name) DO UPDATE SET status='dirty', cursor_value=NULL, last_error=NULL;
+      ` : '';
+            db.exec(`
+        CREATE TRIGGER IF NOT EXISTS ${trigger}
+        AFTER ${operation} ON ${table}
+        BEGIN
+          INSERT INTO memory_atlas_projection_state(
+            project_id, projection_name, cursor_value, status, last_rebuild_at, last_error, metadata_json
+          ) VALUES(COALESCE(${ref}.${projectColumn}, ''), 'memory_atlas.v1', NULL, 'dirty', NULL, NULL, '{}')
+          ON CONFLICT(project_id, projection_name) DO UPDATE SET status='dirty', cursor_value=NULL, last_error=NULL;
+          ${markOldProject}
+        END;
+      `);
+        }
+    }
+}
+function dropAtlasProjectionDirtyTriggers(db) {
+    const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type='trigger' AND name LIKE 'trg_memory_atlas_dirty_%'`).all();
+    for (const row of rows) {
+        if (!/^trg_memory_atlas_dirty_[a-z0-9_]+$/u.test(row.name))
+            continue;
+        db.exec(`DROP TRIGGER IF EXISTS ${row.name};`);
+    }
+}
+function tableExists(db, name) {
+    return Boolean(db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name));
+}

package/dist/migrations/0026_runtime_governance_atlas_reliability.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from '../types/Migration.js';
+export declare const migration_0026: Migration;
+//# sourceMappingURL=0026_runtime_governance_atlas_reliability.d.ts.map

package/dist/migrations/0026_runtime_governance_atlas_reliability.js

@@ -0,0 +1,72 @@
+export const migration_0026 = {
+    version: '0026',
+    description: 'audited candidate review and Atlas reliability metadata',
+    up(db) {
+        ensureColumn(db, 'memory_atlas_documents', 'memory_kind', 'TEXT');
+        ensureColumn(db, 'deep_write_candidates', 'review_after', 'INTEGER');
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS deep_write_candidate_reviews (
+        review_id TEXT PRIMARY KEY,
+        candidate_id TEXT NOT NULL,
+        project_id TEXT,
+        action TEXT NOT NULL,
+        actor TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        from_status TEXT NOT NULL,
+        to_status TEXT NOT NULL,
+        confirmation_event_id TEXT,
+        target_belief_id TEXT,
+        replacement_candidate_id TEXT,
+        review_after INTEGER,
+        decision_json TEXT NOT NULL DEFAULT '{}',
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY(candidate_id) REFERENCES deep_write_candidates(candidate_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_candidate_reviews_project_created
+        ON deep_write_candidate_reviews(project_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_candidate_reviews_candidate_created
+        ON deep_write_candidate_reviews(candidate_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_atlas_documents_project_occurred
+        ON memory_atlas_documents(project_id, occurred_at DESC, node_type);
+      CREATE INDEX IF NOT EXISTS idx_atlas_documents_project_kind
+        ON memory_atlas_documents(project_id, memory_kind, occurred_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_atlas_access_project_time
+        ON memory_atlas_access(project_id, accessed_at DESC);
+    `);
+        db.exec(`
+      UPDATE memory_atlas_documents SET memory_kind = CASE
+        WHEN node_type IN ('action','project','event','time') THEN node_type
+        WHEN lower(json_extract(metadata_json, '$.clusterType')) IN ('decision','correction','goal','preference','plan','event','evidence')
+          THEN lower(json_extract(metadata_json, '$.clusterType'))
+        WHEN lower(json_extract(metadata_json, '$.episodeType')) IN ('decision','correction','goal','preference','plan','event','evidence')
+          THEN lower(json_extract(metadata_json, '$.episodeType'))
+        WHEN lower(json_extract(metadata_json, '$.ontologyClass')) IN ('person','place','project','object','decision','correction','goal','preference','plan','event','evidence')
+          THEN lower(json_extract(metadata_json, '$.ontologyClass'))
+        WHEN lower(json_extract(metadata_json, '$.entityType')) IN ('person','place','project','object')
+          THEN lower(json_extract(metadata_json, '$.entityType'))
+        ELSE NULL END
+      WHERE memory_kind IS NULL;
+      INSERT INTO memory_atlas_projection_state(project_id,projection_name,cursor_value,status,last_rebuild_at,last_error,metadata_json)
+      SELECT DISTINCT project_id,'memory_atlas.v1',CAST(strftime('%s','now') AS TEXT),'dirty',NULL,NULL,'{"migration":"0026","reason":"requires_rebuild_after_schema_migration"}'
+      FROM memory_atlas_documents WHERE project_id<>''
+      ON CONFLICT(project_id,projection_name) DO UPDATE SET status='dirty',last_error=NULL,metadata_json='{"migration":"0026","reason":"requires_rebuild_after_schema_migration"}';
+    `);
+    },
+    down(db) {
+        db.exec(`
+      DROP INDEX IF EXISTS idx_atlas_access_project_time;
+      DROP INDEX IF EXISTS idx_atlas_documents_project_occurred;
+      DROP INDEX IF EXISTS idx_atlas_documents_project_kind;
+      DROP INDEX IF EXISTS idx_candidate_reviews_candidate_created;
+      DROP INDEX IF EXISTS idx_candidate_reviews_project_created;
+      DROP TABLE IF EXISTS deep_write_candidate_reviews;
+    `);
+    },
+};
+function ensureColumn(db, table, column, definition) {
+    const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (columns.length === 0)
+        return;
+    if (!columns.some((item) => item.name === column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}

package/dist/migrations/0027_openclaw_upgrade_hotfix.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from '../types/Migration.js';
+export declare const migration_0027: Migration;
+//# sourceMappingURL=0027_openclaw_upgrade_hotfix.d.ts.map

package/dist/migrations/0027_openclaw_upgrade_hotfix.js

@@ -0,0 +1,21 @@
+export const migration_0027 = {
+    version: '0027',
+    description: 'mark Atlas projections dirty after 3.6.0 upgrade hotfix',
+    up(db) {
+        db.exec(`
+      UPDATE memory_atlas_projection_state
+      SET status='dirty',
+          last_error=NULL,
+          metadata_json='{"migration":"0027","reason":"3.6.0_may_have_marked_action_time_projection_clean_too_early"}'
+      WHERE projection_name='memory_atlas.v1'
+        AND status='clean'
+        AND (
+          metadata_json IS NULL
+          OR json_extract(metadata_json, '$.migration') IN ('0025','0026')
+        );
+    `);
+    },
+    down() {
+        // Projection freshness is rebuildable state; do not re-mark it clean on downgrade.
+    },
+};

package/dist/migrations/SchemaMigrationRunner.d.ts

@@ -0,0 +1,21 @@
+import Database from 'bun:sqlite';
+import type { Migration } from '../types/Migration.js';
+export interface SchemaMigrationRunOptions {
+    dryRun?: boolean;
+}
+export interface SchemaMigrationResult {
+    pending: string[];
+    applied: string[];
+    currentVersion?: string;
+    dryRun: boolean;
+}
+export declare class SchemaMigrationRunner {
+    private readonly db;
+    private readonly migrations;
+    constructor(db: Database, migrations: Migration[]);
+    plan(): Migration[];
+    run(options?: SchemaMigrationRunOptions): SchemaMigrationResult;
+    currentVersion(): string | undefined;
+    private adoptLegacyVersion;
+}
+//# sourceMappingURL=SchemaMigrationRunner.d.ts.map

package/dist/migrations/SchemaMigrationRunner.js

@@ -0,0 +1,67 @@
+export class SchemaMigrationRunner {
+    db;
+    migrations;
+    constructor(db, migrations) {
+        this.db = db;
+        this.migrations = migrations;
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS _schema_migrations (
+        version TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        applied_at TEXT NOT NULL
+      );
+    `);
+        this.adoptLegacyVersion();
+    }
+    plan() {
+        const applied = new Set(this.db.prepare(`SELECT version FROM _schema_migrations`).all().map((row) => row.version));
+        return [...this.migrations]
+            .sort((a, b) => a.version.localeCompare(b.version))
+            .filter((migration) => !applied.has(migration.version));
+    }
+    run(options = {}) {
+        const pending = this.plan();
+        if (options.dryRun) {
+            return { pending: pending.map((item) => item.version), applied: [], currentVersion: this.currentVersion(), dryRun: true };
+        }
+        const applied = [];
+        const transaction = this.db.transaction(() => {
+            for (const migration of pending) {
+                migration.up(this.db);
+                this.db.prepare(`
+          INSERT INTO _schema_migrations (version, description, applied_at)
+          VALUES (?, ?, ?)
+        `).run(migration.version, migration.description, new Date().toISOString());
+                applied.push(migration.version);
+            }
+        });
+        transaction();
+        return { pending: pending.map((item) => item.version), applied, currentVersion: this.currentVersion(), dryRun: false };
+    }
+    currentVersion() {
+        const row = this.db.prepare(`
+      SELECT version FROM _schema_migrations ORDER BY version DESC LIMIT 1
+    `).get();
+        return row?.version;
+    }
+    adoptLegacyVersion() {
+        const metaExists = this.db.prepare(`
+      SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = '_meta'
+    `).get();
+        if (!metaExists)
+            return;
+        const row = this.db.prepare(`SELECT value FROM _meta WHERE key = 'schema_version'`).get();
+        const legacyVersion = Number.parseInt(row?.value || '', 10);
+        if (!Number.isFinite(legacyVersion))
+            return;
+        const insert = this.db.prepare(`
+      INSERT OR IGNORE INTO _schema_migrations (version, description, applied_at)
+      VALUES (?, ?, ?)
+    `);
+        for (const migration of this.migrations) {
+            if (Number.parseInt(migration.version, 10) <= legacyVersion) {
+                insert.run(migration.version, `adopted: ${migration.description}`, new Date(0).toISOString());
+            }
+        }
+    }
+}

package/dist/migrations/index.d.ts

@@ -0,0 +1,36 @@
+import type { Migration } from '../types/Migration.js';
+import { migration_0001 } from './0001_init.js';
+import { migration_0002 } from './0002_v06_platform.js';
+import { migration_0003 } from './0003_v07_dialogues.js';
+import { migration_0004 } from './0004_v09_self_improvement.js';
+import { migration_0005 } from './0005_dialogue_buffer.js';
+import { migration_0006 } from './0006_deep_write_memory.js';
+import { migration_0007 } from './0007_deep_write_summaries.js';
+import { migration_0009 } from './0009_memory_importance.js';
+import { migration_0010 } from './0010_skill_neurons.js';
+import { migration_0011 } from './0011_topic_path.js';
+import { migration_0012 } from './0012_governance_security.js';
+import { migration_0015 } from './0015_memory_governance.js';
+import { migration_0016 } from './0016_entity_governance.js';
+import { migration_0017 } from './0017_belief_graph.js';
+import { migration_0018 } from './0018_temporal_memory.js';
+import { migration_0019 } from './0019_context_cortex.js';
+import { migration_0020 } from './0020_prospective_memory.js';
+import { migration_0021 } from './0021_strategy_cortex.js';
+import { migration_0022 } from './0022_episode_dream_engine.js';
+import { migration_0023 } from './0023_episode_dream_hardening.js';
+import { migration_0024 } from './0024_episode_ontology_reliability.js';
+import { migration_0025 } from './0025_memory_atlas.js';
+import { migration_0026 } from './0026_runtime_governance_atlas_reliability.js';
+import { migration_0027 } from './0027_openclaw_upgrade_hotfix.js';
+/**
+ * Ordered list of all schema migrations.
+ * Add new migrations here in ascending version order.
+ * MigrationRunner.up() applies only the pending ones.
+ */
+export declare const ALL_MIGRATIONS: Migration[];
+export { migration_0001, migration_0002, migration_0003, migration_0004, migration_0005, migration_0006, migration_0007, migration_0009, migration_0010, migration_0011, migration_0012, migration_0015, migration_0016, migration_0017, migration_0018, migration_0019, migration_0020, migration_0021, migration_0022, migration_0023, migration_0024, migration_0025, migration_0026, migration_0027 };
+export { SchemaMigrationRunner } from './SchemaMigrationRunner.js';
+export type { SchemaMigrationResult, SchemaMigrationRunOptions } from './SchemaMigrationRunner.js';
+export type { Migration };
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.js

@@ -0,0 +1,57 @@
+import { migration_0001 } from './0001_init.js';
+import { migration_0002 } from './0002_v06_platform.js';
+import { migration_0003 } from './0003_v07_dialogues.js';
+import { migration_0004 } from './0004_v09_self_improvement.js';
+import { migration_0005 } from './0005_dialogue_buffer.js';
+import { migration_0006 } from './0006_deep_write_memory.js';
+import { migration_0007 } from './0007_deep_write_summaries.js';
+import { migration_0009 } from './0009_memory_importance.js';
+import { migration_0010 } from './0010_skill_neurons.js';
+import { migration_0011 } from './0011_topic_path.js';
+import { migration_0012 } from './0012_governance_security.js';
+import { migration_0015 } from './0015_memory_governance.js';
+import { migration_0016 } from './0016_entity_governance.js';
+import { migration_0017 } from './0017_belief_graph.js';
+import { migration_0018 } from './0018_temporal_memory.js';
+import { migration_0019 } from './0019_context_cortex.js';
+import { migration_0020 } from './0020_prospective_memory.js';
+import { migration_0021 } from './0021_strategy_cortex.js';
+import { migration_0022 } from './0022_episode_dream_engine.js';
+import { migration_0023 } from './0023_episode_dream_hardening.js';
+import { migration_0024 } from './0024_episode_ontology_reliability.js';
+import { migration_0025 } from './0025_memory_atlas.js';
+import { migration_0026 } from './0026_runtime_governance_atlas_reliability.js';
+import { migration_0027 } from './0027_openclaw_upgrade_hotfix.js';
+/**
+ * Ordered list of all schema migrations.
+ * Add new migrations here in ascending version order.
+ * MigrationRunner.up() applies only the pending ones.
+ */
+export const ALL_MIGRATIONS = [
+    migration_0001,
+    migration_0002,
+    migration_0003,
+    migration_0004,
+    migration_0005,
+    migration_0006,
+    migration_0007,
+    migration_0009,
+    migration_0010,
+    migration_0011,
+    migration_0012,
+    migration_0015,
+    migration_0016,
+    migration_0017,
+    migration_0018,
+    migration_0019,
+    migration_0020,
+    migration_0021,
+    migration_0022,
+    migration_0023,
+    migration_0024,
+    migration_0025,
+    migration_0026,
+    migration_0027,
+];
+export { migration_0001, migration_0002, migration_0003, migration_0004, migration_0005, migration_0006, migration_0007, migration_0009, migration_0010, migration_0011, migration_0012, migration_0015, migration_0016, migration_0017, migration_0018, migration_0019, migration_0020, migration_0021, migration_0022, migration_0023, migration_0024, migration_0025, migration_0026, migration_0027 };
+export { SchemaMigrationRunner } from './SchemaMigrationRunner.js';

package/dist/models/ModelCapabilityRouter.d.ts

@@ -0,0 +1,17 @@
+import type { FileUnderstandingInput, FileUnderstandingPolicy, FileUnderstandingProvider } from '../assets/providers/types.js';
+export interface ModelCapabilityRouterDecision {
+    provider: FileUnderstandingProvider | null;
+    reason: string;
+    requiresUserApproval: boolean;
+}
+export declare class ModelCapabilityRouter {
+    private readonly providers;
+    private readonly policy;
+    constructor(providers?: FileUnderstandingProvider[], policy?: FileUnderstandingPolicy);
+    register(provider: FileUnderstandingProvider): void;
+    choose(input: FileUnderstandingInput): ModelCapabilityRouterDecision;
+    private matchesCapability;
+    private withinSizeLimit;
+    private rankProvider;
+}
+//# sourceMappingURL=ModelCapabilityRouter.d.ts.map

package/dist/models/ModelCapabilityRouter.js

@@ -0,0 +1,75 @@
+export class ModelCapabilityRouter {
+    providers;
+    policy;
+    constructor(providers = [], policy = 'ask_before_cloud_upload') {
+        this.providers = providers;
+        this.policy = policy;
+    }
+    register(provider) {
+        this.providers.push(provider);
+    }
+    choose(input) {
+        const capable = this.providers
+            .filter((provider) => this.matchesCapability(provider, input))
+            .filter((provider) => this.withinSizeLimit(provider, input))
+            .sort((a, b) => this.rankProvider(a, input) - this.rankProvider(b, input));
+        if (capable.length === 0) {
+            return { provider: null, reason: 'no_capable_provider', requiresUserApproval: false };
+        }
+        const local = capable.find((provider) => provider.capabilities.privacy === 'local') || null;
+        const cloud = capable.find((provider) => provider.capabilities.privacy === 'cloud') || null;
+        if (this.policy === 'local_only') {
+            return local
+                ? { provider: local, reason: 'local_only_local_provider', requiresUserApproval: false }
+                : { provider: null, reason: 'local_only_no_local_provider', requiresUserApproval: false };
+        }
+        if (this.policy === 'ask_before_cloud_upload') {
+            if (local)
+                return { provider: local, reason: 'local_provider_available', requiresUserApproval: false };
+            if (cloud && input.userApprovedCloudUpload) {
+                return { provider: cloud, reason: 'cloud_approved_by_user', requiresUserApproval: false };
+            }
+            return { provider: null, reason: 'cloud_upload_requires_user_approval', requiresUserApproval: true };
+        }
+        if (this.policy === 'cloud_for_complex_only') {
+            if (input.complexity === 'complex' && cloud) {
+                return { provider: cloud, reason: 'complex_task_cloud_provider', requiresUserApproval: false };
+            }
+            return local
+                ? { provider: local, reason: 'simple_or_local_preferred', requiresUserApproval: false }
+                : { provider: null, reason: 'no_local_provider_for_non_complex_task', requiresUserApproval: false };
+        }
+        return { provider: capable[0], reason: 'cloud_allowed_best_provider', requiresUserApproval: false };
+    }
+    matchesCapability(provider, input) {
+        const c = provider.capabilities;
+        if (input.modality === 'raw_file' && !c.acceptsRawFile)
+            return false;
+        if (input.modality === 'text' && !c.acceptsText)
+            return false;
+        if (input.modality === 'image' && !c.acceptsImage)
+            return false;
+        if (input.modality === 'audio' && !c.acceptsAudio)
+            return false;
+        if (input.modality === 'video' && !c.acceptsVideo)
+            return false;
+        if (input.task === 'ocr' && !c.supportsOCR)
+            return false;
+        if (input.task === 'asr' && !c.supportsASR)
+            return false;
+        if (input.task === 'caption' && !c.supportsVisionCaption)
+            return false;
+        return true;
+    }
+    withinSizeLimit(provider, input) {
+        if (!input.sizeBytes)
+            return true;
+        return input.sizeBytes <= provider.capabilities.maxFileSizeMb * 1024 * 1024;
+    }
+    rankProvider(provider, input) {
+        const privacyRank = provider.capabilities.privacy === 'local' ? 0 : 10;
+        const costRank = { free: 0, low: 1, medium: 2, high: 3 }[provider.capabilities.costTier];
+        const complexCloudBoost = input.complexity === 'complex' && provider.capabilities.privacy === 'cloud' ? -2 : 0;
+        return privacyRank + costRank + complexCloudBoost;
+    }
+}