Add executable Veritas verification gate

README.md

@@ -39,6 +39,8 @@ See `runtime/README.md` and `models/manifest.json` for the adapter contract and
 
 The original AIDE Developer's Credo, inspired by broad Mandalorian discipline themes and translated into engineering behavior, lives in `harness/credo.md`; its research and copyright boundary is in `harness/credo-research.md`. It is mandatory harness context for every model role, alongside the role-specific SOP cards in `harness/sops.json`. `harness/veritas.mjs` uses calibrated task thresholds: 90% for ordinary explanation/code-change evidence and 98% for security, publishing, payment, and identity operations. These are evidence gates, not promises of universal model accuracy; failed gates produce abstention.
 
+`npm run veritas` executes the real local gate before a release or verified answer: compile checks, tests, Git whitespace checks, manifest validation, path boundaries, and secret scanning. It is intentionally allowlisted and does not execute arbitrary model-generated commands.
+
 ## Status
 
 This is a pre-production engineering release. The Liquid checkpoint is not included until its exact artifact, license, checksum, and evaluation are confirmed. The Qwen weight is downloaded separately from its official repository and should be verified before offline use.

harness/README.md

@@ -36,4 +36,6 @@ intake -> guard -> retrieve -> plan -> propose -> verify -> revise -> test -> re
 
 See `orchestrator.mjs` and `policy.json` for the executable contract.
 
+Run `npm run veritas` from a workspace to execute the allowlisted compile, test, Git diff, manifest, secret, and path-boundary checks. A model verdict never overrides a failed execution check. The orchestrator accepts this runner as `verificationRunner` and blocks the final status until it passes.
+
 The research and translation boundary is documented in `credo-research.md`. The product uses original engineering language rather than fictional quotations or branding.

harness/checks.mjs

@@ -0,0 +1,71 @@
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const ALLOWED_COMMANDS = Object.freeze({
+  compile: ['npm', ['run', 'check']],
+  tests: ['npm', ['test']],
+  'git-diff': ['git', ['diff', '--check']]
+});
+
+function command(name, cwd) {
+  const entry = ALLOWED_COMMANDS[name];
+  if (!entry) throw new Error(`command is not allowlisted: ${name}`);
+  return new Promise(resolve => {
+    execFile(entry[0], entry[1], { cwd, timeout: 120000, maxBuffer: 512 * 1024 }, (error, stdout, stderr) => {
+      resolve({
+        name,
+        passed: !error,
+        exit_code: error?.code ?? 0,
+        output: `${stdout}${stderr}`.slice(-12000)
+      });
+    });
+  });
+}
+
+async function secretScan(workspace) {
+  const suspicious = /(hf_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9]{20,}|BEGIN (RSA|OPENSSH|EC) PRIVATE KEY)/;
+  const files = [];
+  async function walk(directory, depth = 0) {
+    if (depth > 4) return;
+    for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      const target = path.join(directory, entry.name);
+      if (entry.isDirectory()) await walk(target, depth + 1);
+      else if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.mjs') || entry.name.endsWith('.json') || entry.name.endsWith('.md') || entry.name.endsWith('.html'))) files.push(target);
+    }
+  }
+  await walk(workspace);
+  const hits = [];
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf8');
+    if (suspicious.test(content)) hits.push(path.relative(workspace, file));
+  }
+  return { name: 'secret-scan', passed: hits.length === 0, hits };
+}
+
+async function manifestCheck(workspace) {
+  const files = ['models/manifest.json', 'community/node-manifest.json', 'release/package-manifest.json'];
+  const errors = [];
+  for (const file of files) {
+    try { JSON.parse(await fs.readFile(path.join(workspace, file), 'utf8')); }
+    catch (error) { errors.push(`${file}: ${error.message}`); }
+  }
+  return { name: 'manifest-validation', passed: errors.length === 0, errors };
+}
+
+function boundaryCheck(workspace, changedFiles = []) {
+  const root = path.resolve(workspace) + path.sep;
+  const invalid = changedFiles.filter(file => !path.resolve(workspace, file).startsWith(root));
+  return { name: 'path-boundary', passed: invalid.length === 0, invalid };
+}
+
+export async function runVeritasChecks({ workspace, changedFiles = [] } = {}) {
+  const results = [boundaryCheck(workspace, changedFiles), await secretScan(workspace), await manifestCheck(workspace)];
+  for (const name of ['compile', 'tests', 'git-diff']) results.push(await command(name, workspace));
+  return {
+    passed: results.every(result => result.passed),
+    checks: Object.fromEntries(results.map(result => [result.name, result.passed])),
+    results
+  };
+}

harness/orchestrator.mjs

@@ -1,4 +1,4 @@
-import { evaluateVeritas } from './veritas.mjs';
+import { evaluateExecution, evaluateVeritas } from './veritas.mjs';
 
 const DEFAULT_POLICY = Object.freeze({
   max_turns: 4,
@@ -32,7 +32,7 @@ function bounded(value, max, label) {
   return text;
 }
 
-export function createHarness({ providers, tools = {}, policy = {} }) {
+export function createHarness({ providers, tools = {}, policy = {}, verificationRunner = null }) {
   const rules = { ...DEFAULT_POLICY, ...policy };
   return {
     async run(task, context = {}) {
@@ -71,11 +71,10 @@ export function createHarness({ providers, tools = {}, policy = {} }) {
         patch
       });
       const approved = /^\s*APPROVE\b/i.test(String(verdict));
-      const veritas = evaluateVeritas({
-        taskClass: context.taskClass || 'code-change',
-        evidenceScore: context.evidenceScore,
-        checks: context.checks
-      });
+      const execution = verificationRunner ? await verificationRunner({ task: goal, plan, patch, context }) : null;
+      const veritas = execution
+        ? evaluateExecution({ taskClass: context.taskClass || 'code-change', execution })
+        : evaluateVeritas({ taskClass: context.taskClass || 'code-change', evidenceScore: context.evidenceScore, checks: context.checks });
       trace.push({ stage: 'verify', status: approved ? 'approved-with-notes' : 'blocked' });
       trace.push({ stage: 'veritas', status: veritas.status, score: veritas.score, threshold: veritas.threshold });
       return {
@@ -83,6 +82,7 @@ export function createHarness({ providers, tools = {}, policy = {} }) {
         plan,
         patch,
         verdict,
+        execution,
         veritas,
         trace,
         apply: async () => {

harness/run-veritas.mjs

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runVeritasChecks } from './checks.mjs';
+
+const root = path.resolve(process.argv[2] || path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'));
+const result = await runVeritasChecks({ workspace: root });
+console.log(JSON.stringify(result, null, 2));
+if (!result.passed) process.exitCode = 1;

harness/test-orchestrator.mjs

@@ -17,4 +17,12 @@ assert.equal(calls.length, 3);
 assert.equal(result.veritas.status, 'abstain-needs-evidence');
 assert.ok(calls.every(call => call.input.mandatory_credo.includes('Protect the user')));
 await assert.rejects(result.apply(), /permission-gated daemon/);
+const verifiedHarness = createHarness({
+  providers: { reason: provider('reason'), build: provider('build'), verify: provider('verify') },
+  policy: { require_human_approval: false },
+  verificationRunner: async () => ({ passed: true, checks: { compile: true, tests: true, 'git-diff': true } })
+});
+const verified = await verifiedHarness.run('Run the verified flow', { taskClass: 'code-change' });
+assert.equal(verified.status, 'ready-for-apply');
+assert.equal(verified.veritas.status, 'verified');
 console.log('universal harness test passed');

harness/veritas.mjs

@@ -19,3 +19,8 @@ export function evaluateVeritas({ taskClass = 'code-change', evidenceScore = 0,
     rule: 'Model confidence is not evidence. A failed deterministic gate blocks final output.'
   };
 }
+
+export function evaluateExecution({ taskClass = 'code-change', execution } = {}) {
+  const evidenceScore = execution?.passed ? 1 : 0;
+  return evaluateVeritas({ taskClass, evidenceScore, checks: execution?.checks || {} });
+}

package.json

@@ -6,7 +6,8 @@
   "type": "module",
   "scripts": {
     "test": "node tests/smoke.mjs && node harness/test-orchestrator.mjs",
-    "check": "node --check app.js && node --check daemon/server.mjs"
+    "check": "node --check app.js && node --check daemon/server.mjs && node --check harness/orchestrator.mjs && node --check harness/checks.mjs",
+    "veritas": "node harness/run-veritas.mjs"
   },
   "engines": {
     "node": ">=20"