@rigour-labs/core 6.8.0 → 6.8.1

package/dist/discovery.test.js

@@ -1,93 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DiscoveryService } from './discovery.js';
-import { containsToken, detectParadigm, stripComments } from './discovery-signals.js';
-describe('DiscoveryService', () => {
-    let cwd;
-    beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'discovery-')); });
-    afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-    function write(rel, body) {
-        fs.mkdirSync(path.dirname(path.join(cwd, rel)), { recursive: true });
-        fs.writeFileSync(path.join(cwd, rel), body);
-    }
-    const discover = () => new DiscoveryService().discover(cwd);
-    it('detects an API from a declared dependency', async () => {
-        write('package.json', JSON.stringify({ dependencies: { express: '^4.0.0' } }));
-        const result = await discover();
-        expect(result.matches.preset).toEqual({ name: 'api', marker: 'dependency:express' });
-    });
-    it('detects a scoped framework package such as @nestjs/core', async () => {
-        write('package.json', JSON.stringify({ dependencies: { '@nestjs/core': '^10.0.0' } }));
-        expect((await discover()).matches.preset?.marker).toBe('dependency:nestjs');
-    });
-    it('detects a Python API with its ignore patterns', async () => {
-        write('requirements.txt', 'flask==2.0.0\n');
-        const result = await discover();
-        expect(result.matches.preset?.name).toBe('api');
-        expect(result.config.ignore).toEqual(expect.arrayContaining(['venv/**', '__pycache__/**', '*.pyc']));
-    });
-    it('detects a UI project from a config file with its ignore patterns', async () => {
-        write('next.config.js', 'module.exports = {};\n');
-        const result = await discover();
-        expect(result.matches.preset?.name).toBe('ui');
-        expect(result.config.ignore).toEqual(expect.arrayContaining(['node_modules/**', '.next/**']));
-    });
-    it('detects Svelte from its dependencies, not "reactivity" or "public" in comments', async () => {
-        write('package.json', JSON.stringify({ devDependencies: { '@sveltejs/kit': '^2.0.0', svelte: '^5.0.0' } }));
-        write('eslint.config.js', '// Svelte 5 rules (state_referenced_locally, a11y, reactivity)\nexport default [];\n');
-        write('playwright.config.ts', '// rides the public internet\nexport default {};\n');
-        write('src/lib/format.ts', 'export function format(v: number) { return v.toFixed(2); }\nexport const pad = (s: string) => s.padStart(2);\n');
-        const result = await discover();
-        expect(result.matches.preset).toEqual({ name: 'ui', marker: 'dependency:svelte' });
-        expect(result.matches.paradigm?.name).toBe('functional');
-    });
-    it('does not read a framework name in source text as a dependency', async () => {
-        write('src/middleware.ts', 'export function run(next: () => void) { next(); }\n');
-        expect((await discover()).matches.preset).toBeUndefined();
-    });
-    it('identifies OOP from class declarations in a subfolder', async () => {
-        write('src/Service.ts', 'export class MyService {}\nexport class OtherService {}\n');
-        const result = await discover();
-        expect(result.matches.paradigm).toEqual({ name: 'oop', marker: 'declarations: 2 classes, 0 functions' });
-    });
-    it('needs several recurring domain keywords before choosing a domain preset', async () => {
-        write('src/billing.ts', 'export const ledger = new Map<string, number>();\n');
-        write('src/report.ts', "import { ledger } from './billing';\nexport const total = () => ledger.size;\n");
-        expect((await discover()).matches.preset).toBeUndefined();
-        write('src/pay.ts', 'export function payment(ledger: Map<string, number>) { return ledger; }\n');
-        write('src/refund.ts', 'export function refund(payment: number) { return -payment; }\n');
-        expect((await discover()).matches.preset).toEqual({ name: 'fintech', marker: 'content:payment,ledger' });
-    });
-    it('needs a file marker to exist, not to be mentioned', async () => {
-        write('src/serve.ts', "export const page = () => 'index.html';\n");
-        expect((await discover()).matches.preset).toBeUndefined();
-    });
-    it('detects notebooks by file, not by the word ipynb in code', async () => {
-        write('src/scan.ts', "export const exts = ['.ipynb', '.py'];\n");
-        expect((await discover()).matches.preset).toBeUndefined();
-        write('notebooks/explore.ipynb', '{}');
-        expect((await discover()).matches.preset).toEqual({ name: 'data', marker: 'file:*.ipynb' });
-    });
-    it('leaves the paradigm unset for an empty project', async () => {
-        expect((await discover()).matches.paradigm).toBeUndefined();
-    });
-});
-describe('discovery signals', () => {
-    it('matches whole tokens only', () => {
-        expect(containsToken('import x from "react"', 'react')).toBe(true);
-        expect(containsToken('reactivity', 'react')).toBe(false);
-        expect(containsToken('@vue/compiler', 'vue')).toBe(false);
-        expect(containsToken('GET /health', 'health')).toBe(false);
-    });
-    it('drops comments but keeps URLs in strings', () => {
-        const text = stripComments('/* public */\nconst u = "https://x.io"; // public\n# public\n');
-        expect(text).not.toContain('public');
-        expect(text).toContain('https://x.io');
-    });
-    it('declines to guess a paradigm when neither side clearly leads', () => {
-        expect(detectParadigm(['export class A {}\nexport function f() {}\n'])).toBeNull();
-        expect(detectParadigm(['export class A {}\nexport function f() {}\nexport function g() {}\n'])?.name).toBe('functional');
-    });
-});

package/dist/environment.test.d.ts

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

package/dist/environment.test.js

@@ -1,94 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { GateRunner } from './gates/runner.js';
-import { ConfigSchema } from './types/index.js';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-describe('Environment Alignment Gate', () => {
-    const testDir = path.join(os.tmpdir(), 'rigour-temp-test-env-' + process.pid);
-    beforeEach(async () => {
-        await fs.ensureDir(testDir);
-    });
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-    it('should detect tool version mismatch (Explicit)', async () => {
-        const rawConfig = {
-            gates: {
-                environment: {
-                    enabled: true,
-                    enforce_contracts: false,
-                    tools: {
-                        node: ">=99.0.0" // Guaranteed to fail
-                    }
-                }
-            }
-        };
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-        expect(report.status).toBe('FAIL');
-        const envFailure = report.failures.find(f => f.id === 'environment-alignment');
-        expect(envFailure).toBeDefined();
-        expect(envFailure?.details).toContain('node');
-        expect(envFailure?.details).toContain('version mismatch');
-    });
-    it('should detect missing environment variables', async () => {
-        const rawConfig = {
-            gates: {
-                environment: {
-                    enabled: true,
-                    required_env: ["RIGOUR_TEST_VAR_MISSING"]
-                }
-            }
-        };
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-        expect(report.status).toBe('FAIL');
-        expect(report.failures[0].details).toContain('RIGOUR_TEST_VAR_MISSING');
-    });
-    it('should discover contracts from pyproject.toml', async () => {
-        // Create mock pyproject.toml with a version that will surely fail
-        await fs.writeFile(path.join(testDir, 'pyproject.toml'), `
-[tool.ruff]
-ruff = ">=99.14.0"
-`);
-        const rawConfig = {
-            gates: {
-                environment: {
-                    enabled: true,
-                    enforce_contracts: true,
-                    tools: {} // Should discover ruff from file
-                }
-            }
-        };
-        const config = ConfigSchema.parse(rawConfig);
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-        // This might pass or fail depending on the local ruff version, 
-        // but we want to check if the gate attempted to check ruff.
-        // If ruff is missing, it will fail with "is missing".
-        const ruffFailure = report.failures.find(f => f.details.includes('ruff'));
-        expect(ruffFailure).toBeDefined();
-    });
-    it('should prioritize environment gate and run it first', async () => {
-        const rawConfig = {
-            gates: {
-                max_file_lines: 1,
-                environment: {
-                    enabled: true,
-                    required_env: ["MANDATORY_SECRET_MISSING"]
-                }
-            }
-        };
-        const config = ConfigSchema.parse(rawConfig);
-        // Create a file that would fail max_file_lines
-        await fs.writeFile(path.join(testDir, 'large.js'), 'line1\nline2\nline3');
-        const runner = new GateRunner(config);
-        const report = await runner.run(testDir);
-        // In a real priority system, we might want to stop after environment failure.
-        // Currently GateRunner runs all, but environment-alignment has been unshifted.
-        expect(Object.keys(report.summary)[0]).toBe('environment-alignment');
-    });
-});

package/dist/firewall/firewall.test.d.ts

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

package/dist/firewall/firewall.test.js

@@ -1,117 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { evaluateTypedCommand, parseCommandLine, evaluateWriteScope, evaluateActionDeterministic, runAdversarialCorpus, CapabilityBroker, validateAgentClaimedScope, } from './index.js';
-describe('typed command firewall', () => {
-    it('denies shell metacharacters', () => {
-        const ev = evaluateTypedCommand('ls; rm -rf /');
-        expect(ev.decision).toBe('deny');
-        expect(ev.ruleId).toBe('shell.no-meta');
-    });
-    it('treats a Windows shim as the program it starts, and still denies an unknown one', () => {
-        expect(evaluateTypedCommand('D:\\repo\\node_modules\\.bin\\vitest.cmd run a.test.ts').decision).toBe('allow');
-        expect(evaluateTypedCommand('D:\\tools\\curl.exe https://evil.example').decision).toBe('deny');
-    });
-    it('denies unknown binaries including node/npx', () => {
-        expect(evaluateTypedCommand('curl https://evil.example').decision).toBe('deny');
-        expect(evaluateTypedCommand('node -e "1"').decision).toBe('deny');
-        expect(evaluateTypedCommand('npx cowsay hi').decision).toBe('deny');
-    });
-    it('denies git push', () => {
-        const ev = evaluateTypedCommand('git push origin main');
-        expect(ev.decision).toBe('deny');
-        expect(ev.ruleId).toBe('git.destructive');
-    });
-    it('allows vitest', () => {
-        const ev = evaluateTypedCommand('vitest run packages/rigour-core');
-        expect(ev.decision).toBe('allow');
-        expect(parseCommandLine('vitest run x')?.bin).toBe('vitest');
-    });
-});
-describe('scope enforcement', () => {
-    it('denies unbound writer when scopes exist', () => {
-        const ev = evaluateWriteScope('/repo', 'packages/rigour-core/src/x.ts', [
-            { agentId: 'a1', taskScope: ['packages/rigour-core/**'] },
-        ]);
-        expect(ev.decision).toBe('scope-violation');
-        expect(ev.ruleId).toBe('scope.unbound');
-    });
-    it('flags out-of-scope writes for bound agent', () => {
-        const ev = evaluateWriteScope('/repo', '.github/workflows/x.yml', [
-            { agentId: 'a1', taskScope: ['packages/rigour-core/**'] },
-        ], 'a1');
-        expect(ev.decision).toBe('scope-violation');
-    });
-    it('allows in-scope writes for bound agent', () => {
-        const ev = evaluateWriteScope('/repo', 'packages/rigour-core/src/firewall/types.ts', [
-            { agentId: 'a1', taskScope: ['packages/rigour-core/**'] },
-        ], 'a1');
-        expect(ev.decision).toBe('allow');
-    });
-    it('rejects broad self-registration scopes', () => {
-        expect(validateAgentClaimedScope(['**/*']).ok).toBe(false);
-        expect(validateAgentClaimedScope(['.github/**']).ok).toBe(false);
-        expect(validateAgentClaimedScope(['packages/rigour-core/**']).ok).toBe(true);
-    });
-});
-describe('capability broker', () => {
-    it('requires explicit authority in enforce mode and reports shadow decisions in observe mode', () => {
-        const base = { defaultTtlMs: 1000, toolAllowlist: ['*'], agentScopes: [] };
-        const enforced = new CapabilityBroker({ ...base, authorizationMode: 'enforce' });
-        expect(enforced.evaluateProposal({ action: 'mcp.call', resource: 'github__get_issue' })).toMatchObject({
-            decision: 'deny', ruleId: 'capability.required',
-        });
-        const observed = new CapabilityBroker({ ...base, authorizationMode: 'observe' });
-        expect(observed.evaluateProposal({ action: 'mcp.call', resource: 'github__get_issue' })).toMatchObject({
-            decision: 'allow', simulatedDecision: 'deny', ruleId: 'capability.observe-required',
-        });
-    });
-    it('denies undeclared MCP tools', () => {
-        const broker = new CapabilityBroker({
-            defaultTtlMs: 1000,
-            toolAllowlist: ['rigour_check'],
-            agentScopes: [],
-        });
-        const ev = broker.evaluateProposal({
-            action: 'mcp.call',
-            resource: 'slack.post_message',
-        });
-        expect(ev.decision).toBe('deny');
-        expect(ev.ruleId).toBe('mcp.undeclared');
-    });
-    it('issues one-use capabilities', () => {
-        const broker = new CapabilityBroker({
-            defaultTtlMs: 60_000,
-            toolAllowlist: ['*'],
-            agentScopes: [],
-        });
-        const grant = broker.issue('mcp.call', 'rigour_check');
-        const ok = broker.evaluateProposal({
-            action: 'mcp.call',
-            resource: 'rigour_check',
-            capabilityId: grant.id,
-        });
-        expect(ok.decision).toBe('allow');
-        const again = broker.evaluateProposal({
-            action: 'mcp.call',
-            resource: 'rigour_check',
-            capabilityId: grant.id,
-        });
-        expect(again.decision).toBe('deny');
-        expect(again.ruleId).toBe('capability.reuse');
-    });
-});
-describe('adversarial corpus', () => {
-    it('passes default regression corpus', () => {
-        const report = runAdversarialCorpus();
-        expect(report.failed).toBe(0);
-        expect(report.passed).toBeGreaterThan(0);
-    });
-    it('evaluateActionDeterministic matches expected deny', () => {
-        const ev = evaluateActionDeterministic({
-            action: 'mcp.call',
-            resource: 'github.merge',
-            toolAllowlist: [],
-            agentScopes: [],
-        });
-        expect(ev.decision).toBe('deny');
-    });
-});

package/dist/firewall/trust-boundaries.test.d.ts

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

package/dist/firewall/trust-boundaries.test.js

@@ -1,64 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { issueArbitrationToken, signArbitrationDecision, verifyArbitrationDecision } from './arbitration-token.js';
-import { admitForCi, createAttestation } from './attestation.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'trust-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('human arbitration', () => {
-    it('accepts only a decision signed with the issued token, once', async () => {
-        const token = await issueArbitrationToken(repo, 'r1');
-        expect(fs.existsSync(path.join(repo, '.rigour', 'arbitration-tokens.json'))).toBe(false);
-        // A line any process can append to the event log carries no valid proof.
-        expect(verifyArbitrationDecision(token, 'r1', 'approve', undefined)).toBe(false);
-        expect(verifyArbitrationDecision(token, 'r1', 'approve', 'f'.repeat(64))).toBe(false);
-        const proof = await signArbitrationDecision(repo, 'r1', 'approve');
-        expect(verifyArbitrationDecision(token, 'r1', 'approve', proof)).toBe(true);
-        expect(verifyArbitrationDecision(token, 'r1', 'reject', proof)).toBe(false);
-        expect(await signArbitrationDecision(repo, 'r1', 'approve')).toBeNull();
-    });
-});
-describe('CI admission', () => {
-    const tx = (over = {}) => ({
-        id: 'tx1', agentId: 'agent', scope: ['**/*'], policyHash: 'policy-a', capabilitiesIssued: [], filesChanged: ['a.ts'], ...over,
-    });
-    const pass = { status: 'PASS', failedGates: [] };
-    it('admits a fresh, bound bundle whose files are unchanged', async () => {
-        await createAttestation(repo, { transaction: tx(), gateResults: pass });
-        expect(await admitForCi(repo)).toMatchObject({ admit: true });
-    });
-    it('refuses when an attested file differs from what was signed, even at the same commit', async () => {
-        await createAttestation(repo, { transaction: tx(), gateResults: pass });
-        fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 2;\n'); // HEAD and its tree are unchanged
-        expect(await admitForCi(repo)).toMatchObject({ admit: false, reason: expect.stringContaining('artifactDigest') });
-    });
-    it('refuses a bundle produced under another policy than the one required', async () => {
-        await createAttestation(repo, { transaction: tx(), gateResults: pass });
-        expect(await admitForCi(repo, { policyHash: 'policy-b' })).toMatchObject({ admit: false });
-        expect(await admitForCi(repo, { policyHash: 'policy-a' })).toMatchObject({ admit: true });
-    });
-    it('refuses a bundle bound to no commit or tree', async () => {
-        const noRepo = fs.mkdtempSync(path.join(os.tmpdir(), 'trust-norepo-'));
-        try {
-            fs.writeFileSync(path.join(noRepo, 'a.ts'), 'export const a = 1;\n');
-            await createAttestation(noRepo, { transaction: tx(), gateResults: pass });
-            expect(await admitForCi(noRepo)).toMatchObject({ admit: false, reason: 'Attestation is bound to no commit or tree' });
-        }
-        finally {
-            fs.rmSync(noRepo, { recursive: true, force: true });
-        }
-    });
-});

package/dist/firewall/trusted-control.test.d.ts

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

package/dist/firewall/trusted-control.test.js

@@ -1,188 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { appendExecutionReceipt, consumeTrustedGrant, getTrustedControlDir, issueTrustedGrant, listTrustedGrants, normalizeMcpAction, saveGatewayConfig, verifyExecutionReceiptChain, } from './index.js';
-const repositories = [];
-const controlRoots = [];
-async function repository() {
-    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-gateway-test-'));
-    repositories.push(cwd);
-    return cwd;
-}
-async function controlRoot() {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-control-test-'));
-    controlRoots.push(root);
-    return root;
-}
-afterEach(async () => {
-    for (const cwd of repositories.splice(0)) {
-        await fs.remove(cwd);
-    }
-    for (const root of controlRoots.splice(0))
-        await fs.remove(root);
-});
-describe('trusted gateway control', () => {
-    it('stores configuration outside the repository', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const location = await saveGatewayConfig(cwd, {
-            version: 1,
-            mode: 'observe',
-            principalId: 'owner',
-            agentId: 'agent-1',
-            taskId: 'task-1',
-            servers: { github: { command: 'github-mcp', allow: ['get_issue'] } },
-        }, root);
-        expect(location.startsWith(cwd)).toBe(false);
-        expect(await fs.pathExists(location)).toBe(true);
-    });
-    it('lists valid grants without failing on malformed control files', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const grant = await issueTrustedGrant(cwd, {
-            issuerId: 'owner', subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://files/read', ttlMs: 60_000,
-        }, root);
-        const grantsDir = path.join(getTrustedControlDir(cwd, root), 'capabilities');
-        await fs.writeFile(path.join(grantsDir, 'not-a-grant.json'), '{broken');
-        await expect(listTrustedGrants(cwd, 10, root)).resolves.toEqual([
-            expect.objectContaining({ id: grant.id, resource: 'mcp://files/read' }),
-        ]);
-    });
-    it('consumes a capability exactly once', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const grant = await issueTrustedGrant(cwd, {
-            issuerId: 'owner', subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/create_issue', ttlMs: 60_000,
-        }, root);
-        const proposal = {
-            id: grant.id, subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/create_issue',
-        };
-        expect((await consumeTrustedGrant(cwd, proposal, root)).ok).toBe(true);
-        expect((await consumeTrustedGrant(cwd, proposal, root)).ok).toBe(false);
-    });
-    it('rejects path traversal in a capability id', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const result = await consumeTrustedGrant(cwd, {
-            id: '../../gateway', subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/create_issue',
-        }, root);
-        expect(result).toMatchObject({ ok: false, reason: 'Invalid capability id' });
-    });
-    it('rejects delegated authority that expands its parent', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const parent = await issueTrustedGrant(cwd, {
-            issuerId: 'owner', subjectId: 'lead-agent', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue', ttlMs: 60_000,
-        }, root);
-        await expect(issueTrustedGrant(cwd, {
-            issuerId: 'lead-agent', subjectId: 'worker-agent', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/delete_repo', ttlMs: 30_000,
-            parentCapabilityId: parent.id,
-        }, root)).rejects.toThrow('preserve parent action and resource');
-    });
-    it('consumes the parent when delegated authority is issued', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const parent = await issueTrustedGrant(cwd, {
-            issuerId: 'owner', subjectId: 'lead-agent', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue', ttlMs: 60_000,
-        }, root);
-        const child = await issueTrustedGrant(cwd, {
-            issuerId: 'lead-agent', subjectId: 'worker-agent', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue', ttlMs: 30_000,
-            parentCapabilityId: parent.id,
-        }, root);
-        expect(child.parentCapabilityId).toBe(parent.id);
-        const parentResult = await consumeTrustedGrant(cwd, {
-            id: parent.id, subjectId: 'lead-agent', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue',
-        }, root);
-        expect(parentResult).toMatchObject({ ok: false, reason: 'Capability already consumed' });
-    });
-    it('invalidates grants when the trusted policy changes', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const base = {
-            version: 1, principalId: 'owner', agentId: 'agent-1', taskId: 'task-1',
-            servers: { github: { command: 'github-mcp', allow: ['get_issue'] } },
-        };
-        await saveGatewayConfig(cwd, { ...base, mode: 'observe' }, root);
-        const grant = await issueTrustedGrant(cwd, {
-            issuerId: 'owner', subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue', ttlMs: 60_000,
-        }, root);
-        await saveGatewayConfig(cwd, { ...base, mode: 'enforce' }, root);
-        const result = await consumeTrustedGrant(cwd, {
-            id: grant.id, subjectId: 'agent-1', taskId: 'task-1',
-            action: 'mcp.call', resource: 'mcp://github/get_issue',
-        }, root);
-        expect(result).toMatchObject({ ok: false, reason: 'Capability policy is stale' });
-    });
-});
-describe('action normalization and receipts', () => {
-    it('defaults unknown tools to external writes instead of assuming read-only', () => {
-        const action = normalizeMcpAction({
-            actorId: 'agent-1', taskId: 'task-1', server: 'custom', tool: 'execute', args: {},
-        });
-        expect(action.sideEffect).toBe('external-write');
-        expect(action.blastRadius).toBe('unknown');
-    });
-    it('detects receipt tampering', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const action = normalizeMcpAction({
-            actorId: 'agent-1', taskId: 'task-1', server: 'github', tool: 'get_issue', args: {},
-        });
-        await appendExecutionReceipt(cwd, {
-            action, mode: 'observe', decision: 'allow', simulatedDecision: 'deny',
-            reason: 'Observed', policyHash: 'policy', outcome: 'forwarded',
-        }, root);
-        expect(await verifyExecutionReceiptChain(cwd, root)).toMatchObject({ valid: true, count: 1 });
-        const log = path.join(getTrustedControlDir(cwd, root), 'receipts.jsonl');
-        const receipt = JSON.parse((await fs.readFile(log, 'utf8')).trim());
-        receipt.reason = 'tampered';
-        await fs.writeFile(log, `${JSON.stringify(receipt)}\n`);
-        expect((await verifyExecutionReceiptChain(cwd, root)).valid).toBe(false);
-    });
-    it('serializes concurrent receipt appends into one valid chain', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        const action = normalizeMcpAction({
-            actorId: 'agent-1', taskId: 'task-1', server: 'github', tool: 'get_issue', args: {},
-        });
-        await Promise.all(Array.from({ length: 8 }, () => appendExecutionReceipt(cwd, {
-            action, mode: 'observe', decision: 'allow', reason: 'Concurrent call',
-            policyHash: 'policy', outcome: 'forwarded',
-        }, root)));
-        expect(await verifyExecutionReceiptChain(cwd, root)).toMatchObject({ valid: true, count: 8 });
-    });
-    it('keeps the trusted receipt when the Studio projection is blocked', async () => {
-        const cwd = await repository();
-        const root = await controlRoot();
-        await fs.writeFile(path.join(cwd, '.rigour'), 'sandbox blocks this projection');
-        const action = normalizeMcpAction({
-            actorId: 'agent-1', taskId: 'task-1', server: 'github', tool: 'get_issue', args: {},
-        });
-        await expect(appendExecutionReceipt(cwd, {
-            action, mode: 'observe', decision: 'allow', reason: 'Projection optional',
-            policyHash: 'policy', outcome: 'forwarded',
-        }, root)).resolves.toMatchObject({ outcome: 'forwarded' });
-        expect(await verifyExecutionReceiptChain(cwd, root)).toMatchObject({ valid: true, count: 1 });
-    });
-});
-describe('receipt lock contention', () => {
-    it('retries while another append releases the lock, including Windows delete-pending errors', async () => {
-        const { isLockContention } = await import('./execution-receipt.js');
-        expect(isLockContention('EEXIST', 'linux')).toBe(true);
-        expect(isLockContention('EPERM', 'win32')).toBe(true);
-        expect(isLockContention('EBUSY', 'win32')).toBe(true);
-        expect(isLockContention('EPERM', 'linux')).toBe(false); // a real permission error elsewhere
-        expect(isLockContention('ENOENT', 'win32')).toBe(false);
-    });
-});

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

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