@rigour-labs/core 6.0.0 → 6.1.0-beta.2

package/dist/storage/team-store.js

@@ -0,0 +1,321 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { openDatabase } from './db.js';
+import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
+import { TEAM_VECTOR_SCHEMA, backfillConfiguredTeamEmbeddings, getTeamSemanticHealth, searchConfiguredTeamKnowledge, upsertTeamLessonEmbedding, } from './team-vector-store.js';
+const DEFAULT_SEMANTIC = {
+    provider: 'pgvector',
+    model: 'Xenova/all-MiniLM-L6-v2',
+    dimensions: 384,
+};
+export const TEAM_CONFIG_PATH = path.join(os.homedir(), '.rigour', 'team.json');
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+export function validateTeamDatabaseUrl(databaseUrl) {
+    const parsed = new URL(databaseUrl);
+    if (!['postgres:', 'postgresql:'].includes(parsed.protocol)) {
+        throw new Error('Team database URL must use postgres:// or postgresql://.');
+    }
+    const local = ['localhost', '127.0.0.1', '::1'].includes(parsed.hostname);
+    const sslMode = parsed.searchParams.get('sslmode');
+    if (!local && sslMode !== 'require' && sslMode !== 'verify-full') {
+        throw new Error('Remote team databases require sslmode=require or sslmode=verify-full.');
+    }
+}
+export async function loadTeamConfiguration() {
+    let file = {};
+    try {
+        file = await fs.readJson(TEAM_CONFIG_PATH);
+    }
+    catch {
+        // Environment-only configuration is supported.
+    }
+    const organizationId = nonEmpty(process.env.RIGOUR_ORGANIZATION_ID) ?? nonEmpty(file.organizationId);
+    const teamId = nonEmpty(process.env.RIGOUR_TEAM_ID) ?? nonEmpty(file.teamId);
+    const actorId = nonEmpty(process.env.RIGOUR_ACTOR_ID) ?? nonEmpty(file.actorId);
+    const databaseUrl = nonEmpty(process.env.RIGOUR_TEAM_DATABASE_URL) ?? nonEmpty(file.databaseUrl);
+    if (!organizationId || !teamId || !actorId || !databaseUrl)
+        return null;
+    const envSemantic = process.env.RIGOUR_TEAM_SEMANTIC === 'pgvector' ? DEFAULT_SEMANTIC : undefined;
+    const semantic = envSemantic ?? (file.semantic?.provider === 'pgvector' ? DEFAULT_SEMANTIC : undefined);
+    return { organizationId, teamId, actorId, databaseUrl, semantic };
+}
+export async function saveTeamConfiguration(config) {
+    if (!config.databaseUrl)
+        throw new Error('A PostgreSQL database URL is required.');
+    validateTeamDatabaseUrl(config.databaseUrl);
+    for (const [name, value] of Object.entries({
+        organizationId: config.organizationId,
+        teamId: config.teamId,
+        actorId: config.actorId,
+    })) {
+        if (!nonEmpty(value))
+            throw new Error(`${name} is required.`);
+    }
+    await fs.ensureDir(path.dirname(TEAM_CONFIG_PATH));
+    await fs.writeJson(TEAM_CONFIG_PATH, config, { spaces: 2, mode: 0o600 });
+    await fs.chmod(TEAM_CONFIG_PATH, 0o600);
+}
+async function loadPg() {
+    try {
+        return await import('pg');
+    }
+    catch {
+        throw new Error('PostgreSQL support is unavailable. Install the optional "pg" dependency.');
+    }
+}
+async function queuedChanges() {
+    let db;
+    try {
+        db = await openDatabase();
+    }
+    catch {
+        return 0;
+    }
+    if (!db)
+        return 0;
+    try {
+        const row = await db.get('SELECT COUNT(*) AS count FROM sync_outbox WHERE synced_at IS NULL');
+        return Number(row?.count ?? 0);
+    }
+    finally {
+        await db.close();
+    }
+}
+const TEAM_SCHEMA = `
+CREATE SCHEMA IF NOT EXISTS rigour;
+CREATE TABLE IF NOT EXISTS rigour.meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS rigour.memberships (
+    db_role NAME NOT NULL,
+    organization_id TEXT NOT NULL,
+    team_id TEXT NOT NULL,
+    actor_id TEXT NOT NULL,
+    role TEXT NOT NULL CHECK (role IN ('member', 'sme', 'owner')),
+    PRIMARY KEY (db_role, team_id)
+);
+CREATE TABLE IF NOT EXISTS rigour.lessons (
+    id TEXT PRIMARY KEY,
+    organization_id TEXT NOT NULL,
+    team_id TEXT NOT NULL,
+    repository_id TEXT NOT NULL,
+    actor_id TEXT NOT NULL,
+    visibility TEXT NOT NULL CHECK (visibility IN ('personal', 'team')),
+    state TEXT NOT NULL CHECK (state IN ('candidate', 'validated', 'promoted', 'rejected', 'superseded')),
+    kind TEXT NOT NULL,
+    subject TEXT NOT NULL,
+    evidence_json JSONB NOT NULL,
+    confidence DOUBLE PRECISION NOT NULL,
+    source TEXT NOT NULL,
+    supersedes_id TEXT,
+    created_at BIGINT NOT NULL,
+    updated_at BIGINT NOT NULL
+);
+ALTER TABLE rigour.lessons ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS lessons_read ON rigour.lessons;
+CREATE POLICY lessons_read ON rigour.lessons FOR SELECT USING (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lessons.organization_id
+          AND membership.team_id = lessons.team_id
+          AND ((lessons.visibility = 'team' AND lessons.state = 'promoted')
+               OR membership.actor_id = lessons.actor_id)
+    )
+);
+DROP POLICY IF EXISTS lessons_write ON rigour.lessons;
+CREATE POLICY lessons_write ON rigour.lessons FOR ALL USING (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lessons.organization_id
+          AND membership.team_id = lessons.team_id
+          AND membership.actor_id = lessons.actor_id
+          AND (lessons.visibility = 'personal' OR membership.role IN ('sme', 'owner'))
+    )
+) WITH CHECK (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lessons.organization_id
+          AND membership.team_id = lessons.team_id
+          AND membership.actor_id = lessons.actor_id
+          AND (lessons.visibility = 'personal' OR membership.role IN ('sme', 'owner'))
+    )
+);
+INSERT INTO rigour.meta (key, value) VALUES ('schema_version', '1')
+ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value;
+`;
+export async function initializeTeamSchema(databaseUrl, options = {}) {
+    validateTeamDatabaseUrl(databaseUrl);
+    const { Pool } = await loadPg();
+    const pool = new Pool({ connectionString: databaseUrl });
+    try {
+        await pool.query(TEAM_SCHEMA);
+        if (options.pgvector)
+            await pool.query(TEAM_VECTOR_SCHEMA);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function getTeamModeStatus() {
+    const config = await loadTeamConfiguration();
+    const queued = await queuedChanges();
+    if (!config?.databaseUrl) {
+        return { mode: 'local', connectivity: 'local', queuedChanges: queued, message: 'SQLite local-only mode' };
+    }
+    try {
+        const result = await doctorTeamConnection(config);
+        return result;
+    }
+    catch (error) {
+        return {
+            mode: 'team',
+            connectivity: 'offline',
+            organizationId: config.organizationId,
+            teamId: config.teamId,
+            actorId: config.actorId,
+            queuedChanges: queued,
+            message: `Offline — changes queued. ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export async function doctorTeamConnection(config) {
+    const resolved = config ?? await loadTeamConfiguration();
+    if (!resolved?.databaseUrl) {
+        return { mode: 'local', connectivity: 'local', queuedChanges: await queuedChanges(), message: 'Team mode is not configured.' };
+    }
+    validateTeamDatabaseUrl(resolved.databaseUrl);
+    const { Pool } = await loadPg();
+    const pool = new Pool({ connectionString: resolved.databaseUrl });
+    try {
+        const result = await pool.query(`SELECT current_user AS database_role,
+                    (SELECT value::integer FROM rigour.meta WHERE key = 'schema_version') AS schema_version,
+                    role
+             FROM rigour.memberships
+             WHERE db_role = current_user AND team_id = $1 AND actor_id = $2 AND organization_id = $3`, [resolved.teamId, resolved.actorId, resolved.organizationId]);
+        if (result.rowCount !== 1)
+            throw new Error('Database role is not provisioned for this team.');
+        const schemaVersion = Number(result.rows[0].schema_version);
+        if (schemaVersion !== 1)
+            throw new Error(`Incompatible team schema version ${schemaVersion}; expected 1.`);
+        const semantic = resolved.semantic ? await getTeamSemanticHealth(pool, resolved) : undefined;
+        return {
+            mode: 'team',
+            connectivity: 'online',
+            organizationId: resolved.organizationId,
+            teamId: resolved.teamId,
+            actorId: resolved.actorId,
+            queuedChanges: await queuedChanges(),
+            schemaVersion,
+            databaseRole: String(result.rows[0].database_role),
+            permissions: [String(result.rows[0].role)],
+            semantic,
+            message: 'PostgreSQL team mode is healthy.',
+        };
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function syncTeamOutbox(options = {}) {
+    const config = await loadTeamConfiguration();
+    if (!config?.databaseUrl)
+        throw new Error('Team mode is not configured.');
+    const db = await openDatabase();
+    if (!db)
+        throw new Error('SQLite offline cache is unavailable.');
+    try {
+        const pending = await db.all(`SELECT * FROM sync_outbox WHERE synced_at IS NULL ORDER BY created_at ASC LIMIT 200`);
+        if (options.dryRun)
+            return { pending: pending.length, synced: 0, pulled: 0 };
+        const { Pool } = await loadPg();
+        const pool = new Pool({ connectionString: config.databaseUrl });
+        let synced = 0;
+        let pulled = 0;
+        try {
+            const membership = await pool.query(`SELECT 1 FROM rigour.memberships
+                  WHERE db_role = current_user AND team_id = $1
+                    AND actor_id = $2 AND organization_id = $3`, [config.teamId, config.actorId, config.organizationId]);
+            if (membership.rowCount !== 1)
+                throw new Error('Database role is not provisioned for this team.');
+            for (const item of pending) {
+                const lesson = await decryptLocalPayload(item.payload_json);
+                try {
+                    const result = await pool.query(`INSERT INTO rigour.lessons (
+                        id, organization_id, team_id, repository_id, actor_id, visibility, state,
+                        kind, subject, evidence_json, confidence, source, supersedes_id, created_at, updated_at
+                    )
+                    SELECT $1, membership.organization_id, membership.team_id, $2, membership.actor_id,
+                           $3, $4, $5, $6, $7::jsonb, $8, $9, $10, $11, $12
+                    FROM rigour.memberships membership
+                    WHERE membership.db_role = current_user AND membership.team_id = $13
+                      AND membership.actor_id = $14 AND membership.organization_id = $15
+                    ON CONFLICT (id) DO UPDATE SET
+                        visibility = EXCLUDED.visibility,
+                        state = EXCLUDED.state,
+                        evidence_json = EXCLUDED.evidence_json,
+                        confidence = EXCLUDED.confidence,
+                        updated_at = EXCLUDED.updated_at
+                    WHERE rigour.lessons.updated_at <= EXCLUDED.updated_at
+                    RETURNING id`, [
+                        lesson.id, lesson.repositoryId, lesson.visibility, lesson.state, lesson.kind,
+                        lesson.subject, JSON.stringify(lesson.evidence), lesson.confidence, lesson.source,
+                        lesson.supersedesId ?? null, lesson.createdAt, lesson.updatedAt, config.teamId,
+                        config.actorId, config.organizationId,
+                    ]);
+                    if (config.semantic && result.rowCount > 0)
+                        await upsertTeamLessonEmbedding(pool, config, lesson);
+                    await db.run('UPDATE sync_outbox SET synced_at = ?, last_error = NULL WHERE id = ?', Date.now(), item.id);
+                    synced++;
+                }
+                catch (error) {
+                    await db.run('UPDATE sync_outbox SET attempts = attempts + 1, last_error = ? WHERE id = ?', String(error instanceof Error ? error.message : error).slice(0, 1_000), item.id);
+                    throw error;
+                }
+            }
+            const remote = await pool.query(`SELECT * FROM rigour.lessons
+                 WHERE team_id = $1 AND organization_id = $3
+                   AND ((actor_id = $2) OR (visibility = 'team' AND state = 'promoted'))
+                 ORDER BY updated_at ASC`, [config.teamId, config.actorId, config.organizationId]);
+            for (const row of remote.rows) {
+                const evidence = typeof row.evidence_json === 'string' ? JSON.parse(row.evidence_json) : row.evidence_json;
+                await db.run(`INSERT INTO lessons (
+                        id, repository_id, actor_id, team_id, visibility, state, kind, subject,
+                        evidence_json, confidence, source, supersedes_id, created_at, updated_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET
+                        visibility=excluded.visibility, state=excluded.state, evidence_json=excluded.evidence_json,
+                        confidence=excluded.confidence, source=excluded.source, supersedes_id=excluded.supersedes_id,
+                        updated_at=excluded.updated_at`, row.id, row.repository_id, row.actor_id, row.team_id, row.visibility, row.state, row.kind, row.subject, await encryptLocalPayload(evidence), row.confidence, row.source, row.supersedes_id, Number(row.created_at), Number(row.updated_at));
+                pulled++;
+            }
+            if (pulled > 0)
+                await db.run("DELETE FROM context_cache WHERE cache_type = 'semantic'");
+        }
+        finally {
+            await pool.end();
+        }
+        return { pending: pending.length, synced, pulled };
+    }
+    finally {
+        await db.close();
+    }
+}
+export async function backfillTeamEmbeddings(limit = 200) {
+    const config = await loadTeamConfiguration();
+    if (!config)
+        throw new Error('pgvector team semantics is not configured.');
+    return backfillConfiguredTeamEmbeddings(config, limit);
+}
+export async function searchTeamKnowledge(query, limit = 8) {
+    const config = await loadTeamConfiguration();
+    if (!config)
+        return { status: 'disabled', candidates: [] };
+    return searchConfiguredTeamKnowledge(config, query, limit);
+}

package/dist/storage/team-store.test.d.ts

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

package/dist/storage/team-store.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { validateTeamDatabaseUrl } from './team-store.js';
+describe('team database configuration', () => {
+    it('requires TLS for remote PostgreSQL URLs', () => {
+        expect(() => validateTeamDatabaseUrl('postgresql://user:pass@db.example.com/rigour')).toThrow(/sslmode/);
+        expect(() => validateTeamDatabaseUrl('postgresql://user:pass@db.example.com/rigour?sslmode=verify-full')).not.toThrow();
+    });
+    it('rejects non-PostgreSQL URLs', () => {
+        expect(() => validateTeamDatabaseUrl('mysql://localhost/rigour')).toThrow(/postgres/);
+    });
+});

package/dist/storage/team-vector-store.d.ts

@@ -0,0 +1,25 @@
+import type { SemanticKnowledgeResult, TeamConfiguration, TeamModeStatus } from './team-store.js';
+type PgPool = {
+    query: (sql: string, params?: unknown[]) => Promise<any>;
+    end: () => Promise<void>;
+};
+interface EmbeddableLesson {
+    id: string;
+    repositoryId?: string;
+    repository_id?: string;
+    actorId?: string;
+    actor_id?: string;
+    kind: string;
+    subject: string;
+    source: string;
+}
+export declare const TEAM_VECTOR_SCHEMA = "\nCREATE EXTENSION IF NOT EXISTS vector;\nCREATE TABLE IF NOT EXISTS rigour.lesson_embeddings (\n    lesson_id TEXT PRIMARY KEY REFERENCES rigour.lessons(id) ON DELETE CASCADE,\n    organization_id TEXT NOT NULL,\n    team_id TEXT NOT NULL,\n    repository_id TEXT NOT NULL,\n    actor_id TEXT NOT NULL,\n    model TEXT NOT NULL,\n    content_hash TEXT NOT NULL,\n    embedding vector(384) NOT NULL,\n    updated_at BIGINT NOT NULL\n);\nALTER TABLE rigour.lesson_embeddings ENABLE ROW LEVEL SECURITY;\nDROP POLICY IF EXISTS lesson_embeddings_read ON rigour.lesson_embeddings;\nCREATE POLICY lesson_embeddings_read ON rigour.lesson_embeddings FOR SELECT USING (\n    EXISTS (\n        SELECT 1 FROM rigour.memberships membership\n        JOIN rigour.lessons lesson ON lesson.id = lesson_embeddings.lesson_id\n        WHERE membership.db_role = current_user\n          AND membership.organization_id = lesson_embeddings.organization_id\n          AND membership.team_id = lesson_embeddings.team_id\n          AND ((lesson.visibility = 'team' AND lesson.state = 'promoted')\n               OR membership.actor_id = lesson.actor_id)\n    )\n);\nDROP POLICY IF EXISTS lesson_embeddings_write ON rigour.lesson_embeddings;\nCREATE POLICY lesson_embeddings_write ON rigour.lesson_embeddings FOR ALL USING (\n    EXISTS (\n        SELECT 1 FROM rigour.memberships membership\n        WHERE membership.db_role = current_user\n          AND membership.organization_id = lesson_embeddings.organization_id\n          AND membership.team_id = lesson_embeddings.team_id\n          AND membership.actor_id = lesson_embeddings.actor_id\n    )\n) WITH CHECK (\n    EXISTS (\n        SELECT 1 FROM rigour.memberships membership\n        WHERE membership.db_role = current_user\n          AND membership.organization_id = lesson_embeddings.organization_id\n          AND membership.team_id = lesson_embeddings.team_id\n          AND membership.actor_id = lesson_embeddings.actor_id\n    )\n);\nCREATE INDEX IF NOT EXISTS lesson_embeddings_scope\n    ON rigour.lesson_embeddings (organization_id, team_id, model);\nCREATE INDEX IF NOT EXISTS lesson_embeddings_hnsw\n    ON rigour.lesson_embeddings USING hnsw (embedding vector_cosine_ops);\n";
+export declare function getTeamSemanticHealth(pool: PgPool, config: TeamConfiguration): Promise<NonNullable<TeamModeStatus['semantic']>>;
+export declare function upsertTeamLessonEmbedding(pool: PgPool, config: TeamConfiguration, lesson: EmbeddableLesson): Promise<boolean>;
+export declare function backfillConfiguredTeamEmbeddings(config: TeamConfiguration, limit: number): Promise<{
+    eligible: number;
+    embedded: number;
+    skipped: number;
+}>;
+export declare function searchConfiguredTeamKnowledge(config: TeamConfiguration, query: string, limit: number): Promise<SemanticKnowledgeResult>;
+export {};

package/dist/storage/team-vector-store.js

@@ -0,0 +1,183 @@
+import { createHash } from 'node:crypto';
+export const TEAM_VECTOR_SCHEMA = `
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE TABLE IF NOT EXISTS rigour.lesson_embeddings (
+    lesson_id TEXT PRIMARY KEY REFERENCES rigour.lessons(id) ON DELETE CASCADE,
+    organization_id TEXT NOT NULL,
+    team_id TEXT NOT NULL,
+    repository_id TEXT NOT NULL,
+    actor_id TEXT NOT NULL,
+    model TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    embedding vector(384) NOT NULL,
+    updated_at BIGINT NOT NULL
+);
+ALTER TABLE rigour.lesson_embeddings ENABLE ROW LEVEL SECURITY;
+DROP POLICY IF EXISTS lesson_embeddings_read ON rigour.lesson_embeddings;
+CREATE POLICY lesson_embeddings_read ON rigour.lesson_embeddings FOR SELECT USING (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        JOIN rigour.lessons lesson ON lesson.id = lesson_embeddings.lesson_id
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lesson_embeddings.organization_id
+          AND membership.team_id = lesson_embeddings.team_id
+          AND ((lesson.visibility = 'team' AND lesson.state = 'promoted')
+               OR membership.actor_id = lesson.actor_id)
+    )
+);
+DROP POLICY IF EXISTS lesson_embeddings_write ON rigour.lesson_embeddings;
+CREATE POLICY lesson_embeddings_write ON rigour.lesson_embeddings FOR ALL USING (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lesson_embeddings.organization_id
+          AND membership.team_id = lesson_embeddings.team_id
+          AND membership.actor_id = lesson_embeddings.actor_id
+    )
+) WITH CHECK (
+    EXISTS (
+        SELECT 1 FROM rigour.memberships membership
+        WHERE membership.db_role = current_user
+          AND membership.organization_id = lesson_embeddings.organization_id
+          AND membership.team_id = lesson_embeddings.team_id
+          AND membership.actor_id = lesson_embeddings.actor_id
+    )
+);
+CREATE INDEX IF NOT EXISTS lesson_embeddings_scope
+    ON rigour.lesson_embeddings (organization_id, team_id, model);
+CREATE INDEX IF NOT EXISTS lesson_embeddings_hnsw
+    ON rigour.lesson_embeddings USING hnsw (embedding vector_cosine_ops);
+`;
+async function createPool(databaseUrl) {
+    try {
+        const { Pool } = await import('pg');
+        return new Pool({ connectionString: databaseUrl });
+    }
+    catch {
+        throw new Error('PostgreSQL support is unavailable. Install the optional "pg" dependency.');
+    }
+}
+function vectorLiteral(values) {
+    if (!values.length || values.some(value => !Number.isFinite(value)))
+        throw new Error('Embedding contains invalid values.');
+    return `[${values.join(',')}]`;
+}
+export async function getTeamSemanticHealth(pool, config) {
+    if (!config.semantic)
+        throw new Error('pgvector team semantics is not configured.');
+    const result = await pool.query(`SELECT (SELECT extversion FROM pg_extension WHERE extname = 'vector') AS extversion,
+                to_regclass('rigour.lesson_embeddings') IS NOT NULL AS table_ready,
+                (SELECT COUNT(*)::integer FROM rigour.lesson_embeddings) AS indexed_lessons,
+                (SELECT COUNT(*)::integer
+                   FROM rigour.lessons lesson
+                  WHERE lesson.state IN ('validated', 'promoted')
+                    AND NOT EXISTS (
+                        SELECT 1 FROM rigour.lesson_embeddings embedding
+                        WHERE embedding.lesson_id = lesson.id
+                    )) AS missing_lessons`);
+    const row = result.rows[0];
+    if (!row?.extversion || !row?.table_ready) {
+        throw new Error('pgvector semantic storage is configured but the vector extension or lesson_embeddings table is missing.');
+    }
+    return {
+        provider: 'pgvector',
+        status: 'ready',
+        extensionVersion: String(row.extversion),
+        model: config.semantic.model,
+        dimensions: config.semantic.dimensions,
+        indexedLessons: Number(row.indexed_lessons ?? 0),
+        missingLessons: Number(row.missing_lessons ?? 0),
+    };
+}
+export async function upsertTeamLessonEmbedding(pool, config, lesson) {
+    if (!config.semantic)
+        return false;
+    const { generateEmbedding } = await import('../pattern-index/embeddings.js');
+    const content = `${lesson.kind}\n${lesson.subject}\n${lesson.source}`;
+    const embedding = await generateEmbedding(content);
+    if (embedding.length !== config.semantic.dimensions)
+        return false;
+    await pool.query(`INSERT INTO rigour.lesson_embeddings (
+            lesson_id, organization_id, team_id, repository_id, actor_id,
+            model, content_hash, embedding, updated_at
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::vector, $9)
+        ON CONFLICT (lesson_id) DO UPDATE SET
+            model=EXCLUDED.model, content_hash=EXCLUDED.content_hash,
+            embedding=EXCLUDED.embedding, updated_at=EXCLUDED.updated_at`, [lesson.id, config.organizationId, config.teamId, lesson.repositoryId ?? lesson.repository_id,
+        lesson.actorId ?? lesson.actor_id ?? config.actorId, config.semantic.model,
+        createHash('sha256').update(content).digest('hex'), vectorLiteral(embedding), Date.now()]);
+    return true;
+}
+export async function backfillConfiguredTeamEmbeddings(config, limit) {
+    if (!config.databaseUrl || !config.semantic)
+        throw new Error('pgvector team semantics is not configured.');
+    const pool = await createPool(config.databaseUrl);
+    try {
+        const lessons = await pool.query(`SELECT lesson.id, lesson.repository_id, lesson.actor_id, lesson.kind, lesson.subject, lesson.source
+               FROM rigour.lessons lesson
+              WHERE lesson.organization_id = $1 AND lesson.team_id = $2
+                AND lesson.actor_id = $3
+                AND lesson.state IN ('validated', 'promoted')
+                AND NOT EXISTS (
+                    SELECT 1 FROM rigour.lesson_embeddings embedding
+                    WHERE embedding.lesson_id = lesson.id AND embedding.model = $4
+                )
+              ORDER BY lesson.updated_at ASC LIMIT $5`, [config.organizationId, config.teamId, config.actorId, config.semantic.model, Math.max(1, Math.min(2_000, limit))]);
+        let embedded = 0;
+        for (const lesson of lessons.rows) {
+            if (await upsertTeamLessonEmbedding(pool, config, lesson))
+                embedded++;
+        }
+        return { eligible: lessons.rows.length, embedded, skipped: lessons.rows.length - embedded };
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function searchConfiguredTeamKnowledge(config, query, limit) {
+    if (!config.semantic || !config.databaseUrl)
+        return { status: 'disabled', candidates: [] };
+    try {
+        const { generateEmbedding } = await import('../pattern-index/embeddings.js');
+        const embedding = await generateEmbedding(query);
+        if (embedding.length !== config.semantic.dimensions) {
+            return {
+                status: 'degraded', provider: 'pgvector', model: config.semantic.model, candidates: [],
+                message: `Embedding model returned ${embedding.length} dimensions; expected ${config.semantic.dimensions}.`,
+            };
+        }
+        const pool = await createPool(config.databaseUrl);
+        try {
+            const result = await pool.query(`SELECT lesson.id, lesson.repository_id, lesson.subject, lesson.visibility,
+                        lesson.state, lesson.confidence, lesson.source,
+                        1 - (embedding.embedding <=> $1::vector) AS similarity
+                   FROM rigour.lesson_embeddings embedding
+                   JOIN rigour.lessons lesson ON lesson.id = embedding.lesson_id
+                  WHERE embedding.organization_id = $2 AND embedding.team_id = $3
+                    AND embedding.model = $4
+                    AND ((lesson.visibility = 'personal' AND lesson.actor_id = $7
+                          AND lesson.state IN ('validated', 'promoted'))
+                         OR (lesson.visibility = 'team' AND lesson.state = 'promoted'))
+                    AND 1 - (embedding.embedding <=> $1::vector) >= $6
+                  ORDER BY embedding.embedding <=> $1::vector LIMIT $5`, [vectorLiteral(embedding), config.organizationId, config.teamId, config.semantic.model,
+                Math.max(1, Math.min(25, limit)), 0.45, config.actorId]);
+            return {
+                status: 'ready', provider: 'pgvector', model: config.semantic.model,
+                candidates: result.rows.map((row) => ({
+                    lessonId: String(row.id), repositoryId: String(row.repository_id), subject: String(row.subject),
+                    visibility: String(row.visibility), state: String(row.state), confidence: Number(row.confidence),
+                    similarity: Number(row.similarity), provenance: `${row.visibility}:${row.source}:${row.id}`,
+                })),
+            };
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    catch (error) {
+        return {
+            status: 'degraded', provider: 'pgvector', model: config.semantic.model, candidates: [],
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/storage/team-vector-store.test.d.ts

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

package/dist/storage/team-vector-store.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { getTeamSemanticHealth } from './team-vector-store.js';
+const config = {
+    organizationId: 'acme',
+    teamId: 'platform',
+    actorId: 'alice',
+    databaseUrl: 'postgresql://localhost/rigour',
+    semantic: {
+        provider: 'pgvector',
+        model: 'Xenova/all-MiniLM-L6-v2',
+        dimensions: 384,
+    },
+};
+describe('pgvector team health', () => {
+    it('reports extension, model, and embedding coverage', async () => {
+        const pool = {
+            query: async () => ({ rows: [{
+                        extversion: '0.8.1',
+                        table_ready: true,
+                        indexed_lessons: 12,
+                        missing_lessons: 3,
+                    }] }),
+            end: async () => undefined,
+        };
+        await expect(getTeamSemanticHealth(pool, config)).resolves.toEqual({
+            provider: 'pgvector',
+            status: 'ready',
+            extensionVersion: '0.8.1',
+            model: 'Xenova/all-MiniLM-L6-v2',
+            dimensions: 384,
+            indexedLessons: 12,
+            missingLessons: 3,
+        });
+    });
+    it('fails health checks when vector storage is incomplete', async () => {
+        const pool = {
+            query: async () => ({ rows: [{ extversion: null, table_ready: false }] }),
+            end: async () => undefined,
+        };
+        await expect(getTeamSemanticHealth(pool, config)).rejects.toThrow(/vector extension/);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.0.0",
+  "version": "6.1.0-beta.2",
   "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -64,18 +64,20 @@
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.30.1",
     "@xenova/transformers": "^2.17.2",
+    "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.0.0",
-    "@rigour-labs/brain-linux-arm64": "6.0.0",
-    "@rigour-labs/brain-darwin-x64": "6.0.0",
-    "@rigour-labs/brain-win-x64": "6.0.0",
-    "@rigour-labs/brain-linux-x64": "6.0.0"
+    "@rigour-labs/brain-darwin-arm64": "6.1.0-beta.2",
+    "@rigour-labs/brain-win-x64": "6.1.0-beta.2",
+    "@rigour-labs/brain-linux-x64": "6.1.0-beta.2",
+    "@rigour-labs/brain-darwin-x64": "6.1.0-beta.2",
+    "@rigour-labs/brain-linux-arm64": "6.1.0-beta.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^25.0.3",
+    "@types/pg": "^8.15.5",
     "@types/semver": "^7.7.1"
   },
   "scripts": {