@rigour-labs/core 2.17.2 → 2.18.1

package/dist/context.test.js

@@ -28,6 +28,11 @@ describe('Context Awareness Engine', () => {
                     enabled: true,
                     sensitivity: 0.8,
                     mining_depth: 10,
+                    ignored_patterns: [],
+                    cross_file_patterns: true,
+                    naming_consistency: true,
+                    import_relationships: true,
+                    max_cross_file_depth: 50,
                 },
             },
             output: { report_path: 'rigour-report.json' }
@@ -47,7 +52,16 @@ describe('Context Awareness Engine', () => {
             version: 1,
             commands: {},
             gates: {
-                context: { enabled: true },
+                context: {
+                    enabled: true,
+                    sensitivity: 0.8,
+                    mining_depth: 100,
+                    ignored_patterns: [],
+                    cross_file_patterns: true,
+                    naming_consistency: true,
+                    import_relationships: true,
+                    max_cross_file_depth: 50,
+                },
             },
             output: { report_path: 'rigour-report.json' }
         };

package/dist/discovery.js

@@ -26,12 +26,25 @@ export class DiscoveryService {
         return { config, matches };
     }
     mergeConfig(base, extension) {
+        // Deep merge for gates to preserve defaults when overrides are partial
+        const mergedGates = { ...base.gates };
+        if (extension.gates) {
+            for (const [key, value] of Object.entries(extension.gates)) {
+                if (typeof value === 'object' && value !== null && !Array.isArray(value) && mergedGates[key]) {
+                    mergedGates[key] = { ...mergedGates[key], ...value };
+                }
+                else {
+                    mergedGates[key] = value;
+                }
+            }
+        }
         return {
             ...base,
             preset: extension.preset || base.preset,
             paradigm: extension.paradigm || base.paradigm,
             commands: { ...base.commands, ...extension.commands },
-            gates: { ...base.gates, ...extension.gates },
+            gates: mergedGates,
+            ignore: [...new Set([...(base.ignore || []), ...(extension.ignore || [])])],
         };
     }
     async findFirstMarker(cwd, markers, searchContent = false) {

package/dist/discovery.test.js

@@ -54,4 +54,27 @@ describe('DiscoveryService', () => {
         const result = await service.discover('/test');
         expect(result.matches.paradigm?.name).toBe('oop');
     });
+    it('should include project-type-aware ignore patterns for API preset', async () => {
+        const service = new DiscoveryService();
+        // Mock finding requirements.txt (Python API marker)
+        vi.mocked(fs.pathExists).mockImplementation(async (p) => p.includes('requirements.txt'));
+        vi.mocked(fs.readdir).mockResolvedValue(['requirements.txt']);
+        vi.mocked(fs.readFile).mockResolvedValue('flask==2.0.0');
+        const result = await service.discover('/test');
+        expect(result.matches.preset?.name).toBe('api');
+        expect(result.config.ignore).toContain('venv/**');
+        expect(result.config.ignore).toContain('__pycache__/**');
+        expect(result.config.ignore).toContain('*.pyc');
+    });
+    it('should include project-type-aware ignore patterns for UI preset', async () => {
+        const service = new DiscoveryService();
+        // Mock finding next.config.js (UI marker)
+        vi.mocked(fs.pathExists).mockImplementation(async (p) => p.includes('next.config.js'));
+        vi.mocked(fs.readdir).mockResolvedValue(['next.config.js']);
+        vi.mocked(fs.readFile).mockResolvedValue('module.exports = {}');
+        const result = await service.discover('/test');
+        expect(result.matches.preset?.name).toBe('ui');
+        expect(result.config.ignore).toContain('node_modules/**');
+        expect(result.config.ignore).toContain('.next/**');
+    });
 });

package/dist/gates/agent-team.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Agent Team Governance Gate
+ *
+ * Supervises multi-agent coordination for frontier models like
+ * Opus 4.6 (agent teams) and GPT-5.3-Codex (coworking mode).
+ *
+ * Detects:
+ * - Cross-agent pattern conflicts
+ * - Task scope violations
+ * - Handoff context loss
+ *
+ * @since v2.14.0
+ */
+import { Gate, GateContext } from './base.js';
+import { Failure } from '../types/index.js';
+export interface AgentRegistration {
+    agentId: string;
+    taskScope: string[];
+    registeredAt: Date;
+    lastActivity?: Date;
+}
+export interface AgentTeamSession {
+    sessionId: string;
+    agents: AgentRegistration[];
+    startedAt: Date;
+}
+export interface AgentTeamConfig {
+    enabled?: boolean;
+    max_concurrent_agents?: number;
+    cross_agent_pattern_check?: boolean;
+    handoff_verification?: boolean;
+    task_ownership?: 'strict' | 'collaborative';
+}
+/**
+ * Register an agent in the current session
+ */
+export declare function registerAgent(cwd: string, agentId: string, taskScope: string[]): AgentTeamSession;
+/**
+ * Get current session status
+ */
+export declare function getSession(cwd: string): AgentTeamSession | null;
+/**
+ * Clear current session
+ */
+export declare function clearSession(cwd: string): void;
+export declare class AgentTeamGate extends Gate {
+    private config;
+    constructor(config?: AgentTeamConfig);
+    run(context: GateContext): Promise<Failure[]>;
+}

package/dist/gates/agent-team.js

@@ -0,0 +1,159 @@
+/**
+ * Agent Team Governance Gate
+ *
+ * Supervises multi-agent coordination for frontier models like
+ * Opus 4.6 (agent teams) and GPT-5.3-Codex (coworking mode).
+ *
+ * Detects:
+ * - Cross-agent pattern conflicts
+ * - Task scope violations
+ * - Handoff context loss
+ *
+ * @since v2.14.0
+ */
+import { Gate } from './base.js';
+import { Logger } from '../utils/logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+// In-memory session store (persisted to .rigour/agent-session.json)
+let currentSession = null;
+/**
+ * Register an agent in the current session
+ */
+export function registerAgent(cwd, agentId, taskScope) {
+    if (!currentSession) {
+        currentSession = {
+            sessionId: `session-${Date.now()}`,
+            agents: [],
+            startedAt: new Date(),
+        };
+    }
+    // Check if agent already registered
+    const existing = currentSession.agents.find(a => a.agentId === agentId);
+    if (existing) {
+        existing.taskScope = taskScope;
+        existing.lastActivity = new Date();
+    }
+    else {
+        currentSession.agents.push({
+            agentId,
+            taskScope,
+            registeredAt: new Date(),
+        });
+    }
+    // Persist session
+    persistSession(cwd);
+    return currentSession;
+}
+/**
+ * Get current session status
+ */
+export function getSession(cwd) {
+    if (!currentSession) {
+        loadSession(cwd);
+    }
+    return currentSession;
+}
+/**
+ * Clear current session
+ */
+export function clearSession(cwd) {
+    currentSession = null;
+    const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
+    if (fs.existsSync(sessionPath)) {
+        fs.unlinkSync(sessionPath);
+    }
+}
+function persistSession(cwd) {
+    const rigourDir = path.join(cwd, '.rigour');
+    if (!fs.existsSync(rigourDir)) {
+        fs.mkdirSync(rigourDir, { recursive: true });
+    }
+    const sessionPath = path.join(rigourDir, 'agent-session.json');
+    fs.writeFileSync(sessionPath, JSON.stringify(currentSession, null, 2));
+}
+function loadSession(cwd) {
+    const sessionPath = path.join(cwd, '.rigour', 'agent-session.json');
+    if (fs.existsSync(sessionPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+            currentSession = {
+                ...data,
+                startedAt: new Date(data.startedAt),
+                agents: data.agents.map((a) => ({
+                    ...a,
+                    registeredAt: new Date(a.registeredAt),
+                    lastActivity: a.lastActivity ? new Date(a.lastActivity) : undefined,
+                })),
+            };
+        }
+        catch (err) {
+            Logger.warn('Failed to load agent session, starting fresh');
+            currentSession = null;
+        }
+    }
+}
+/**
+ * Check if two glob patterns might overlap
+ */
+function scopesOverlap(scope1, scope2) {
+    const overlapping = [];
+    for (const s1 of scope1) {
+        for (const s2 of scope2) {
+            // Simple overlap detection - same path or one is prefix of other
+            if (s1 === s2 || s1.startsWith(s2.replace('**', '')) || s2.startsWith(s1.replace('**', ''))) {
+                overlapping.push(`${s1} ↔ ${s2}`);
+            }
+        }
+    }
+    return overlapping;
+}
+export class AgentTeamGate extends Gate {
+    config;
+    constructor(config = {}) {
+        super('agent-team', 'Agent Team Governance');
+        this.config = {
+            enabled: config.enabled ?? false,
+            max_concurrent_agents: config.max_concurrent_agents ?? 3,
+            cross_agent_pattern_check: config.cross_agent_pattern_check ?? true,
+            handoff_verification: config.handoff_verification ?? true,
+            task_ownership: config.task_ownership ?? 'strict',
+        };
+    }
+    async run(context) {
+        if (!this.config.enabled) {
+            return [];
+        }
+        const failures = [];
+        const session = getSession(context.cwd);
+        if (!session || session.agents.length === 0) {
+            // No multi-agent session active, skip
+            return [];
+        }
+        Logger.info(`Agent Team Gate: ${session.agents.length} agents in session`);
+        // Check 1: Max concurrent agents
+        if (session.agents.length > (this.config.max_concurrent_agents ?? 3)) {
+            failures.push(this.createFailure(`Too many concurrent agents: ${session.agents.length} (max: ${this.config.max_concurrent_agents})`, undefined, 'Reduce the number of concurrent agents or increase max_concurrent_agents in rigour.yml', 'Too Many Concurrent Agents'));
+        }
+        // Check 2: Task scope conflicts (strict mode only)
+        if (this.config.task_ownership === 'strict') {
+            for (let i = 0; i < session.agents.length; i++) {
+                for (let j = i + 1; j < session.agents.length; j++) {
+                    const agent1 = session.agents[i];
+                    const agent2 = session.agents[j];
+                    const overlaps = scopesOverlap(agent1.taskScope, agent2.taskScope);
+                    if (overlaps.length > 0) {
+                        failures.push(this.createFailure(`Task scope conflict between ${agent1.agentId} and ${agent2.agentId}: ${overlaps.join(', ')}`, undefined, 'In strict mode, each agent must have exclusive task scope. Either adjust scopes or set task_ownership: collaborative', 'Task Scope Conflict'));
+                    }
+                }
+            }
+        }
+        // Check 3: Cross-agent pattern detection (if enabled)
+        if (this.config.cross_agent_pattern_check && context.record) {
+            // This would integrate with the Pattern Index to detect conflicting patterns
+            // For now, we log that we would do this check
+            Logger.debug('Cross-agent pattern check: would analyze patterns across agent scopes');
+        }
+        return failures;
+    }
+}

package/dist/gates/agent-team.test.d.ts

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

package/dist/gates/agent-team.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { AgentTeamGate, registerAgent, getSession, clearSession } from './agent-team.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+describe('AgentTeamGate', () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-team-test-'));
+    });
+    afterEach(() => {
+        clearSession(testDir);
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    describe('gate initialization', () => {
+        it('should create gate with default config', () => {
+            const gate = new AgentTeamGate();
+            expect(gate.id).toBe('agent-team');
+            expect(gate.title).toBe('Agent Team Governance');
+        });
+        it('should skip when not enabled', async () => {
+            const gate = new AgentTeamGate({ enabled: false });
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toEqual([]);
+        });
+    });
+    describe('session management', () => {
+        it('should register an agent', () => {
+            const session = registerAgent(testDir, 'agent-a', ['src/api/**']);
+            expect(session.agents).toHaveLength(1);
+            expect(session.agents[0].agentId).toBe('agent-a');
+            expect(session.agents[0].taskScope).toEqual(['src/api/**']);
+        });
+        it('should update existing agent registration', () => {
+            registerAgent(testDir, 'agent-a', ['src/api/**']);
+            const session = registerAgent(testDir, 'agent-a', ['src/api/**', 'src/utils/**']);
+            expect(session.agents).toHaveLength(1);
+            expect(session.agents[0].taskScope).toEqual(['src/api/**', 'src/utils/**']);
+        });
+        it('should persist session to disk', () => {
+            registerAgent(testDir, 'agent-a', ['src/**']);
+            const sessionPath = path.join(testDir, '.rigour', 'agent-session.json');
+            expect(fs.existsSync(sessionPath)).toBe(true);
+        });
+        it('should load session from disk', () => {
+            registerAgent(testDir, 'agent-a', ['src/**']);
+            // Clear in-memory cache
+            clearSession(testDir);
+            // Re-register to re-create session file
+            registerAgent(testDir, 'agent-b', ['tests/**']);
+            const session = getSession(testDir);
+            expect(session).not.toBeNull();
+            expect(session.agents).toHaveLength(1); // Only agent-b after clearSession
+        });
+        it('should clear session', () => {
+            registerAgent(testDir, 'agent-a', ['src/**']);
+            clearSession(testDir);
+            const session = getSession(testDir);
+            expect(session).toBeNull();
+        });
+    });
+    describe('max concurrent agents check', () => {
+        it('should pass when under limit', async () => {
+            const gate = new AgentTeamGate({ enabled: true, max_concurrent_agents: 3 });
+            registerAgent(testDir, 'agent-a', ['src/a/**']);
+            registerAgent(testDir, 'agent-b', ['src/b/**']);
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toEqual([]);
+        });
+        it('should fail when over limit', async () => {
+            const gate = new AgentTeamGate({ enabled: true, max_concurrent_agents: 2 });
+            registerAgent(testDir, 'agent-a', ['src/a/**']);
+            registerAgent(testDir, 'agent-b', ['src/b/**']);
+            registerAgent(testDir, 'agent-c', ['src/c/**']);
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toHaveLength(1);
+            expect(failures[0].title).toBe('Too Many Concurrent Agents');
+        });
+    });
+    describe('task scope conflicts (strict mode)', () => {
+        it('should pass when scopes are disjoint', async () => {
+            const gate = new AgentTeamGate({
+                enabled: true,
+                task_ownership: 'strict'
+            });
+            registerAgent(testDir, 'agent-a', ['src/api/**']);
+            registerAgent(testDir, 'agent-b', ['src/ui/**']);
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toEqual([]);
+        });
+        it('should fail when scopes overlap', async () => {
+            const gate = new AgentTeamGate({
+                enabled: true,
+                task_ownership: 'strict'
+            });
+            registerAgent(testDir, 'agent-a', ['src/api/**']);
+            registerAgent(testDir, 'agent-b', ['src/api/**']); // Same scope!
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toHaveLength(1);
+            expect(failures[0].title).toBe('Task Scope Conflict');
+        });
+        it('should allow overlapping scopes in collaborative mode', async () => {
+            const gate = new AgentTeamGate({
+                enabled: true,
+                task_ownership: 'collaborative'
+            });
+            registerAgent(testDir, 'agent-a', ['src/api/**']);
+            registerAgent(testDir, 'agent-b', ['src/api/**']); // Same scope - OK in collaborative
+            const failures = await gate.run({ cwd: testDir });
+            expect(failures).toEqual([]);
+        });
+    });
+});

package/dist/gates/checkpoint.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Checkpoint Supervision Gate
+ *
+ * Monitors agent quality during extended execution for frontier models
+ * like GPT-5.3-Codex "coworking mode" that run autonomously for long periods.
+ *
+ * Features:
+ * - Time-based checkpoint triggers
+ * - Quality score tracking
+ * - Drift detection (quality degradation over time)
+ * - Auto-save on failure
+ *
+ * @since v2.14.0
+ */
+import { Gate, GateContext } from './base.js';
+import { Failure } from '../types/index.js';
+export interface CheckpointEntry {
+    checkpointId: string;
+    timestamp: Date;
+    progressPct: number;
+    filesChanged: string[];
+    summary: string;
+    qualityScore: number;
+    warnings: string[];
+}
+export interface CheckpointSession {
+    sessionId: string;
+    startedAt: Date;
+    lastCheckpoint?: Date;
+    checkpoints: CheckpointEntry[];
+    status: 'active' | 'completed' | 'aborted';
+}
+export interface CheckpointConfig {
+    enabled?: boolean;
+    interval_minutes?: number;
+    quality_threshold?: number;
+    drift_detection?: boolean;
+    auto_save_on_failure?: boolean;
+}
+/**
+ * Get or create checkpoint session
+ */
+export declare function getOrCreateCheckpointSession(cwd: string): CheckpointSession;
+/**
+ * Record a checkpoint with quality evaluation
+ */
+export declare function recordCheckpoint(cwd: string, progressPct: number, filesChanged: string[], summary: string, qualityScore: number): {
+    continue: boolean;
+    warnings: string[];
+    checkpoint: CheckpointEntry;
+};
+/**
+ * Get current checkpoint session
+ */
+export declare function getCheckpointSession(cwd: string): CheckpointSession | null;
+/**
+ * Complete checkpoint session
+ */
+export declare function completeCheckpointSession(cwd: string): void;
+/**
+ * Abort checkpoint session (quality too low)
+ */
+export declare function abortCheckpointSession(cwd: string, reason: string): void;
+/**
+ * Clear checkpoint session
+ */
+export declare function clearCheckpointSession(cwd: string): void;
+export declare class CheckpointGate extends Gate {
+    private config;
+    constructor(config?: CheckpointConfig);
+    run(context: GateContext): Promise<Failure[]>;
+}