Add universal Veritas development harness

README.md

@@ -33,6 +33,12 @@ See `runtime/README.md` and `models/manifest.json` for the adapter contract and
 
 `daemon/server.mjs` is the first runnable native boundary for workspace and Git operations. It binds to loopback and exposes only bounded read-only endpoints. `desktop/README.md` defines the Tauri shell plan and acceptance gates; no compiled desktop binary is claimed in this pre-production release.
 
+## Universal Harness
+
+`harness/` contains the model-independent closed loop: guard, retrieve, plan, propose, verify, revise, test, review, and learn. Liquid is assigned to reasoning and verification; Qwen Coder is assigned to patch generation. The harness does not mutate model weights and never lets a model approve or apply its own changes.
+
+The original AIDE Developer's Credo and role-specific SOP cards live in `harness/credo.md` and `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.
+
 ## 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

@@ -0,0 +1,37 @@
+# AIDE Universal Harness
+
+The harness is the layer that makes every connected model safer and more useful. It does not secretly retrain weights. It improves system behavior through curated context, role-specific prompts, deterministic tools, external verification, calibrated feedback, and reversible execution.
+
+## Closed Loop
+
+```text
+intake -> guard -> retrieve -> plan -> propose -> verify -> revise -> test -> review -> learn
+```
+
+- **Intake:** normalize the task, workspace, permissions, and success criteria.
+- **Guard:** reject prompt injection, unsafe paths, secret exposure, and unapproved network actions.
+- **Retrieve:** select only relevant files, symbols, tests, docs, and prior decisions within a context budget.
+- **Plan:** use the reasoning model to create constraints and a bounded checklist.
+- **Propose:** use the coding model to emit a structured patch or artifact, never direct writes.
+- **Verify:** use deterministic parsers, tests, linters, type checkers, Git diff checks, and a separate verifier model.
+- **Revise:** allow a small fixed number of revisions, then stop and request human direction.
+- **Test:** run only approved tasks in a sandbox and attach raw output to the trace.
+- **Review:** show claims, evidence, diff, permissions, and verification result before applying.
+- **Learn:** store anonymized outcome metadata and failures locally for prompt/eval improvement; never silently modify weights.
+
+## Guarantees
+
+- One model cannot approve its own work.
+- The harness owns tools, permissions, context, cancellation, budgets, and audit records.
+- Every patch is atomic, reversible, and user-approved.
+- Low confidence or failed verification produces abstention, not fabricated success.
+- Models can be swapped without changing the workflow.
+
+## Model Roles
+
+- `reason`: Liquid thinking model for requirements, architecture, research, and test plans.
+- `build`: Qwen Coder for code and unified diffs.
+- `verify`: Liquid or another independent verifier for evidence and failure analysis.
+- `fast`: optional small model for autocomplete and classification.
+
+See `orchestrator.mjs` and `policy.json` for the executable contract.

harness/credo.md

@@ -0,0 +1,22 @@
+# AIDE Developer's Credo
+
+This is an original engineering code inspired by broad themes of disciplined craft, loyalty to the people protected by the work, keeping one's word, and earning trust through action. It is not a reproduction or quotation of the Mandalorian creed.
+
+1. **Protect the user.** Do not leak source, secrets, identity, or control of the device.
+2. **Keep the contract.** State what was done, what was not done, and what remains uncertain.
+3. **Earn trust through evidence.** A model's confidence is not proof; tests, compilers, signatures, and sources are proof.
+4. **Finish the procedure.** Follow the task SOP, record the result, and stop when a gate fails.
+5. **Guard the vulnerable boundary.** Treat untrusted files, prompts, tools, plugins, dependencies, and network peers as hostile until checked.
+6. **Carry the work forward.** Make changes reviewable, reversible, documented, and usable by the next developer.
+7. **Adapt without abandoning principles.** Models, runtimes, relays, and payment providers may change; safety, privacy, and honesty do not.
+8. **Never confuse output with accomplishment.** A generated answer is only a proposal until the Veritas layer validates it.
+
+## Model Practice
+
+Every model follows a short role card instead of re-learning the whole system prompt:
+
+- **Reasoner:** identify constraints, evidence, risks, and test criteria; do not edit.
+- **Builder:** produce the smallest structured patch; do not claim execution.
+- **Verifier:** attack assumptions and inspect evidence; do not approve its own work.
+- **Operator:** execute only allowlisted deterministic tools after approval.
+- **Archivist:** record provenance, checksums, decisions, and failures; do not alter history.

harness/orchestrator.mjs

@@ -0,0 +1,81 @@
+import { evaluateVeritas } from './veritas.mjs';
+
+const DEFAULT_POLICY = Object.freeze({
+  max_turns: 4,
+  max_context_bytes: 120000,
+  max_patch_bytes: 200000,
+  require_human_approval: true,
+  allow_network: false
+});
+
+function requireProvider(providers, role) {
+  const provider = providers[role];
+  if (!provider || typeof provider.complete !== 'function') {
+    throw new Error(`missing provider for role: ${role}`);
+  }
+  return provider;
+}
+
+function bounded(value, max, label) {
+  const text = String(value ?? '');
+  if (Buffer.byteLength(text) > max) throw new Error(`${label} exceeds harness budget`);
+  return text;
+}
+
+export function createHarness({ providers, tools = {}, policy = {} }) {
+  const rules = { ...DEFAULT_POLICY, ...policy };
+  return {
+    async run(task, context = {}) {
+      const goal = bounded(task, rules.max_context_bytes, 'task');
+      const trace = [{ stage: 'intake', status: 'accepted' }];
+      if (!goal.trim()) throw new Error('task is empty');
+      if (rules.allow_network !== false && tools.network) throw new Error('network policy must be explicit');
+
+      const reason = requireProvider(providers, 'reason');
+      const plan = await reason.complete({
+        role: 'reason',
+        instruction: 'Return constraints, risks, files to inspect, and a test checklist. Do not edit files.',
+        task: goal,
+        context: bounded(JSON.stringify(context), rules.max_context_bytes, 'context')
+      });
+      trace.push({ stage: 'plan', status: 'complete', bytes: Buffer.byteLength(String(plan)) });
+
+      const builder = requireProvider(providers, 'build');
+      const patch = bounded(await builder.complete({
+        role: 'build',
+        instruction: 'Return a unified diff only. Do not claim tests passed. Do not write files.',
+        task: goal,
+        plan: bounded(plan, rules.max_context_bytes, 'plan')
+      }), rules.max_patch_bytes, 'patch');
+      trace.push({ stage: 'propose', status: 'complete', bytes: Buffer.byteLength(patch) });
+
+      const verifier = requireProvider(providers, 'verify');
+      const verdict = await verifier.complete({
+        role: 'verify',
+        instruction: 'Return exactly APPROVE, REJECT, or NEEDS-EVIDENCE followed by concrete reasons. Do not edit files.',
+        task: goal,
+        plan,
+        patch
+      });
+      const approved = /^\s*APPROVE\b/i.test(String(verdict));
+      const veritas = 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 {
+        status: approved && veritas.passed && !rules.require_human_approval ? 'ready-for-apply' : 'awaiting-human-approval',
+        plan,
+        patch,
+        verdict,
+        veritas,
+        trace,
+        apply: async () => {
+          throw new Error('apply is owned by the permission-gated daemon, not the model harness');
+        }
+      };
+    }
+  };
+}

harness/policy.json

@@ -0,0 +1,14 @@
+{
+  "schema_version": "1.0",
+  "max_turns": 4,
+  "max_context_bytes": 120000,
+  "max_patch_bytes": 200000,
+  "require_human_approval": true,
+  "allow_network": false,
+  "allow_untrusted_commands": false,
+  "self_approval_forbidden": true,
+  "revision_policy": "stop-after-budget",
+  "verification": ["patch-parse", "path-boundary", "format", "tests", "git-diff"],
+  "feedback_storage": "local-only",
+  "weights_mutated_by_harness": false
+}

harness/sops.json

@@ -0,0 +1,17 @@
+{
+  "schema_version": "1.0",
+  "credo": "harness/credo.md",
+  "roles": {
+    "reason": {"sop": "requirements-and-plan", "must": ["identify-goal", "list-constraints", "cite-workspace-evidence", "define-tests"], "must_not": ["write-files", "claim-success"]},
+    "build": {"sop": "minimal-patch", "must": ["preserve-user-edits", "emit-unified-diff", "list-assumptions"], "must_not": ["execute-commands", "hide-files", "claim-tests-passed"]},
+    "verify": {"sop": "adversarial-review", "must": ["check-diff", "check-evidence", "check-security", "request-missing-proof"], "must_not": ["approve-own-output", "invent-test-results"]},
+    "operator": {"sop": "safe-execution", "must": ["check-approval", "check-path", "capture-output", "support-cancel"], "must_not": ["use-network-by-default", "read-secrets", "run-unbounded-commands"]},
+    "archivist": {"sop": "provenance-record", "must": ["record-revision", "record-checksum", "record-result", "record-failure"], "must_not": ["rewrite-history", "omit-negative-results"]}
+  },
+  "task_classes": {
+    "explanation": {"veritas_threshold": 0.9, "requires": ["evidence-or-explicit-uncertainty"]},
+    "code-change": {"veritas_threshold": 0.9, "requires": ["patch-parse", "path-boundary", "compile-or-typecheck", "tests", "diff-review"]},
+    "security-or-publish": {"veritas_threshold": 0.98, "requires": ["independent-review", "license-check", "checksum", "reproducible-artifact", "human-approval"]},
+    "payment-or-identity": {"veritas_threshold": 0.98, "requires": ["human-approval", "provider-confirmation", "no-custody"]}
+  }
+}

harness/test-orchestrator.mjs

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+import { createHarness } from './orchestrator.mjs';
+
+const calls = [];
+const provider = role => ({ complete: async input => {
+  calls.push({ role, input });
+  if (role === 'reason') return 'constraints: preserve API; tests: npm test';
+  if (role === 'build') return 'diff --git a/a b/a\n+safe change';
+  return 'APPROVE: diff is bounded; run tests before apply';
+}});
+
+const harness = createHarness({ providers: { reason: provider('reason'), build: provider('build'), verify: provider('verify') } });
+const result = await harness.run('Improve the provider router', { files: ['router.ts'] });
+assert.equal(result.status, 'awaiting-human-approval');
+assert.equal(result.trace.length, 5);
+assert.equal(calls.length, 3);
+assert.equal(result.veritas.status, 'abstain-needs-evidence');
+await assert.rejects(result.apply(), /permission-gated daemon/);
+console.log('universal harness test passed');

harness/veritas.mjs

@@ -0,0 +1,21 @@
+const THRESHOLDS = Object.freeze({
+  explanation: 0.90,
+  'code-change': 0.90,
+  'security-or-publish': 0.98,
+  'payment-or-identity': 0.98
+});
+
+export function evaluateVeritas({ taskClass = 'code-change', evidenceScore = 0, checks = {} } = {}) {
+  const threshold = THRESHOLDS[taskClass] ?? THRESHOLDS['code-change'];
+  const failed = Object.entries(checks).filter(([, result]) => result !== true).map(([name]) => name);
+  const score = Math.max(0, Math.min(1, Number(evidenceScore) || 0));
+  const passed = score >= threshold && failed.length === 0;
+  return {
+    passed,
+    status: passed ? 'verified' : 'abstain-needs-evidence',
+    score,
+    threshold,
+    failed_checks: failed,
+    rule: 'Model confidence is not evidence. A failed deterministic gate blocks final output.'
+  };
+}

package.json

@@ -5,7 +5,7 @@
   "description": "Local-first sovereign development workbench",
   "type": "module",
   "scripts": {
-    "test": "node tests/smoke.mjs",
+    "test": "node tests/smoke.mjs && node harness/test-orchestrator.mjs",
     "check": "node --check app.js && node --check daemon/server.mjs"
   },
   "engines": {