@rigour-labs/cli 6.0.0 → 6.1.0-beta.1

package/dist/cli.js

@@ -20,6 +20,7 @@ import { reviewCommand } from './commands/review.js';
 import { checkPatternCommand } from './commands/check-pattern.js';
 import { securityAuditCommand } from './commands/security-audit.js';
 import { firewallTransactCommand, firewallAdversarialCommand, firewallAdmitCommand, firewallStatusCommand } from './commands/firewall.js';
+import { teamCommand } from './commands/team.js';
 import { checkForUpdates } from './utils/version.js';
 import { getCliVersion } from './utils/cli-version.js';
 import chalk from 'chalk';
@@ -29,6 +30,7 @@ program.addCommand(indexCommand);
 program.addCommand(studioCommand);
 program.addCommand(brainCommand);
 program.addCommand(deepStatsCommand);
+program.addCommand(teamCommand);
 program
     .name('rigour')
     .description('🛡️ Rigour: The Quality Gate Loop for AI-Assisted Engineering')

package/dist/commands/hooks.js

@@ -18,7 +18,7 @@ import path from 'path';
 import chalk from 'chalk';
 import { randomUUID } from 'crypto';
 import { fileURLToPath } from 'url';
-import { runHookChecker, scanInputForCredentials, formatDLPAlert, createDLPAuditEntry, writeDLPBlockManifest, allowLastDLPBlock } from '@rigour-labs/core';
+import { allowLastDLPBlock, createDLPAuditEntry, formatDLPAlert, recordInteractionEvidence, recordInteractionLesson, runHookChecker, scanInputForCredentials, updateAutomaticIndexForFiles, writeDLPBlockManifest, } from '@rigour-labs/core';
 function getHookCliVersion() {
     const thisDir = path.dirname(fileURLToPath(import.meta.url));
     const packagePath = path.resolve(thisDir, '../../package.json');
@@ -648,7 +648,28 @@ export async function hooksCheckCommand(cwd, options = {}) {
         cwd,
         files,
         timeout_ms: Number.isFinite(timeout) ? timeout : 5000,
+        agentId: options.agent || process.env.RIGOUR_AGENT_ID,
     });
+    const requestId = randomUUID();
+    const outcome = result.status === 'pass' ? 'success' : result.status === 'fail' ? 'rejected' : 'error';
+    await Promise.allSettled([
+        updateAutomaticIndexForFiles(cwd, files),
+        recordInteractionEvidence(cwd, {
+            tool: 'rigour_hooks_check', requestId, phase: 'response', outcome,
+            deterministic: result.status === 'pass', agentId: options.agent || process.env.RIGOUR_AGENT_ID,
+            files, summary: `${result.failures.length} finding(s)`,
+        }),
+        recordInteractionLesson(cwd, {
+            tool: 'rigour_hooks_check', requestId, outcome,
+            deterministic: result.status === 'pass', agentId: options.agent || process.env.RIGOUR_AGENT_ID,
+            files, summary: `${result.failures.length} finding(s)`,
+        }),
+        logStudioEvent(cwd, {
+            type: 'hook_check', requestId, outcome, status: result.status,
+            agentId: options.agent || process.env.RIGOUR_AGENT_ID,
+            files, summary: `${files.length} file(s), ${result.failures.length} finding(s)`,
+        }),
+    ]);
     // Return Cursor-compatible format if detected as Cursor hook
     if (cursorMode) {
         if (result.status === 'fail') {

package/dist/commands/index.js

@@ -30,7 +30,7 @@ async function logStudioEvent(cwd, event) {
 // native dependency issues from affecting the rest of the CLI.
 export const indexCommand = new Command('index')
     .description('Build or update the pattern index for the current project')
-    .option('-s, --semantic', 'Generate semantic embeddings for better matching (requires Transformers.js)', false)
+    .option('--no-semantic', 'Skip local semantic embeddings and build only the structural index')
     .option('-f, --force', 'Force a full rebuild of the index', false)
     .option('-o, --output <path>', 'Custom path for the index file')
     .action(async (options) => {

package/dist/commands/studio-contracts.d.ts

@@ -0,0 +1,20 @@
+export type AgentStatus = 'active' | 'idle' | 'completed';
+export type AgentSessionStatus = AgentStatus | 'aborted' | 'inactive';
+export interface StudioAgent {
+    agentId: string;
+    taskScope: string[];
+    registeredAt: string;
+    lastCheckpoint?: string;
+    status: AgentStatus;
+}
+export interface StudioAgentSession {
+    schemaVersion: 1;
+    sessionId: string;
+    agents: StudioAgent[];
+    status: AgentSessionStatus;
+    createdAt: string;
+    derived: boolean;
+    dataQuality: 'valid' | 'degraded';
+    warnings: string[];
+}
+export declare function normalizeAgentSession(input: unknown, now?: string): StudioAgentSession;

package/dist/commands/studio-contracts.js

@@ -0,0 +1,78 @@
+const AGENT_STATUSES = new Set(['active', 'idle', 'completed']);
+const SESSION_STATUSES = new Set([
+    'active',
+    'idle',
+    'completed',
+    'aborted',
+    'inactive',
+]);
+function record(value) {
+    return value && typeof value === 'object' ? value : {};
+}
+function validDate(value, fallback) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return fallback;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? fallback : date.toISOString();
+}
+function inferSessionStatus(agents) {
+    if (agents.length === 0)
+        return 'inactive';
+    if (agents.some((agent) => agent.status === 'active'))
+        return 'active';
+    if (agents.some((agent) => agent.status === 'idle'))
+        return 'idle';
+    return 'completed';
+}
+export function normalizeAgentSession(input, now = new Date().toISOString()) {
+    const source = record(input);
+    const warnings = [];
+    const rawAgents = Array.isArray(source.agents) ? source.agents : [];
+    if (!Array.isArray(source.agents) && source.agents !== undefined) {
+        warnings.push('Ignored invalid agents collection.');
+    }
+    const agents = rawAgents.map((value, index) => {
+        const raw = record(value);
+        const agentId = typeof raw.agentId === 'string' && raw.agentId.trim()
+            ? raw.agentId.trim()
+            : `unknown-agent-${index + 1}`;
+        if (agentId.startsWith('unknown-agent-'))
+            warnings.push(`Agent ${index + 1} had no identifier.`);
+        const taskScope = Array.isArray(raw.taskScope)
+            ? raw.taskScope.filter((scope) => typeof scope === 'string' && scope.length > 0)
+            : [];
+        if (!Array.isArray(raw.taskScope) && raw.taskScope !== undefined) {
+            warnings.push(`Agent ${agentId} had an invalid scope.`);
+        }
+        const status = typeof raw.status === 'string' && AGENT_STATUSES.has(raw.status)
+            ? raw.status
+            : 'idle';
+        if (status === 'idle' && raw.status !== 'idle')
+            warnings.push(`Agent ${agentId} had no valid status.`);
+        const registeredAt = validDate(raw.registeredAt, now);
+        const lastCheckpoint = raw.lastCheckpoint === undefined
+            ? undefined
+            : validDate(raw.lastCheckpoint, registeredAt);
+        return { agentId, taskScope, registeredAt, lastCheckpoint, status };
+    });
+    const requestedStatus = typeof source.status === 'string'
+        ? source.status
+        : undefined;
+    const status = requestedStatus && SESSION_STATUSES.has(requestedStatus)
+        ? requestedStatus
+        : inferSessionStatus(agents);
+    if (requestedStatus !== status)
+        warnings.push('Session status was inferred from agent activity.');
+    return {
+        schemaVersion: 1,
+        sessionId: typeof source.sessionId === 'string' && source.sessionId.trim()
+            ? source.sessionId
+            : agents.length > 0 ? 'legacy-session' : 'inactive',
+        agents,
+        status,
+        createdAt: validDate(source.createdAt, agents[0]?.registeredAt ?? now),
+        derived: Boolean(source.derived),
+        dataQuality: warnings.length > 0 ? 'degraded' : 'valid',
+        warnings,
+    };
+}

package/dist/commands/studio-contracts.test.d.ts

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

package/dist/commands/studio-contracts.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeAgentSession } from './studio-contracts.js';
+describe('normalizeAgentSession', () => {
+    it('repairs a legacy session without status', () => {
+        const session = normalizeAgentSession({
+            sessionId: 'legacy',
+            agents: [{ agentId: 'agent-1', taskScope: ['src/**'], registeredAt: '2026-09-10T00:00:00Z' }],
+        }, '2026-09-10T01:00:00.000Z');
+        expect(session.status).toBe('idle');
+        expect(session.agents[0].status).toBe('idle');
+        expect(session.dataQuality).toBe('degraded');
+        expect(session.warnings).toContain('Session status was inferred from agent activity.');
+    });
+    it('returns an inactive contract for malformed input', () => {
+        expect(normalizeAgentSession({ agents: 'broken' }).status).toBe('inactive');
+        expect(normalizeAgentSession(null).agents).toEqual([]);
+    });
+    it('preserves valid current sessions', () => {
+        const session = normalizeAgentSession({
+            sessionId: 'session-1',
+            status: 'active',
+            createdAt: '2026-09-10T00:00:00Z',
+            agents: [{
+                    agentId: 'agent-1',
+                    taskScope: ['src/**'],
+                    registeredAt: '2026-09-10T00:00:00Z',
+                    status: 'active',
+                }],
+        });
+        expect(session.dataQuality).toBe('valid');
+        expect(session.status).toBe('active');
+    });
+});

package/dist/commands/studio.js

@@ -4,8 +4,11 @@ import os from 'os';
 import chalk from 'chalk';
 import { execa } from 'execa';
 import fs from 'fs-extra';
+import { createReadStream, promises as nativeFs } from 'fs';
+import readline from 'readline';
 import http from 'http';
 import { randomUUID } from 'crypto';
+import { normalizeAgentSession } from './studio-contracts.js';
 function sendJson(res, status, body) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(body));
@@ -20,6 +23,44 @@ async function readJsonIfExists(filePath) {
         return null;
     }
 }
+async function readRecentLines(filePath, limit) {
+    const stat = await nativeFs.stat(filePath);
+    const bytes = Math.min(stat.size, 512 * 1024);
+    const handle = await nativeFs.open(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(bytes);
+        await handle.read(buffer, 0, bytes, stat.size - bytes);
+        return buffer.toString('utf8').split('\n').filter(line => line.trim()).slice(-limit);
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readEventPage(filePath, limit, before) {
+    if (!(await fs.pathExists(filePath)))
+        return { events: [], hasMore: false };
+    const ring = [];
+    let matching = 0;
+    const lines = readline.createInterface({ input: createReadStream(filePath), crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const event = JSON.parse(line);
+            const timestamp = Date.parse(event.timestamp ?? event.createdAt ?? 0);
+            if (before && (!Number.isFinite(timestamp) || timestamp >= before))
+                continue;
+            matching++;
+            ring.push(event);
+            if (ring.length > limit)
+                ring.shift();
+        }
+        catch {
+            // Malformed historical lines are ignored without hiding the remaining ledger.
+        }
+    }
+    return { events: ring.reverse(), hasMore: matching > limit };
+}
 async function mergeMemoryStores(cwd) {
     const sources = [];
     const memories = {};
@@ -72,7 +113,7 @@ async function synthesizeAgents(cwd, checkpoints) {
     const sessionPath = path.join(cwd, '.rigour/agent-session.json');
     const session = await readJsonIfExists(sessionPath);
     if (session?.agents?.length) {
-        return session;
+        return normalizeAgentSession(session);
     }
     const byAgent = new Map();
     for (const cp of checkpoints) {
@@ -94,13 +135,13 @@ async function synthesizeAgents(cwd, checkpoints) {
         }
     }
     const agents = [...byAgent.values()];
-    return {
+    return normalizeAgentSession({
         sessionId: agents.length ? 'derived-from-checkpoints' : 'inactive',
         agents,
         status: agents.length ? 'completed' : 'inactive',
         createdAt: agents[0]?.registeredAt || new Date().toISOString(),
         derived: true,
-    };
+    });
 }
 async function handleApiRequest(req, res, url, ctx) {
     if (!url.pathname.startsWith('/api'))
@@ -112,6 +153,7 @@ async function handleApiRequest(req, res, url, ctx) {
     }
     res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS, POST, DELETE');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    res.setHeader('X-Rigour-Api-Version', '1');
     if (req.method === 'OPTIONS') {
         res.writeHead(204);
         res.end();
@@ -124,30 +166,35 @@ async function handleApiRequest(req, res, url, ctx) {
             'Cache-Control': 'no-cache',
             Connection: 'keep-alive',
         });
+        res.write(': connected\n\n');
         if (await fs.pathExists(eventsPath)) {
-            const content = await fs.readFile(eventsPath, 'utf8');
-            const lines = content.split('\n').filter((l) => l.trim());
-            // Send recent history only — full 77MB dumps freeze the UI
-            for (const line of lines.slice(-200)) {
+            for (const line of await readRecentLines(eventsPath, 200)) {
                 res.write(`data: ${line}\n\n`);
             }
         }
         await fs.ensureDir(path.dirname(eventsPath));
-        const watcher = fs.watch(path.dirname(eventsPath), async (_eventType, filename) => {
-            if (filename === 'events.jsonl') {
-                try {
-                    const content = await fs.readFile(eventsPath, 'utf8');
-                    const lines = content.split('\n').filter((l) => l.trim());
-                    const lastLine = lines[lines.length - 1];
-                    if (lastLine)
-                        res.write(`data: ${lastLine}\n\n`);
-                }
-                catch {
-                    // ignore transient reads
-                }
+        let lastModified = (await fs.pathExists(eventsPath)) ? (await fs.stat(eventsPath)).mtimeMs : 0;
+        let ticks = 0;
+        const poller = setInterval(async () => {
+            try {
+                ticks++;
+                if (ticks % 15 === 0)
+                    res.write(': heartbeat\n\n');
+                if (!(await fs.pathExists(eventsPath)))
+                    return;
+                const stat = await fs.stat(eventsPath);
+                if (stat.mtimeMs <= lastModified)
+                    return;
+                lastModified = stat.mtimeMs;
+                const lastLine = (await readRecentLines(eventsPath, 1)).at(-1);
+                if (lastLine)
+                    res.write(`data: ${lastLine}\n\n`);
             }
-        });
-        req.on('close', () => watcher.close());
+            catch {
+                // A transient read failure must not terminate the event stream.
+            }
+        }, 1_000);
+        req.on('close', () => clearInterval(poller));
         return true;
     }
     if (url.pathname === '/api/file') {
@@ -158,13 +205,21 @@ async function handleApiRequest(req, res, url, ctx) {
             return true;
         }
         const absolutePath = path.resolve(cwd, filePath);
-        if (!absolutePath.startsWith(cwd)) {
+        const relativePath = path.relative(path.resolve(cwd), absolutePath);
+        if (!relativePath || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) {
             res.writeHead(403);
             res.end('Forbidden');
             return true;
         }
         try {
-            const content = await fs.readFile(absolutePath, 'utf8');
+            const [realRoot, realFile] = await Promise.all([fs.realpath(cwd), fs.realpath(absolutePath)]);
+            const realRelative = path.relative(realRoot, realFile);
+            if (!realRelative || realRelative.startsWith(`..${path.sep}`) || path.isAbsolute(realRelative)) {
+                res.writeHead(403);
+                res.end('Forbidden');
+                return true;
+            }
+            const content = await fs.readFile(realFile, 'utf8');
             res.writeHead(200, { 'Content-Type': 'text/plain' });
             res.end(content);
         }
@@ -267,6 +322,109 @@ async function handleApiRequest(req, res, url, ctx) {
         }
         return true;
     }
+    if (url.pathname === '/api/health') {
+        try {
+            const { getSystemHealth } = await import('@rigour-labs/core');
+            sendJson(res, 200, await getSystemHealth(cwd));
+        }
+        catch (e) {
+            sendJson(res, 503, { schemaVersion: 1, generatedAt: new Date().toISOString(), error: e.message });
+        }
+        return true;
+    }
+    if (url.pathname === '/api/lessons' && req.method === 'GET') {
+        try {
+            const { listLessons, loadTeamConfiguration } = await import('@rigour-labs/core');
+            const [lessons, teamConfiguration] = await Promise.all([
+                listLessons(cwd),
+                loadTeamConfiguration(),
+            ]);
+            sendJson(res, 200, { schemaVersion: 1, lessons, teamConfigured: Boolean(teamConfiguration) });
+        }
+        catch (e) {
+            sendJson(res, 500, { schemaVersion: 1, lessons: [], teamConfigured: false, error: e.message });
+        }
+        return true;
+    }
+    if (url.pathname === '/api/lessons' && req.method === 'POST') {
+        let body = '';
+        req.on('data', (chunk) => (body += chunk));
+        req.on('end', async () => {
+            try {
+                const payload = JSON.parse(body || '{}');
+                const allowedStates = new Set(['validated', 'promoted', 'rejected', 'superseded']);
+                if (typeof payload.id !== 'string' || !allowedStates.has(payload.state)) {
+                    sendJson(res, 400, { error: 'A lesson id and valid target state are required.' });
+                    return;
+                }
+                const { transitionLesson } = await import('@rigour-labs/core');
+                const publishing = payload.state === 'promoted';
+                const changed = await transitionLesson(payload.id, payload.state, {
+                    visibility: publishing ? 'team' : undefined,
+                    queueSync: publishing,
+                });
+                sendJson(res, changed ? 200 : 404, { success: changed });
+            }
+            catch (e) {
+                sendJson(res, 400, { error: e.message });
+            }
+        });
+        return true;
+    }
+    if (url.pathname === '/api/agent-history') {
+        try {
+            const requested = Number(url.searchParams.get('limit') ?? 250);
+            const limit = Math.max(1, Math.min(500, Number.isFinite(requested) ? requested : 250));
+            const beforeValue = Number(url.searchParams.get('before'));
+            const before = Number.isFinite(beforeValue) && beforeValue > 0 ? beforeValue : undefined;
+            const page = await readEventPage(eventsPath, limit, before);
+            const { buildAgentRuns, normalizeAgentEvents } = await import('@rigour-labs/core');
+            const events = normalizeAgentEvents(page.events);
+            sendJson(res, 200, {
+                schemaVersion: 1,
+                events,
+                runs: buildAgentRuns(events),
+                hasMore: page.hasMore,
+                nextBefore: events.length ? Date.parse(events.at(-1).timestamp) : null,
+            });
+        }
+        catch (e) {
+            sendJson(res, 500, { schemaVersion: 1, events: [], runs: [], hasMore: false, error: e.message });
+        }
+        return true;
+    }
+    if (url.pathname === '/api/knowledge-graph') {
+        try {
+            const { buildAgentRuns, buildEngineeringKnowledgeGraph, getRepositoryId, listKnowledgeLessons, normalizeAgentEvents } = await import('@rigour-labs/core');
+            const [page, dependencyGraph, lessons, repositoryId, patternIndex, memory] = await Promise.all([
+                readEventPage(eventsPath, 2_000),
+                readJsonIfExists(path.join(cwd, '.rigour/dependency-graph.json')),
+                listKnowledgeLessons(cwd).catch(() => []),
+                getRepositoryId(cwd),
+                readJsonIfExists(path.join(cwd, '.rigour/patterns.json')),
+                mergeMemoryStores(cwd),
+            ]);
+            const events = normalizeAgentEvents(page.events);
+            sendJson(res, 200, buildEngineeringKnowledgeGraph({
+                repository: { id: repositoryId, name: path.basename(cwd) },
+                dependencyGraph,
+                events,
+                runs: buildAgentRuns(events),
+                lessons,
+                patterns: Array.isArray(patternIndex?.patterns) ? patternIndex.patterns : [],
+                memories: Object.entries(memory.memories).map(([id, value]) => ({
+                    id,
+                    label: id,
+                    source: value?.source,
+                    detail: value?.type || value?.category || 'retained memory',
+                })),
+            }));
+        }
+        catch (e) {
+            sendJson(res, 500, { schemaVersion: 1, nodes: [], edges: [], counts: {}, truncated: false, error: e.message });
+        }
+        return true;
+    }
     if (url.pathname === '/api/index-stats') {
         try {
             const indexPath = path.join(cwd, '.rigour/patterns.json');
@@ -405,7 +563,7 @@ async function handleApiRequest(req, res, url, ctx) {
     if (url.pathname === '/api/drift') {
         try {
             const { generateTemporalDriftReport } = await import('@rigour-labs/core');
-            const report = generateTemporalDriftReport(cwd);
+            const report = await generateTemporalDriftReport(cwd);
             sendJson(res, 200, report || { totalScans: 0 });
         }
         catch {
@@ -886,6 +1044,18 @@ export const studioCommand = new Command('studio')
         `http://127.0.0.1:${studioPort}`,
     ]);
     const ctx = { cwd, eventsPath, allowedOrigins };
+    const { ensureAutomaticIndex, loadTeamConfiguration, syncTeamOutbox } = await import('@rigour-labs/core');
+    void ensureAutomaticIndex(cwd).catch((error) => {
+        console.warn(chalk.yellow(`Structural index is degraded: ${error instanceof Error ? error.message : String(error)}`));
+    });
+    const syncTimer = setInterval(() => {
+        void loadTeamConfiguration().then((config) => {
+            if (config)
+                return syncTeamOutbox().catch(() => undefined);
+            return undefined;
+        });
+    }, 30_000);
+    syncTimer.unref();
     console.log(chalk.bold.cyan('\n🛡️ Launching Rigour Studio...'));
     console.log(chalk.gray(`Project Root: ${cwd}`));
     const configPath = path.join(cwd, 'rigour.yml');

package/dist/commands/team.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const teamCommand: Command;

package/dist/commands/team.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { backfillTeamEmbeddings, doctorTeamConnection, initializeTeamSchema, saveTeamConfiguration, searchTeamKnowledge, syncTeamOutbox, } from '@rigour-labs/core';
+export const teamCommand = new Command('team').description('Configure and diagnose PostgreSQL team learning');
+teamCommand
+    .command('init-schema')
+    .description('Initialize the PostgreSQL team schema with an administrator connection')
+    .requiredOption('--database-url <url>', 'Administrator PostgreSQL URL; remote databases must require TLS')
+    .option('--pgvector', 'Enable the optional pgvector semantic knowledge index')
+    .action(async (options) => {
+    await initializeTeamSchema(options.databaseUrl, { pgvector: Boolean(options.pgvector) });
+    console.log(chalk.green(`Rigour team schema initialized${options.pgvector ? ' with pgvector' : ''}.`));
+});
+teamCommand
+    .command('configure')
+    .description('Configure a provisioned PostgreSQL team database')
+    .requiredOption('--database-url <url>', 'PostgreSQL URL; remote databases must require TLS')
+    .requiredOption('--organization <id>', 'Organization identifier')
+    .requiredOption('--team <id>', 'Team identifier')
+    .requiredOption('--actor <id>', 'Actor identifier provisioned for the database role')
+    .option('--initialize-schema', 'Create or update the Rigour schema (administrator only)')
+    .option('--pgvector', 'Use pgvector to rank team knowledge semantically')
+    .action(async (options) => {
+    if (options.initializeSchema)
+        await initializeTeamSchema(options.databaseUrl, { pgvector: Boolean(options.pgvector) });
+    const config = {
+        databaseUrl: options.databaseUrl,
+        organizationId: options.organization,
+        teamId: options.team,
+        actorId: options.actor,
+        semantic: options.pgvector ? {
+            provider: 'pgvector',
+            model: 'Xenova/all-MiniLM-L6-v2',
+            dimensions: 384,
+        } : undefined,
+    };
+    const result = await doctorTeamConnection(config);
+    await saveTeamConfiguration(config);
+    console.log(chalk.green(result.message));
+});
+teamCommand
+    .command('doctor')
+    .description('Verify team database TLS, schema, role, and membership')
+    .action(async () => {
+    const result = await doctorTeamConnection();
+    console.log(JSON.stringify(result, null, 2));
+    if (result.connectivity === 'offline')
+        process.exitCode = 1;
+});
+teamCommand
+    .command('semantic-backfill')
+    .description('Embed existing validated knowledge owned by the configured actor')
+    .option('--limit <count>', 'Maximum lessons to embed in this run', '200')
+    .action(async (options) => {
+    const limit = Number.parseInt(options.limit, 10);
+    if (!Number.isInteger(limit) || limit < 1)
+        throw new Error('--limit must be a positive integer.');
+    console.log(JSON.stringify(await backfillTeamEmbeddings(limit), null, 2));
+});
+teamCommand
+    .command('semantic-search')
+    .description('Diagnose advisory cross-repository knowledge recall')
+    .argument('<query>', 'Natural-language engineering question')
+    .option('--limit <count>', 'Maximum candidates to return', '8')
+    .action(async (query, options) => {
+    const limit = Number.parseInt(options.limit, 10);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 25)
+        throw new Error('--limit must be between 1 and 25.');
+    console.log(JSON.stringify(await searchTeamKnowledge(query, limit), null, 2));
+});
+teamCommand
+    .command('sync')
+    .description('Synchronize approved team lessons from the offline outbox')
+    .option('--dry-run', 'Report pending records without sending them')
+    .action(async (options) => {
+    const result = await syncTeamOutbox({ dryRun: Boolean(options.dryRun) });
+    console.log(JSON.stringify(result, null, 2));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "6.0.0",
+  "version": "6.1.0-beta.1",
   "description": "AI-native quality gates with local LLM analysis. Forces AI agents (Claude, Cursor, Copilot, Cline, Windsurf) to meet engineering standards. Bayesian Brain learns your codebase. Zero config: npx rigour-scan.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -53,12 +53,13 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "6.0.0"
+    "@rigour-labs/core": "6.1.0-beta.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
-    "@types/node": "^25.0.3"
+    "@types/node": "^25.0.3",
+    "@rigour-labs/studio": "6.1.0-beta.1"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",