@rigour-labs/core 6.5.3 → 6.6.0

package/README.md

@@ -46,7 +46,7 @@ Rigour's deep analysis is not a wrapper around a generic LLM. The model operates
 2. **Interpret** — the model receives structured facts (not raw source), focuses on SOLID, design patterns, language idioms, architecture. Constrained input prevents hallucination.
 3. **Verify** — every LLM finding is cross-referenced against all five signal streams. Wrong line numbers, phantom patterns, non-existent functions → discarded. Only verified findings with confidence scores reach the report.
 
-The lite and deep tiers are fine-tuned via the [DriftBench RLAIF pipeline](https://github.com/rigour-labs/driftbench), where the five signal streams serve as the teacher signal. The max tier (Qwen2.5-Coder-7B) runs the stock model until a fine-tune passes the evaluation gate.
+Deep review is built for frontier models: your own key, or the coding agent's own model. The small local models (lite and deep tiers fine-tuned via the [DriftBench RLAIF pipeline](https://github.com/rigour-labs/driftbench); max is the stock Qwen2.5-Coder-7B) remain available offline but are no longer developed.
 
 ### Temporal Drift Engine (v5.1)
 

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

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

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

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const writes = vi.hoisted(() => ({ count: 0 }));
+vi.mock('../storage/context-telemetry.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    setContextCacheRecord: async () => { writes.count++; },
+}));
+const { ensureAutomaticIndex, updateAutomaticIndexForFiles } = await import('./automatic-index.js');
+let cwd;
+beforeEach(() => {
+    writes.count = 0;
+    cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'auto-index-'));
+    fs.mkdirSync(path.join(cwd, 'src'));
+    fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'export function alpha() { return 1; }\n');
+    fs.writeFileSync(path.join(cwd, 'src/b.ts'), 'export function beta() { return 2; }\n');
+});
+afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
+describe('automatic indexing', () => {
+    it('writes nothing to the context cache, however many edits it sees', async () => {
+        await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        for (let edit = 0; edit < 5; edit++) {
+            fs.writeFileSync(path.join(cwd, 'src/a.ts'), `export function alpha() { return ${edit}; }\n`);
+            await updateAutomaticIndexForFiles(cwd, ['src/a.ts']);
+        }
+        expect(writes.count).toBe(0);
+        expect(fs.existsSync(path.join(cwd, '.rigour', 'patterns.json'))).toBe(true);
+    });
+});

package/dist/context/automatic-index.js

@@ -3,7 +3,6 @@ import path from 'path';
 import { PatternIndexer, getDefaultIndexPath, loadPatternIndex, savePatternIndex } from '../pattern-index/indexer.js';
 import { EMBEDDING_TEXT_VERSION } from '../pattern-index/embeddings.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);
@@ -78,7 +77,6 @@ async function enrichSemantic(cwd, 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',
@@ -114,7 +112,6 @@ export async function ensureAutomaticIndex(cwd, options = {}) {
     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);
     }
@@ -144,7 +141,6 @@ export async function updateAutomaticIndexForFiles(cwd, changedFiles) {
     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

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

@@ -1,32 +1,11 @@
 /**
- * 4-Layer Context Caching Engine for Rigour
+ * Context caching for Rigour: the two layers something reads.
+ * - Semantic-query cache: the edit and validation scope resolved for a task query.
+ * - Task checkpoint cache: compact handoff packets between agents.
  *
- * Implements:
- * 1. Content-addressed static cache (AST, exports, imports, dependencies, patterns by content SHA)
- * 2. Component context cache (Compact dossiers per component scope)
- * 3. Semantic-query cache (Intent embeddings & edit/validation scopes)
- * 4. Task checkpoint cache (Subagent handoff packets)
+ * The static (per-file) and component layers were removed: nothing read them, and the index sync
+ * that wrote them added a fresh row per component on every edit (millions of rows in real use).
  */
-export interface StaticCacheEntry {
-    astSummary?: any;
-    exports?: string[];
-    imports?: string[];
-    dependencies?: string[];
-    ownership?: string;
-    schemas?: any[];
-    endpoints?: string[];
-    eventRelationships?: any[];
-    styleFingerprint?: string;
-    rigourPatterns?: string[];
-}
-export interface ComponentDossier {
-    component: string;
-    responsibility: string;
-    canonicalFiles: string[];
-    contracts: string[];
-    directConsumers: string[];
-    validationCommands: string[];
-}
 export interface SemanticQueryEntry {
     query: string;
     intentEmbedding?: number[];
@@ -78,17 +57,7 @@ export interface TaskCheckpointPacket {
  */
 export declare function hashContent(content: string): string;
 /**
- * Layer 1: Content-Addressed Static Cache
- */
-export declare function getStaticCache(repo: string, branch: string, filePath: string, fileContent: string, cwd?: string): Promise<StaticCacheEntry | null>;
-export declare function setStaticCache(repo: string, branch: string, filePath: string, fileContent: string, entry: StaticCacheEntry, cwd?: string): Promise<void>;
-/**
- * Layer 2: Component Context Cache
- */
-export declare function getComponentCache(componentName: string, commitSha: string, profileVersion?: string, cwd?: string): Promise<ComponentDossier | null>;
-export declare function setComponentCache(componentName: string, commitSha: string, dossier: ComponentDossier, dependencyFingerprint: string, profileVersion?: string, cwd?: string): Promise<void>;
-/**
- * Layer 3: Semantic-Query Cache
+ * Semantic-Query Cache
  */
 export declare function normalizeQuery(query: string): string;
 export declare function getSemanticQueryCache(query: string, commitSha: string, cwd?: string): Promise<SemanticQueryEntry | null>;
@@ -119,7 +88,7 @@ export declare function filterExistingEditScope(editScope: string[], cwd: string
     missing: string[];
 }>;
 /**
- * Layer 4: Task Checkpoint Cache
+ * Task Checkpoint Cache
  */
 export declare function setTaskCheckpointCache(packet: TaskCheckpointPacket, rawStateTokens: number, cwd?: string): Promise<void>;
 export declare function getTaskCheckpointCache(taskId: string, agentId: string, phase: string, cwd?: string): Promise<TaskCheckpointPacket | null>;

package/dist/context/cache-engine.js

@@ -1,11 +1,10 @@
 /**
- * 4-Layer Context Caching Engine for Rigour
+ * Context caching for Rigour: the two layers something reads.
+ * - Semantic-query cache: the edit and validation scope resolved for a task query.
+ * - Task checkpoint cache: compact handoff packets between agents.
  *
- * Implements:
- * 1. Content-addressed static cache (AST, exports, imports, dependencies, patterns by content SHA)
- * 2. Component context cache (Compact dossiers per component scope)
- * 3. Semantic-query cache (Intent embeddings & edit/validation scopes)
- * 4. Task checkpoint cache (Subagent handoff packets)
+ * The static (per-file) and component layers were removed: nothing read them, and the index sync
+ * that wrote them added a fresh row per component on every edit (millions of rows in real use).
  */
 import { createHash } from 'crypto';
 import fs from 'fs-extra';
@@ -18,69 +17,7 @@ export function hashContent(content) {
     return createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
 /**
- * Layer 1: Content-Addressed Static Cache
- */
-export async function getStaticCache(repo, branch, filePath, fileContent, cwd) {
-    const contentSha = hashContent(fileContent);
-    const cacheKey = `static:${repo}:${branch}:${filePath}:${contentSha}:v1`;
-    const record = await getContextCacheRecord(cacheKey, cwd);
-    if (!record)
-        return null;
-    try {
-        return JSON.parse(record.payloadJson);
-    }
-    catch {
-        return null;
-    }
-}
-export async function setStaticCache(repo, branch, filePath, fileContent, entry, cwd) {
-    const contentSha = hashContent(fileContent);
-    const cacheKey = `static:${repo}:${branch}:${filePath}:${contentSha}:v1`;
-    const payloadJson = JSON.stringify(entry);
-    const payloadTokens = Math.ceil(payloadJson.length / 4);
-    await setContextCacheRecord({
-        cacheKey,
-        cacheType: 'static',
-        repo,
-        branch,
-        commitSha: contentSha,
-        dependencyFingerprint: `sha-${contentSha}`,
-        payloadJson,
-        payloadTokens,
-    }, cwd);
-}
-/**
- * Layer 2: Component Context Cache
- */
-export async function getComponentCache(componentName, commitSha, profileVersion = '3', cwd) {
-    const cacheKey = `component:${componentName}:${commitSha}:v${profileVersion}`;
-    const record = await getContextCacheRecord(cacheKey, cwd);
-    if (!record)
-        return null;
-    try {
-        return JSON.parse(record.payloadJson);
-    }
-    catch {
-        return null;
-    }
-}
-export async function setComponentCache(componentName, commitSha, dossier, dependencyFingerprint, profileVersion = '3', cwd) {
-    const cacheKey = `component:${componentName}:${commitSha}:v${profileVersion}`;
-    const payloadJson = JSON.stringify(dossier);
-    const payloadTokens = Math.ceil(payloadJson.length / 4);
-    await setContextCacheRecord({
-        cacheKey,
-        cacheType: 'component',
-        repo: dossier.component,
-        branch: 'main',
-        commitSha,
-        dependencyFingerprint,
-        payloadJson,
-        payloadTokens,
-    }, cwd);
-}
-/**
- * Layer 3: Semantic-Query Cache
+ * Semantic-Query Cache
  */
 export function normalizeQuery(query) {
     return query.toLowerCase().trim().replace(/[^a-z0-9\s]/g, '').replace(/\s+/g, ' ');
@@ -193,7 +130,7 @@ export async function filterExistingEditScope(editScope, cwd) {
     return { valid, missing };
 }
 /**
- * Layer 4: Task Checkpoint Cache
+ * Task Checkpoint Cache
  */
 export async function setTaskCheckpointCache(packet, rawStateTokens, cwd) {
     const cacheKey = `checkpoint:${packet.taskId}:${packet.agentId}:${packet.phase}`;

package/dist/context/cache-engine.test.js

@@ -8,8 +8,8 @@ vi.mock('./db.js', () => ({
     DB_PATH: '/tmp/rigour-test.db',
     RIGOUR_DIR: '/tmp/.rigour',
 }));
-import { getStaticCache, setStaticCache, getComponentCache, setComponentCache, getSemanticQueryCache, setSemanticQueryCache, findRelatedSemanticQueryCache, queryTokenOverlap, distinctiveTokenAgreement, filterExistingEditScope, getTaskCheckpointCache, setTaskCheckpointCache, hashContent, normalizeQuery } from './cache-engine.js';
-describe('4-Layer Context Cache Engine', () => {
+import { getSemanticQueryCache, setSemanticQueryCache, findRelatedSemanticQueryCache, queryTokenOverlap, distinctiveTokenAgreement, filterExistingEditScope, getTaskCheckpointCache, setTaskCheckpointCache, hashContent, normalizeQuery } from './cache-engine.js';
+describe('Context cache engine', () => {
     const testCwd = path.join(os.tmpdir(), `rigour-cache-test-${Date.now()}`);
     beforeEach(async () => {
         await fs.ensureDir(testCwd);
@@ -26,35 +26,6 @@ describe('4-Layer Context Cache Engine', () => {
         expect(normalizeQuery('  Add priority to task!! ')).toBe('add priority to task');
         expect(normalizeQuery('Task SHOULD Support Priority.')).toBe('task should support priority');
     });
-    it('Layer 1: should store and retrieve content-addressed static cache', async () => {
-        const fileContent = 'export function processTask() { return true; }';
-        const entry = {
-            exports: ['processTask'],
-            imports: [],
-            ownership: 'platform-team',
-            endpoints: ['/api/task']
-        };
-        await setStaticCache('rigour-repo', 'main', 'services/task.ts', fileContent, entry, testCwd);
-        const cached = await getStaticCache('rigour-repo', 'main', 'services/task.ts', fileContent, testCwd);
-        expect(cached).not.toBeNull();
-        expect(cached?.exports).toEqual(['processTask']);
-        expect(cached?.ownership).toBe('platform-team');
-    });
-    it('Layer 2: should store and retrieve component context dossier', async () => {
-        const dossier = {
-            component: 'services/task',
-            responsibility: 'Task lifecycle and persistence',
-            canonicalFiles: ['services/task.ts'],
-            contracts: ['TaskContract'],
-            directConsumers: ['controllers/task'],
-            validationCommands: ['npm test']
-        };
-        await setComponentCache('services/task', 'abc123commit', dossier, 'dep-fingerprint-v1', '3', testCwd);
-        const retrieved = await getComponentCache('services/task', 'abc123commit', '3', testCwd);
-        expect(retrieved).not.toBeNull();
-        expect(retrieved?.responsibility).toBe('Task lifecycle and persistence');
-        expect(retrieved?.canonicalFiles).toContain('services/task.ts');
-    });
     it('Layer 3: should store and retrieve semantic query scope', async () => {
         const entry = {
             query: 'task priority persistence',
@@ -125,19 +96,4 @@ describe('4-Layer Context Cache Engine', () => {
         expect(result.valid).toEqual(['alive.ts']);
         expect(result.missing).toEqual(['gone.ts']);
     });
-    it('Layer 1: invalidates static cache when file content changes', async () => {
-        const originalContent = 'export function processTask() { return true; }';
-        const entry = {
-            exports: ['processTask'],
-            imports: [],
-            ownership: 'platform-team',
-            endpoints: ['/api/task'],
-        };
-        await setStaticCache('rigour-repo', 'main', 'services/task.ts', originalContent, entry, testCwd);
-        const cached = await getStaticCache('rigour-repo', 'main', 'services/task.ts', originalContent, testCwd);
-        expect(cached?.exports).toEqual(['processTask']);
-        const changedContent = 'export function processTask() { return false; }';
-        const stale = await getStaticCache('rigour-repo', 'main', 'services/task.ts', changedContent, testCwd);
-        expect(stale).toBeNull();
-    });
 });

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

@@ -1,8 +1,6 @@
 /**
- * Bridge between Pattern Index and 4-Layer Context Cache.
- * Syncs indexed patterns into static cache entries and component dossiers.
+ * Health of the pattern index (.rigour/patterns.json): present, readable, fresh.
  */
-import type { PatternIndex } from '../pattern-index/types.js';
 export interface IndexHealthReport {
     indexPath: string;
     exists: boolean;
@@ -14,10 +12,6 @@ export interface IndexHealthReport {
     totalFiles?: number;
     message: string;
 }
-/**
- * Sync pattern index entries into static cache and component dossier layers.
- */
-export declare function syncIndexToContextCache(cwd: string, index: PatternIndex): Promise<number>;
 /**
  * Check patterns.json freshness relative to the project directory.
  */

package/dist/context/index-bridge.js

@@ -1,90 +1,12 @@
 /**
- * Bridge between Pattern Index and 4-Layer Context Cache.
- * Syncs indexed patterns into static cache entries and component dossiers.
+ * Health of the pattern index (.rigour/patterns.json): present, readable, fresh.
  */
 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) {
-        const key = p.type === 'component' ? p.name : p.category || 'uncategorized';
-        const list = groups.get(key) ?? [];
-        list.push(p);
-        groups.set(key, list);
-    }
-    return groups;
-}
-function buildDossier(component, patterns) {
-    const canonicalFiles = [...new Set(patterns.map(p => p.file))];
-    const contracts = patterns
-        .filter(p => p.signature)
-        .map(p => p.signature)
-        .slice(0, 20);
-    const descriptions = patterns.map(p => p.description).filter(Boolean);
-    const responsibility = descriptions[0] || `Indexed ${patterns.length} patterns for ${component}`;
-    return {
-        component,
-        responsibility,
-        canonicalFiles,
-        contracts,
-        directConsumers: [],
-        validationCommands: [],
-    };
-}
-/**
- * Sync pattern index entries into static cache and component dossier layers.
- */
-export async function syncIndexToContextCache(cwd, index) {
-    const resolved = path.resolve(cwd);
-    const repo = await getRepositoryId(resolved);
-    const branch = await resolveGitBranch(resolved);
-    const commitSha = hashContent(index.lastUpdated);
-    let synced = 0;
-    for (const file of index.files) {
-        const filePatterns = index.patterns.filter(p => p.file === file.path);
-        if (filePatterns.length === 0)
-            continue;
-        const payload = {
-            rigourPatterns: filePatterns.map(p => `${p.type}:${p.name}`),
-            exports: filePatterns.filter(p => p.exported).map(p => p.name),
-        };
-        const fileContent = JSON.stringify(payload);
-        await setStaticCache(repo, branch, file.path, fileContent, payload, resolved);
-        synced++;
-    }
-    const componentGroups = groupByComponent(index.patterns);
-    for (const [component, patterns] of componentGroups) {
-        const dossier = buildDossier(component, patterns);
-        const fingerprint = hashContent(JSON.stringify(patterns.map(p => p.id)));
-        await setComponentCache(component, commitSha, dossier, fingerprint, '3', resolved);
-        synced++;
-    }
-    return synced;
-}
 /**
  * Check patterns.json freshness relative to the project directory.
  */

package/dist/deep/risk.d.ts

@@ -38,4 +38,10 @@ export declare function findFunction(cwd: string, file: string, name: string): {
     start: number;
     end: number;
 } | undefined;
+/**
+ * What a review record is bound to: the function's exact source. Collapsing whitespace once let
+ * `"a  b"` and `"a b"` share a hash, so a string changed after review still counted as reviewed.
+ * Only line endings are normalised (a Windows checkout is the same code); any other change,
+ * formatting included, asks for a new review.
+ */
 export declare function functionHash(text: string): string;

package/dist/deep/risk.js

@@ -92,8 +92,14 @@ export function findFunction(cwd, file, name) {
     visit(sourceFile);
     return found;
 }
+/**
+ * What a review record is bound to: the function's exact source. Collapsing whitespace once let
+ * `"a  b"` and `"a b"` share a hash, so a string changed after review still counted as reviewed.
+ * Only line endings are normalised (a Windows checkout is the same code); any other change,
+ * formatting included, asks for a new review.
+ */
 export function functionHash(text) {
-    return crypto.createHash('sha256').update(text.replace(/\s+/g, ' ').trim()).digest('hex');
+    return crypto.createHash('sha256').update(text.replace(/\r\n/g, '\n')).digest('hex');
 }
 const GUARD = /\b(?:if|else|return|throw|break|continue|catch)\b|\?\?|\?\./g;
 function guards(lines) {

package/dist/deep/risk.test.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { rankChangedFunctions, scoreRisk } from './risk.js';
+import { functionHash, rankChangedFunctions, scoreRisk } from './risk.js';
 import { routeFiles } from './router.js';
 let dir;
 beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'risk-')); });
@@ -61,3 +61,14 @@ describe('routeFiles', () => {
         expect(stale.stats).toMatchObject({ routed: 1, already_reviewed: 0 });
     });
 });
+describe('functionHash', () => {
+    it('changes when anything inside the function changes, strings included', () => {
+        const a = 'function f() { return "a  b"; }';
+        const b = 'function f() { return "a b"; }';
+        expect(functionHash(a)).not.toBe(functionHash(b));
+        expect(functionHash('function f() { return `x ${y}`; }')).not.toBe(functionHash('function f() { return `x  ${y}`; }'));
+    });
+    it('treats a Windows checkout of the same code as the same code', () => {
+        expect(functionHash('function f() {\r\n  return 1;\r\n}')).toBe(functionHash('function f() {\n  return 1;\n}'));
+    });
+});

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

@@ -1,8 +1,17 @@
 /**
- * One-time arbitration tokens — bind Studio approve/reject to the requesting MCP process.
+ * One-time arbitration tokens — bind a Studio approve/reject to the MCP process that asked.
+ *
+ * The token lives only in the requesting process's memory and in a store outside the workspace
+ * (never in .rigour/ or the event log, which agents write). Studio consumes it once and signs the
+ * decision with it; the requester accepts only a decision whose signature verifies, so appending
+ * a decision line to .rigour/events.jsonl approves nothing.
  */
+export type ArbitrationDecision = 'approve' | 'reject';
 export declare function issueArbitrationToken(cwd: string, requestId: string, ttlMs?: number): Promise<string>;
 /**
- * Consume a one-time token. Returns false if missing, expired, or mismatched.
+ * Studio side: consume the request's token once and sign the human's decision with it.
+ * Null when the request is unknown, expired or already decided.
  */
-export declare function consumeArbitrationToken(cwd: string, requestId: string, token: string | undefined): Promise<boolean>;
+export declare function signArbitrationDecision(cwd: string, requestId: string, decision: ArbitrationDecision): Promise<string | null>;
+/** Requester side: true only for a decision signed with the token this process issued. */
+export declare function verifyArbitrationDecision(token: string, requestId: string, decision: unknown, proof: unknown): boolean;

package/dist/firewall/arbitration-token.js

@@ -1,26 +1,29 @@
 /**
- * One-time arbitration tokens — bind Studio approve/reject to the requesting MCP process.
+ * One-time arbitration tokens — bind a Studio approve/reject to the MCP process that asked.
+ *
+ * The token lives only in the requesting process's memory and in a store outside the workspace
+ * (never in .rigour/ or the event log, which agents write). Studio consumes it once and signs the
+ * decision with it; the requester accepts only a decision whose signature verifies, so appending
+ * a decision line to .rigour/events.jsonl approves nothing.
  */
-import { randomBytes, timingSafeEqual } from 'crypto';
+import { createHmac, randomBytes, timingSafeEqual } from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';
+import { repoStateDir } from '../utils/user-state.js';
 function storePath(cwd) {
-    return path.join(cwd, '.rigour', 'arbitration-tokens.json');
+    return path.join(repoStateDir(cwd), 'arbitration-tokens.json');
 }
 async function readStore(cwd) {
-    const p = storePath(cwd);
-    if (!(await fs.pathExists(p)))
-        return {};
     try {
-        return await fs.readJson(p);
+        return await fs.readJson(storePath(cwd));
     }
     catch {
         return {};
     }
 }
 async function writeStore(cwd, store) {
-    await fs.ensureDir(path.join(cwd, '.rigour'));
-    await fs.writeJson(storePath(cwd), store, { spaces: 2 });
+    await fs.ensureDir(path.dirname(storePath(cwd)), { mode: 0o700 });
+    await fs.writeJson(storePath(cwd), store, { spaces: 2, mode: 0o600 });
 }
 export async function issueArbitrationToken(cwd, requestId, ttlMs = 60_000) {
     const token = randomBytes(24).toString('hex');
@@ -34,25 +37,29 @@ export async function issueArbitrationToken(cwd, requestId, ttlMs = 60_000) {
     await writeStore(cwd, store);
     return token;
 }
+function decisionProof(token, requestId, decision) {
+    return createHmac('sha256', token).update(`${requestId}:${decision}`).digest('hex');
+}
 /**
- * Consume a one-time token. Returns false if missing, expired, or mismatched.
+ * Studio side: consume the request's token once and sign the human's decision with it.
+ * Null when the request is unknown, expired or already decided.
  */
-export async function consumeArbitrationToken(cwd, requestId, token) {
-    if (!token || !requestId)
-        return false;
+export async function signArbitrationDecision(cwd, requestId, decision) {
+    if (!requestId)
+        return null;
     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);
+        return null;
     delete store[requestId];
     await writeStore(cwd, store);
-    return ok;
+    return Date.now() > entry.expiresAt ? null : decisionProof(entry.token, requestId, decision);
+}
+/** Requester side: true only for a decision signed with the token this process issued. */
+export function verifyArbitrationDecision(token, requestId, decision, proof) {
+    if ((decision !== 'approve' && decision !== 'reject') || typeof proof !== 'string')
+        return false;
+    const expected = Buffer.from(decisionProof(token, requestId, decision));
+    const given = Buffer.from(proof);
+    return expected.length === given.length && timingSafeEqual(expected, given);
 }

package/dist/firewall/attestation.d.ts

@@ -30,9 +30,14 @@ export declare function createAttestation(cwd: string, input: {
 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.
+ * CI admission. Admits only a bundle that is signed with a key outside the workspace, records PASS
+ * gates, is fresh, is bound to this checkout (commit or tree, and at least one must be present and
+ * match), whose artifact digest recomputes from the files here, and, when the caller names the
+ * policy it requires, was produced under that policy.
  */
-export declare function admitForCi(cwd: string): Promise<{
+export declare function admitForCi(cwd: string, options?: {
+    policyHash?: string;
+}): Promise<{
     admit: boolean;
     reason: string;
 }>;