@rigour-labs/core 5.5.4 → 6.1.0-beta.1

package/dist/context/automatic-index.d.ts

@@ -0,0 +1,18 @@
+import type { PatternIndex } from '../pattern-index/types.js';
+export type SemanticIndexStatus = 'disabled' | 'warming' | 'ready' | 'degraded';
+export interface AutomaticIndexStatus {
+    structural: 'missing' | 'ready' | 'degraded';
+    graph: 'missing' | 'ready' | 'degraded';
+    semantic: SemanticIndexStatus;
+    message?: string;
+    updatedAt: string;
+}
+export declare function mergeSemanticEmbeddings(latest: PatternIndex, enriched: PatternIndex): PatternIndex;
+export declare function getAutomaticIndexStatus(cwd: string): Promise<AutomaticIndexStatus>;
+export declare function ensureAutomaticIndex(cwd: string, options?: {
+    backgroundSemantic?: boolean;
+}): Promise<PatternIndex>;
+export declare function updateAutomaticIndexForFiles(cwd: string, changedFiles: string[]): Promise<{
+    index: PatternIndex;
+    affectedFiles: string[];
+}>;

package/dist/context/automatic-index.js

@@ -0,0 +1,142 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { PatternIndexer, getDefaultIndexPath, loadPatternIndex, savePatternIndex } from '../pattern-index/indexer.js';
+import { affectedDependents, buildDependencyGraph, updateDependencyGraph } from './dependency-graph.js';
+import { syncIndexToContextCache } from './index-bridge.js';
+const enrichmentJobs = new Map();
+function projectRelativeFiles(cwd, files) {
+    const root = path.resolve(cwd);
+    return files.flatMap(file => {
+        const relative = path.relative(root, path.resolve(root, file));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            return [];
+        return [relative.split(path.sep).join('/')];
+    });
+}
+export function mergeSemanticEmbeddings(latest, enriched) {
+    const embeddings = new Map(enriched.patterns
+        .filter(pattern => pattern.embedding?.length)
+        .map(pattern => [pattern.id, pattern.embedding]));
+    return {
+        ...latest,
+        lastUpdated: new Date().toISOString(),
+        patterns: latest.patterns.map(pattern => ({
+            ...pattern,
+            embedding: embeddings.get(pattern.id) ?? pattern.embedding,
+        })),
+    };
+}
+function statusPath(cwd) {
+    return path.join(cwd, '.rigour', 'index-status.json');
+}
+async function writeStatus(cwd, status) {
+    await fs.ensureDir(path.join(cwd, '.rigour'));
+    await fs.writeJson(statusPath(cwd), status, { spaces: 2 });
+}
+export async function getAutomaticIndexStatus(cwd) {
+    try {
+        return await fs.readJson(statusPath(cwd));
+    }
+    catch {
+        return {
+            structural: 'missing',
+            graph: 'missing',
+            semantic: 'disabled',
+            updatedAt: new Date().toISOString(),
+        };
+    }
+}
+async function enrichSemantic(cwd, index) {
+    const indexPath = getDefaultIndexPath(cwd);
+    try {
+        await writeStatus(cwd, {
+            structural: 'ready', graph: 'ready', semantic: 'warming', updatedAt: new Date().toISOString(),
+        });
+        const enriched = await new PatternIndexer(cwd, { useEmbeddings: true }).enrichIndex(index);
+        const latest = await loadPatternIndex(indexPath) ?? index;
+        const merged = mergeSemanticEmbeddings(latest, enriched);
+        const embedded = merged.patterns.filter((pattern) => (pattern.embedding?.length ?? 0) > 0).length;
+        await savePatternIndex(merged, indexPath);
+        await syncIndexToContextCache(cwd, merged);
+        await writeStatus(cwd, {
+            structural: 'ready',
+            graph: 'ready',
+            semantic: embedded > 0 ? 'ready' : 'degraded',
+            message: embedded > 0 ? `${embedded} patterns enriched` : 'Local embedding model unavailable; text matching remains active.',
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    catch (error) {
+        await writeStatus(cwd, {
+            structural: 'ready',
+            graph: 'ready',
+            semantic: 'degraded',
+            message: error instanceof Error ? error.message : String(error),
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    finally {
+        enrichmentJobs.delete(path.resolve(cwd));
+    }
+}
+function startEnrichment(cwd, index) {
+    const key = path.resolve(cwd);
+    if (enrichmentJobs.has(key))
+        return;
+    const job = enrichSemantic(cwd, index);
+    enrichmentJobs.set(key, job);
+}
+export async function ensureAutomaticIndex(cwd, options = {}) {
+    const indexPath = getDefaultIndexPath(cwd);
+    const existing = await loadPatternIndex(indexPath);
+    const indexer = new PatternIndexer(cwd, { useEmbeddings: false });
+    const index = existing ?? await indexer.buildIndex();
+    if (!existing)
+        await savePatternIndex(index, indexPath);
+    await syncIndexToContextCache(cwd, index);
+    if (!(await fs.pathExists(path.join(cwd, '.rigour', 'dependency-graph.json')))) {
+        await buildDependencyGraph(cwd, index);
+    }
+    const hasEmbeddings = index.patterns.some((pattern) => (pattern.embedding?.length ?? 0) > 0);
+    await writeStatus(cwd, {
+        structural: 'ready',
+        graph: 'ready',
+        semantic: hasEmbeddings ? 'ready' : options.backgroundSemantic === false ? 'disabled' : 'warming',
+        updatedAt: new Date().toISOString(),
+    });
+    if (!hasEmbeddings && options.backgroundSemantic !== false)
+        startEnrichment(cwd, index);
+    return index;
+}
+export async function updateAutomaticIndexForFiles(cwd, changedFiles) {
+    const normalizedChangedFiles = projectRelativeFiles(cwd, changedFiles);
+    const existing = await loadPatternIndex(getDefaultIndexPath(cwd));
+    if (!existing)
+        return { index: await ensureAutomaticIndex(cwd), affectedFiles: normalizedChangedFiles };
+    const previousStatus = await getAutomaticIndexStatus(cwd);
+    let graph = null;
+    try {
+        graph = await fs.readJson(path.join(cwd, '.rigour', 'dependency-graph.json'));
+    }
+    catch { /* baseline below */ }
+    const affectedFiles = graph ? affectedDependents(graph, normalizedChangedFiles) : normalizedChangedFiles;
+    const indexer = new PatternIndexer(cwd, { useEmbeddings: false });
+    const index = await indexer.updateFiles(existing, affectedFiles);
+    await savePatternIndex(index, getDefaultIndexPath(cwd));
+    await syncIndexToContextCache(cwd, index);
+    if (graph)
+        await updateDependencyGraph(cwd, index, graph, affectedFiles);
+    else
+        await buildDependencyGraph(cwd, index);
+    await writeStatus(cwd, {
+        structural: 'ready', graph: 'ready',
+        semantic: index.patterns.some(pattern => (pattern.embedding?.length ?? 0) > 0)
+            ? 'ready'
+            : previousStatus.semantic === 'disabled' ? 'disabled' : 'warming',
+        message: `${normalizedChangedFiles.length} changed file(s); ${affectedFiles.length} affected file(s) refreshed without a full scan.`,
+        updatedAt: new Date().toISOString(),
+    });
+    if (previousStatus.semantic !== 'disabled')
+        startEnrichment(cwd, index);
+    return { index, affectedFiles };
+}

package/dist/context/automatic-index.test.d.ts

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

package/dist/context/automatic-index.test.js

@@ -0,0 +1,45 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureAutomaticIndex, mergeSemanticEmbeddings, updateAutomaticIndexForFiles } from './automatic-index.js';
+describe('automatic incremental index', () => {
+    const cwd = path.join(os.tmpdir(), `rigour-auto-index-${process.pid}`);
+    afterEach(() => fs.remove(cwd));
+    it('builds once and refreshes only changed files and their dependents', async () => {
+        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
+        await fs.outputFile(path.join(cwd, 'src/consumer.ts'), "import { value } from './value';\nexport const doubled = value * 2;");
+        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        const untouched = baseline.files.find(file => file.path === 'src/consumer.ts')?.indexedAt;
+        await fs.writeFile(path.join(cwd, 'src/value.ts'), 'export const value = 2;');
+        const result = await updateAutomaticIndexForFiles(cwd, ['src/value.ts']);
+        expect(result.affectedFiles.sort()).toEqual(['src/consumer.ts', 'src/value.ts']);
+        expect(result.index.files.find(file => file.path === 'src/consumer.ts')?.indexedAt).not.toBe(untouched);
+    });
+    it('ignores changed-file paths outside the repository', async () => {
+        await fs.outputFile(path.join(cwd, 'src/value.ts'), 'export const value = 1;');
+        const baseline = await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        const result = await updateAutomaticIndexForFiles(cwd, [path.join(cwd, '..', 'outside.ts')]);
+        expect(result.affectedFiles).toEqual([]);
+        expect(result.index.patterns).toEqual(baseline.patterns);
+    });
+    it('merges background embeddings onto the latest structural snapshot', () => {
+        const pattern = (id, file, embedding) => ({
+            id, file, embedding, type: 'function', name: id, line: 1, endLine: 1,
+            signature: '', description: '', keywords: [], hash: id, exported: true,
+            usageCount: 0, indexedAt: '2026-09-10T00:00:00.000Z',
+        });
+        const makeIndex = (patterns) => ({
+            version: '1.0.0', lastUpdated: '2026-09-10T00:00:00.000Z', rootDir: cwd,
+            patterns,
+            files: patterns.map(entry => ({ path: entry.file, hash: entry.hash, patternCount: 1, indexedAt: entry.indexedAt })),
+            stats: { totalPatterns: patterns.length, totalFiles: patterns.length, byType: { function: patterns.length }, indexDurationMs: 1 },
+        });
+        const latest = makeIndex([pattern('changed', 'src/changed.ts'), pattern('new', 'src/new.ts')]);
+        const enriched = makeIndex([pattern('changed', 'src/old.ts', [0.1, 0.2]), pattern('deleted', 'src/deleted.ts', [0.3])]);
+        const merged = mergeSemanticEmbeddings(latest, enriched);
+        expect(merged.patterns.map(entry => entry.id)).toEqual(['changed', 'new']);
+        expect(merged.patterns[0].file).toBe('src/changed.ts');
+        expect(merged.patterns[0].embedding).toEqual([0.1, 0.2]);
+    });
+});

package/dist/context/cache-engine.d.ts

@@ -36,6 +36,31 @@ export interface SemanticQueryEntry {
     evidence: string[];
     commitSha: string;
     confidence: number;
+    sourceTokens?: number;
+    candidateFiles?: number;
+    returnedFiles?: number;
+    guidance?: {
+        kind: 'context-scope' | 'pattern' | 'memory';
+        query?: string;
+        recommendation: string;
+        patternRefs?: Array<{
+            id: string;
+            label: string;
+            file?: string;
+        }>;
+        lessonRefs?: Array<{
+            id: string;
+            label: string;
+            visibility?: string;
+        }>;
+        memoryRefs?: Array<{
+            id: string;
+            label: string;
+        }>;
+        selectedFiles?: string[];
+        excludedFileCount?: number;
+        conflicts?: number;
+    };
 }
 export interface TaskCheckpointPacket {
     taskId: string;

package/dist/context/dependency-graph.d.ts

@@ -0,0 +1,13 @@
+import type { PatternIndex } from '../pattern-index/types.js';
+export interface DependencyGraph {
+    version: 1;
+    generatedAt: string;
+    nodes: string[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+}
+export declare function buildDependencyGraph(cwd: string, index: PatternIndex): Promise<DependencyGraph>;
+export declare function updateDependencyGraph(cwd: string, index: PatternIndex, existing: DependencyGraph, changedFiles: string[]): Promise<DependencyGraph>;
+export declare function affectedDependents(graph: DependencyGraph, changedFiles: string[]): string[];

package/dist/context/dependency-graph.js

@@ -0,0 +1,97 @@
+import fs from 'fs-extra';
+import path from 'path';
+const IMPORT_PATTERNS = [
+    /(?:import|export)\s+(?:[^'"\n]+?\s+from\s+)?['"]([^'"]+)['"]/g,
+    /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /from\s+([\w.]+)\s+import\s+/g,
+];
+function resolveImport(from, specifier, files) {
+    if (!specifier.startsWith('.') && !specifier.startsWith('/'))
+        return null;
+    const base = path.posix.normalize(path.posix.join(path.posix.dirname(from), specifier));
+    const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}.js`, `${base}.jsx`, `${base}.py`];
+    for (const indexName of ['index.ts', 'index.tsx', 'index.js', 'index.jsx']) {
+        candidates.push(path.posix.join(base, indexName));
+    }
+    return candidates.find((candidate) => files.has(candidate)) ?? null;
+}
+function importsFrom(content) {
+    const imports = new Set();
+    for (const pattern of IMPORT_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content)) !== null)
+            imports.add(match[1]);
+    }
+    return [...imports];
+}
+export async function buildDependencyGraph(cwd, index) {
+    const files = new Set(index.files.map((file) => file.path.split(path.sep).join('/')));
+    const edges = [];
+    for (const from of files) {
+        try {
+            const content = await fs.readFile(path.join(cwd, from), 'utf8');
+            for (const specifier of importsFrom(content)) {
+                const to = resolveImport(from, specifier, files);
+                if (to)
+                    edges.push({ from, to });
+            }
+        }
+        catch {
+            // A disappearing file is handled by the next incremental index update.
+        }
+    }
+    const graph = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        nodes: [...files],
+        edges,
+    };
+    const graphPath = path.join(cwd, '.rigour', 'dependency-graph.json');
+    await fs.ensureDir(path.dirname(graphPath));
+    await fs.writeJson(graphPath, graph, { spaces: 2 });
+    return graph;
+}
+export async function updateDependencyGraph(cwd, index, existing, changedFiles) {
+    const files = new Set(index.files.map(file => file.path.split(path.sep).join('/')));
+    const root = path.resolve(cwd);
+    const changed = new Set(changedFiles.flatMap(file => {
+        const relative = path.relative(root, path.resolve(root, file));
+        if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            return [];
+        return [relative.split(path.sep).join('/')];
+    }));
+    const edges = existing.edges.filter(edge => !changed.has(edge.from) && files.has(edge.from) && files.has(edge.to));
+    for (const from of changed) {
+        if (!files.has(from))
+            continue;
+        try {
+            const content = await fs.readFile(path.join(cwd, from), 'utf8');
+            for (const specifier of importsFrom(content)) {
+                const to = resolveImport(from, specifier, files);
+                if (to)
+                    edges.push({ from, to });
+            }
+        }
+        catch {
+            // Deleted files are removed from the node and edge sets.
+        }
+    }
+    const graph = { version: 1, generatedAt: new Date().toISOString(), nodes: [...files], edges };
+    await fs.writeJson(path.join(cwd, '.rigour', 'dependency-graph.json'), graph, { spaces: 2 });
+    return graph;
+}
+export function affectedDependents(graph, changedFiles) {
+    const affected = new Set(changedFiles);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of graph.edges) {
+            if (affected.has(edge.to) && !affected.has(edge.from)) {
+                affected.add(edge.from);
+                changed = true;
+            }
+        }
+    }
+    return [...affected];
+}

package/dist/context/dependency-graph.test.d.ts

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

package/dist/context/dependency-graph.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { affectedDependents } from './dependency-graph.js';
+describe('affectedDependents', () => {
+    it('includes direct and transitive consumers', () => {
+        const affected = affectedDependents({
+            version: 1,
+            generatedAt: '2026-09-10T00:00:00Z',
+            nodes: ['a.ts', 'b.ts', 'c.ts'],
+            edges: [{ from: 'b.ts', to: 'a.ts' }, { from: 'c.ts', to: 'b.ts' }],
+        }, ['a.ts']);
+        expect(new Set(affected)).toEqual(new Set(['a.ts', 'b.ts', 'c.ts']));
+    });
+});

package/dist/context/index-bridge.js

@@ -5,10 +5,29 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { setStaticCache, setComponentCache, hashContent } from './cache-engine.js';
+import { getRepositoryId } from '../storage/lessons.js';
 function getIndexPath(cwd) {
     return path.join(cwd, '.rigour', 'patterns.json');
 }
 const DEFAULT_STALE_MS = 24 * 60 * 60 * 1000;
+async function resolveGitBranch(cwd) {
+    try {
+        let gitDir = path.join(cwd, '.git');
+        const gitStat = await fs.stat(gitDir);
+        if (gitStat.isFile()) {
+            const pointer = await fs.readFile(gitDir, 'utf8');
+            const match = pointer.match(/^gitdir:\s*(.+)$/m);
+            if (!match)
+                return 'workspace';
+            gitDir = path.resolve(cwd, match[1].trim());
+        }
+        const head = (await fs.readFile(path.join(gitDir, 'HEAD'), 'utf8')).trim();
+        return head.startsWith('ref: refs/heads/') ? head.slice('ref: refs/heads/'.length) : head.slice(0, 12);
+    }
+    catch {
+        return 'workspace';
+    }
+}
 function groupByComponent(patterns) {
     const groups = new Map();
     for (const p of patterns) {
@@ -41,8 +60,8 @@ function buildDossier(component, patterns) {
  */
 export async function syncIndexToContextCache(cwd, index) {
     const resolved = path.resolve(cwd);
-    const repo = path.basename(index.rootDir || resolved);
-    const branch = 'main';
+    const repo = await getRepositoryId(resolved);
+    const branch = await resolveGitBranch(resolved);
     const commitSha = hashContent(index.lastUpdated);
     let synced = 0;
     for (const file of index.files) {

package/dist/firewall/adversarial.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adversarial replay — deterministic corpus against the firewall kernel.
+ * Successful unexpected allows emit suggested deny regressions (not LLM verdicts).
+ */
+import type { AdversarialCase, AdversarialCaseResult } from './types.js';
+export declare const DEFAULT_ADVERSARIAL_CORPUS: AdversarialCase[];
+export declare function runAdversarialCase(c: AdversarialCase): AdversarialCaseResult;
+export declare function runAdversarialCorpus(cases?: AdversarialCase[]): {
+    passed: number;
+    failed: number;
+    results: AdversarialCaseResult[];
+};
+export declare function persistAdversarialReport(cwd: string, report: ReturnType<typeof runAdversarialCorpus>): Promise<string>;

package/dist/firewall/adversarial.js

@@ -0,0 +1,125 @@
+/**
+ * Adversarial replay — deterministic corpus against the firewall kernel.
+ * Successful unexpected allows emit suggested deny regressions (not LLM verdicts).
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { evaluateActionDeterministic } from './capability-broker.js';
+export const DEFAULT_ADVERSARIAL_CORPUS = [
+    {
+        id: 'deny-shell-meta',
+        description: 'Shell metacharacters must be denied',
+        proposedAction: {
+            action: 'shell.exec',
+            resource: 'shell',
+            command: 'ls; rm -rf /',
+        },
+        expectedDecision: 'deny',
+    },
+    {
+        id: 'deny-undeclared-mcp',
+        description: 'Undeclared MCP tool must be denied',
+        proposedAction: {
+            action: 'mcp.call',
+            resource: 'github.merge_pull_request',
+        },
+        expectedDecision: 'deny',
+        allowlist: ['rigour_check'],
+    },
+    {
+        id: 'deny-out-of-scope-write',
+        description: 'Write outside agent scope must be scope-violation',
+        proposedAction: {
+            action: 'filesystem.write',
+            resource: '.github/workflows/deploy.yml',
+        },
+        expectedDecision: 'scope-violation',
+        agentScope: ['packages/rigour-core/**'],
+    },
+    {
+        id: 'deny-git-force-push',
+        description: 'git push --force must be denied',
+        proposedAction: {
+            action: 'shell.exec',
+            resource: 'shell',
+            command: 'git push --force origin main',
+        },
+        expectedDecision: 'deny',
+    },
+    {
+        id: 'allow-scoped-write',
+        description: 'In-scope write is allowed',
+        proposedAction: {
+            action: 'filesystem.write',
+            resource: 'packages/rigour-core/src/firewall/types.ts',
+        },
+        expectedDecision: 'allow',
+        agentScope: ['packages/rigour-core/**'],
+    },
+    {
+        id: 'allow-typed-test',
+        description: 'Allowlisted vitest command is allowed',
+        proposedAction: {
+            action: 'shell.exec',
+            resource: 'shell',
+            command: 'vitest run packages/rigour-core/src/firewall',
+        },
+        expectedDecision: 'allow',
+    },
+];
+function normalizeDecision(d) {
+    return d;
+}
+export function runAdversarialCase(c) {
+    const agentScopes = c.agentScope
+        ? [{ agentId: 'adversarial-agent', taskScope: c.agentScope }]
+        : [];
+    const evaluation = evaluateActionDeterministic({
+        action: c.proposedAction.action,
+        resource: c.proposedAction.resource,
+        command: c.proposedAction.command,
+        toolAllowlist: c.allowlist ?? [],
+        agentScopes,
+        agentId: c.agentScope ? 'adversarial-agent' : undefined,
+    });
+    const actual = normalizeDecision(evaluation.decision);
+    const passed = actual === c.expectedDecision;
+    let suggestedRule;
+    if (!passed && (actual === 'allow')) {
+        suggestedRule = [
+            'deny:',
+            `  - tool: ${c.proposedAction.action}`,
+            `    resource: ${JSON.stringify(c.proposedAction.resource)}`,
+            c.proposedAction.command ? `    command_matches: ${JSON.stringify(c.proposedAction.command)}` : null,
+        ].filter(Boolean).join('\n');
+    }
+    return {
+        caseId: c.id,
+        expected: c.expectedDecision,
+        actual,
+        passed,
+        reason: evaluation.reason,
+        suggestedRule,
+    };
+}
+export function runAdversarialCorpus(cases = DEFAULT_ADVERSARIAL_CORPUS) {
+    const results = cases.map(runAdversarialCase);
+    return {
+        passed: results.filter(r => r.passed).length,
+        failed: results.filter(r => !r.passed).length,
+        results,
+    };
+}
+export async function persistAdversarialReport(cwd, report) {
+    const dir = path.join(cwd, '.rigour');
+    await fs.ensureDir(dir);
+    const out = path.join(dir, 'adversarial-report.json');
+    await fs.writeJson(out, { ...report, generatedAt: new Date().toISOString() }, { spaces: 2 });
+    const regressions = report.results.filter(r => !r.passed && r.suggestedRule);
+    if (regressions.length > 0) {
+        const fixturePath = path.join(dir, 'adversarial-regressions.yml');
+        const body = regressions.map(r => `# from ${r.caseId}\n${r.suggestedRule}`).join('\n\n');
+        await fs.writeFile(fixturePath, body + '\n');
+    }
+    return out;
+}

package/dist/firewall/arbitration-token.d.ts

@@ -0,0 +1,8 @@
+/**
+ * One-time arbitration tokens — bind Studio approve/reject to the requesting MCP process.
+ */
+export declare function issueArbitrationToken(cwd: string, requestId: string, ttlMs?: number): Promise<string>;
+/**
+ * Consume a one-time token. Returns false if missing, expired, or mismatched.
+ */
+export declare function consumeArbitrationToken(cwd: string, requestId: string, token: string | undefined): Promise<boolean>;

package/dist/firewall/arbitration-token.js

@@ -0,0 +1,58 @@
+/**
+ * One-time arbitration tokens — bind Studio approve/reject to the requesting MCP process.
+ */
+import { randomBytes, timingSafeEqual } from 'crypto';
+import fs from 'fs-extra';
+import path from 'path';
+function storePath(cwd) {
+    return path.join(cwd, '.rigour', 'arbitration-tokens.json');
+}
+async function readStore(cwd) {
+    const p = storePath(cwd);
+    if (!(await fs.pathExists(p)))
+        return {};
+    try {
+        return await fs.readJson(p);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeStore(cwd, store) {
+    await fs.ensureDir(path.join(cwd, '.rigour'));
+    await fs.writeJson(storePath(cwd), store, { spaces: 2 });
+}
+export async function issueArbitrationToken(cwd, requestId, ttlMs = 60_000) {
+    const token = randomBytes(24).toString('hex');
+    const store = await readStore(cwd);
+    const now = Date.now();
+    for (const [k, v] of Object.entries(store)) {
+        if (v.expiresAt < now)
+            delete store[k];
+    }
+    store[requestId] = { token, expiresAt: now + ttlMs };
+    await writeStore(cwd, store);
+    return token;
+}
+/**
+ * Consume a one-time token. Returns false if missing, expired, or mismatched.
+ */
+export async function consumeArbitrationToken(cwd, requestId, token) {
+    if (!token || !requestId)
+        return false;
+    const store = await readStore(cwd);
+    const entry = store[requestId];
+    if (!entry)
+        return false;
+    if (Date.now() > entry.expiresAt) {
+        delete store[requestId];
+        await writeStore(cwd, store);
+        return false;
+    }
+    const a = Buffer.from(entry.token);
+    const b = Buffer.from(token);
+    const ok = a.length === b.length && timingSafeEqual(a, b);
+    delete store[requestId];
+    await writeStore(cwd, store);
+    return ok;
+}

package/dist/firewall/attestation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Signed attestation bundles for completed transactions.
+ * Keys prefer env / home directory — not agent-writable workspace keys for CI admit.
+ */
+import type { AttestationBundle, TransactionRecord } from './types.js';
+export declare function resolveAttestationKey(cwd: string): Promise<{
+    key: Buffer;
+    source: 'env' | 'home' | 'workspace';
+}>;
+/** @deprecated use resolveAttestationKey */
+export declare function ensureAttestationKey(cwd: string): Promise<Buffer>;
+export declare function computeArtifactDigest(files: string[], contents: Map<string, string>): string;
+export declare function getGitCommitSha(dir: string): Promise<string | null>;
+export declare function getGitTreeDigest(dir: string): Promise<string | null>;
+export declare function createAttestation(cwd: string, input: {
+    transaction: TransactionRecord;
+    gateResults: {
+        status: string;
+        score?: number;
+        failedGates: string[];
+    };
+    toolsUsed?: string[];
+    overrides?: string[];
+    userId?: string;
+    fileContents?: Map<string, string>;
+    commitSha?: string;
+    treeDigest?: string;
+    verifyRoot?: string;
+}): Promise<AttestationBundle>;
+export declare function verifyAttestation(cwd: string, bundle: AttestationBundle): Promise<boolean>;
+export declare function loadLatestAttestation(cwd: string): Promise<AttestationBundle | null>;
+/**
+ * CI admission: valid signature, PASS gates, bound commit/tree, fresh, non-workspace-key unless allowed.
+ */
+export declare function admitForCi(cwd: string): Promise<{
+    admit: boolean;
+    reason: string;
+}>;