harness-everything 0.2.2 → 0.3.6

package/opencode-plugin/hooks/post-edit.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Post-Edit Verification Hook
+ * 
+ * Enforces verification after file edits in opencode.
+ * This hook runs after every Edit or Write tool use and:
+ * 1. Records that an edit occurred
+ * 2. Blocks completion until verification runs
+ * 3. Logs compliance status
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.harness-state');
+const STATE_FILE = path.join(STATE_DIR, 'edit-state.json');
+
+// Ensure state directory exists
+if (!fs.existsSync(STATE_DIR)) {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+  } catch (e) {
+    // Ignore parse errors
+  }
+  return {
+    lastEditTime: null,
+    verificationPending: false,
+    editsSinceVerification: 0,
+    sessionStart: Date.now()
+  };
+}
+
+function saveState(state) {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function main() {
+  const state = loadState();
+  
+  // Record edit
+  state.lastEditTime = Date.now();
+  state.verificationPending = true;
+  state.editsSinceVerification++;
+  
+  saveState(state);
+  
+  // Output enforcement message
+  console.log(JSON.stringify({
+    hook: 'post-edit-verification',
+    action: 'record',
+    editsSinceVerification: state.editsSinceVerification,
+    message: `Edit recorded. ${state.editsSinceVerification} edit(s) since last verification. Run verification before completing.`
+  }));
+}
+
+main();

package/opencode-plugin/hooks/pre-complete.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Pre-Complete Verification Gate
+ * 
+ * Blocks completion until verification runs after edits.
+ * This hook runs before the agent claims work is done and:
+ * 1. Checks if verification is pending
+ * 2. Blocks completion if verification hasn't run
+ * 3. Allows completion if verification passed or no edits occurred
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.harness-state');
+const STATE_FILE = path.join(STATE_DIR, 'edit-state.json');
+
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+  } catch (e) {
+    // Ignore parse errors
+  }
+  return {
+    lastEditTime: null,
+    verificationPending: false,
+    editsSinceVerification: 0,
+    sessionStart: Date.now()
+  };
+}
+
+function saveState(state) {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function main() {
+  const state = loadState();
+  
+  // Check if verification is pending
+  if (state.verificationPending && state.editsSinceVerification > 0) {
+    // Block completion
+    console.log(JSON.stringify({
+      hook: 'pre-complete-verification',
+      action: 'block',
+      reason: 'verification_pending',
+      editsSinceVerification: state.editsSinceVerification,
+      message: `Cannot complete: ${state.editsSinceVerification} edit(s) since last verification. Run verification first.`,
+      instructions: 'Run verification: node .harness-src/opencode-plugin/hooks/verify.js'
+    }));
+    
+    // Exit with non-zero to block
+    process.exit(1);
+  }
+  
+  // Allow completion
+  console.log(JSON.stringify({
+    hook: 'pre-complete-verification',
+    action: 'allow',
+    message: 'Verification complete or no edits pending.'
+  }));
+}
+
+main();

package/opencode-plugin/hooks/verify.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * Verification Runner Hook
+ * 
+ * Runs verification commands and updates state.
+ * This hook runs available verification commands (npm test, lint, build) and:
+ * 1. Detects available scripts from package.json
+ * 2. Executes only available verification commands
+ * 3. Updates state to reflect verification status
+ * 4. Logs verification results
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const STATE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.harness-state');
+const STATE_FILE = path.join(STATE_DIR, 'edit-state.json');
+
+// Ensure state directory exists
+if (!fs.existsSync(STATE_DIR)) {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+  } catch (e) {
+    // Ignore parse errors
+  }
+  return {
+    lastEditTime: null,
+    verificationPending: false,
+    editsSinceVerification: 0,
+    sessionStart: Date.now()
+  };
+}
+
+function saveState(state) {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function getAvailableScripts() {
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return [];
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.scripts || {};
+  } catch {
+    return [];
+  }
+}
+
+function runVerification(command) {
+  try {
+    execSync(command, { 
+      stdio: 'pipe',
+      timeout: 60000 // 60 second timeout
+    });
+    return { success: true, command };
+  } catch (e) {
+    return { 
+      success: false, 
+      command,
+      error: e.message.slice(0, 200)
+    };
+  }
+}
+
+function main() {
+  const state = loadState();
+  
+  // Get available scripts from package.json
+  const scripts = getAvailableScripts();
+  
+  // Verification commands to try (only if script exists)
+  const possibleCommands = [
+    { cmd: 'npm test', script: 'test' },
+    { cmd: 'npm run lint', script: 'lint' },
+    { cmd: 'npm run build', script: 'build' }
+  ];
+  
+  const commands = possibleCommands
+    .filter(c => scripts[c.script])
+    .map(c => c.cmd);
+  
+  // If no verification scripts available, check if we should skip
+  if (commands.length === 0) {
+    // No npm verification available - check if this is a non-code task
+    // Allow completion without npm verification for doc-only tasks
+    console.log(JSON.stringify({
+      hook: 'verification-runner',
+      action: 'verify',
+      allPassed: true,
+      results: [],
+      message: 'No npm verification scripts available. Skipping npm verification (non-code task assumed).',
+      skipped: true
+    }));
+    return;
+  }
+  
+  const results = [];
+  let allPassed = true;
+  
+  for (const cmd of commands) {
+    const result = runVerification(cmd);
+    results.push(result);
+    if (!result.success) {
+      allPassed = false;
+    }
+  }
+  
+  // Update state
+  state.verificationPending = !allPassed;
+  state.editsSinceVerification = allPassed ? 0 : state.editsSinceVerification;
+  state.lastVerificationTime = Date.now();
+  state.verificationResults = results;
+  
+  saveState(state);
+  
+  // Output results
+  console.log(JSON.stringify({
+    hook: 'verification-runner',
+    action: 'verify',
+    allPassed,
+    results: results.map(r => ({
+      command: r.command,
+      success: r.success
+    })),
+    message: allPassed 
+      ? 'All available verification passed. You can now complete.'
+      : 'Some verification failed. Fix issues before completing.'
+  }));
+}
+
+main();

package/opencode-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "harness-enforcement",
+  "description": "Enforcement plugin for Harness skills - adds hard gates for verification and circuit breaker in opencode",
+  "version": "0.1.0",
+  "author": "Miya Daniel",
+  "license": "Apache-2.0",
+  "hooks": {
+    "postEdit": "hooks/post-edit.js",
+    "preComplete": "hooks/pre-complete.js"
+  },
+  "config": {
+    "verificationRequired": true,
+    "circuitBreakerEnabled": true,
+    "maxRetries": 3,
+    "verificationCommands": ["npm test", "npm run lint", "npm run build"]
+  }
+}

package/opencode-plugin/test-hook-firing.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+/**
+ * Hook Firing Verification Test
+ * 
+ * Tests that each opencode plugin hook fires correctly by:
+ * 1. Directly invoking each hook with test inputs
+ * 2. Verifying expected outputs and state changes
+ * 3. Reporting hook fire rate
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const HOOKS_DIR = path.join(__dirname, 'hooks');
+const STATE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.harness-state');
+
+const HOOKS = [
+  { name: 'post-edit', file: 'post-edit.js', input: null },
+  { name: 'pre-complete', file: 'pre-complete.js', input: null },
+  { name: 'circuit-breaker', file: 'circuit-breaker.js', input: 'Error: test failure signature' },
+  { name: 'compliance', file: 'compliance.js', input: JSON.stringify({ hook: 'post-edit-verification' }) },
+  { name: 'verify', file: 'verify.js', input: null }
+];
+
+function cleanState() {
+  const files = ['edit-state.json', 'circuit-breaker.json', 'compliance.json'];
+  for (const f of files) {
+    const p = path.join(STATE_DIR, f);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+}
+
+function runHook(hook, testInput) {
+  return new Promise((resolve) => {
+    const hookPath = path.join(HOOKS_DIR, hook.file);
+    const child = spawn('node', [hookPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, NODE_ENV: 'test' }
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (testInput) {
+      child.stdin.write(testInput);
+      child.stdin.end();
+    }
+
+    child.stdout.on('data', (data) => stdout += data);
+    child.stderr.on('data', (data) => stderr += data);
+
+    child.on('close', (code) => {
+      resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() });
+    });
+
+    child.on('error', (err) => {
+      resolve({ code: -1, stdout: '', stderr: err.message });
+    });
+  });
+}
+
+function parseOutput(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    return { raw: output };
+  }
+}
+
+async function testHookFiring() {
+  console.log('=== Hook Firing Verification Test ===\n');
+  
+  // Clean state before each test
+  cleanState();
+  
+  let passed = 0;
+  let total = 0;
+
+  for (const hook of HOOKS) {
+    total++;
+    console.log(`Testing ${hook.name}...`);
+    
+    const result = await runHook(hook, hook.input);
+    const parsed = parseOutput(result.stdout);
+    
+    const success = result.code === 0 || result.code === 1 || result.code === 2;
+    const hasHookField = parsed.hook !== undefined;
+    
+    if (success && hasHookField) {
+      console.log(`  ✅ PASS - Hook fired (exit=${result.code}, hook=${parsed.hook})`);
+      passed++;
+    } else {
+      console.log(`  ❌ FAIL - Hook did not fire properly`);
+      console.log(`     Exit code: ${result.code}`);
+      console.log(`     Stdout: ${result.stdout}`);
+      console.log(`     Stderr: ${result.stderr}`);
+    }
+  }
+
+  // Test circuit breaker trip sequence
+  console.log('\n--- Circuit Breaker Sequence Test ---');
+  cleanState();
+  
+  let cbTrips = 0;
+  for (let i = 1; i <= 4; i++) {
+    const result = await runHook(HOOKS[2], 'Error: repeated failure signature');
+    const parsed = parseOutput(result.stdout);
+    
+    if (result.code === 2) {
+      cbTrips++;
+      console.log(`  Trip ${i}: ${parsed.action} (${parsed.reason || 'N/A'}) count=${parsed.count}`);
+    }
+  }
+  
+  // Now simulate reflection and test hard lock
+  const breakerFile = path.join(STATE_DIR, 'circuit-breaker.json');
+  if (fs.existsSync(breakerFile)) {
+    const breakerState = JSON.parse(fs.readFileSync(breakerFile, 'utf8'));
+    // Set lastReflection to simulate zoom-out reflection
+    breakerState.lastReflection = Date.now();
+    fs.writeFileSync(breakerFile, JSON.stringify(breakerState, null, 2));
+  }
+  
+  // 5th trip should hard lock
+  const hardLockResult = await runHook(HOOKS[2], 'Error: repeated failure signature');
+  const hardLockParsed = parseOutput(hardLockResult.stdout);
+  console.log(`  Trip 5 (after reflection): ${hardLockParsed.action} (${hardLockParsed.reason || 'N/A'})`);
+  
+  if (hardLockResult.code === 2 && hardLockParsed.action === 'hard_lock') {
+    console.log('  ✅ Circuit breaker hard-locks after reflection');
+    passed++;
+  } else {
+    console.log('  ❌ Circuit breaker did not hard-lock after reflection');
+  }
+  total++;
+
+  // Test compliance aggregation
+  console.log('\n--- Compliance Aggregation Test ---');
+  cleanState();
+  
+  // Simulate a few events
+  await runHook(HOOKS[3], JSON.stringify({ hook: 'post-edit-verification' }));
+  await runHook(HOOKS[3], JSON.stringify({ hook: 'pre-complete-verification', action: 'block' }));
+  await runHook(HOOKS[3], JSON.stringify({ hook: 'verification-runner', allPassed: true }));
+  
+  const compResult = await runHook(HOOKS[3], JSON.stringify({ hook: 'circuit-breaker', action: 'force_reflection' }));
+  const compParsed = parseOutput(compResult.stdout);
+  
+  if (compParsed.metrics && compParsed.metrics.totalEdits > 0) {
+    console.log('  ✅ Compliance tracking works');
+    console.log(`     ${compParsed.message}`);
+    passed++;
+  } else {
+    console.log('  ❌ Compliance tracking failed');
+    console.log(`     Output: ${compResult.stdout}`);
+  }
+  total++;
+
+  // Test verification runner
+  console.log('\n--- Verification Runner Test ---');
+  cleanState();
+  // First do an edit to set pending state
+  await runHook(HOOKS[0]);
+  // Then run verification
+  const verifyResult = await runHook(HOOKS[4]);
+  const verifyParsed = parseOutput(verifyResult.stdout);
+  
+  if (verifyParsed.hook === 'verification-runner') {
+    console.log('  ✅ Verification runner fires');
+    console.log(`     Result: ${verifyParsed.message}`);
+    passed++;
+  } else {
+    console.log('  ❌ Verification runner failed');
+    console.log(`     Output: ${verifyResult.stdout}`);
+  }
+  total++;
+
+  // Summary
+  const rate = (passed / total * 100).toFixed(1);
+  console.log(`\n=== SUMMARY ===`);
+  console.log(`Hooks tested: ${total}`);
+  console.log(`Passed: ${passed}`);
+  console.log(`Fire rate: ${rate}%`);
+  
+  if (rate >= 95) {
+    console.log('\n🎉 HOOK FIRING VERIFICATION PASSED (≥95%)');
+    process.exit(0);
+  } else {
+    console.log('\n❌ HOOK FIRING VERIFICATION FAILED (<95%)');
+    process.exit(1);
+  }
+}
+
+testHookFiring().catch(err => {
+  console.error('Test error:', err);
+  process.exit(1);
+});

package/package.json

@@ -1,22 +1,50 @@
-{
-  "name": "harness-everything",
-  "version": "0.2.2",
-  "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
-  "main": "harness-everything/scripts/bootstrap.js",
-  "bin": {
-    "harness": "./bin/cli.js"
-  },
-  "scripts": {
-    "test": "node self-evolve/scripts/self-regression.js",
-    "self-regression": "node self-evolve/scripts/self-regression.js",
-    "test:mechanism": "node eval-framework/mechanism-test.js",
-    "harness:reset": "node hooks/scripts/reset-circuit-breaker.js"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "author": "Miya Daniel | Harness Core Team",
-  "license": "Apache-2.0",
-  "dependencies": {},
-  "devDependencies": {}
-}
+{
+  "name": "harness-everything",
+  "version": "0.3.6",
+  "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
+  "main": "harness-everything/scripts/bootstrap.js",
+  "bin": {
+    "harness": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "node self-evolve/scripts/self-regression.js",
+    "self-regression": "node self-evolve/scripts/self-regression.js",
+    "test:mechanism": "node ci/mechanism-test.js",
+    "test:consistency": "node ci/consistency-check.js",
+    "test:references": "node ci/reference-check.js",
+    "test:release": "node ci/release-consistency-check.js --tag v0.3.3-beta",
+    "test:install": "node scripts/verify-install.js",
+    "test:collision": "node ci/description-collision.js",
+    "test:routing:skills": "node ci/skill-routing-check.js",
+    "test:routing": "node ci/routing-check.js",
+    "benchmark:scaffold": "node benchmarks/run.js scaffold",
+    "benchmark:status": "node benchmarks/run.js status",
+    "eval:behavioral": "node behavioral-evals/run.js run",
+    "eval:behavioral:validate": "node behavioral-evals/run.js validate",
+    "eval:behavioral:plugin": "node behavioral-evals/run-with-plugin.js run",
+    "test:ab": "node ci/ab-test-harness.js validate",
+    "test:ab:run": "node ci/ab-test-harness.js run",
+    "harness:reset": "node hooks/scripts/reset-circuit-breaker.js",
+    "prepare": "husky install",
+    "commitlint": "commitlint --edit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "Miya Daniel",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dyphn1/Harness-everything.git"
+  },
+  "homepage": "https://github.com/dyphn1/Harness-everything#readme",
+  "bugs": {
+    "url": "https://github.com/dyphn1/Harness-everything/issues"
+  },
+  "devDependencies": {
+    "js-yaml": "^5.4.1",
+    "@commitlint/cli": "^19.0.0",
+    "@commitlint/config-conventional": "^19.0.0",
+    "husky": "^9.0.0"
+  }
+}

package/references/definition-of-done.md

@@ -0,0 +1,67 @@
+# Definition of Done
+
+A standing, project-wide bar that every change must clear before it counts as done. Unlike acceptance criteria, which vary per task and answer "did we build the right thing?", the Definition of Done is the same every time and answers "is this finished to our standard?". Use it as the final gate in `planning-and-task-breakdown`, `incremental-implementation`, and `shipping-and-launch`.
+
+## Definition of Done vs. Acceptance Criteria
+
+| | Acceptance Criteria | Definition of Done |
+|---|---|---|
+| Scope | Specific to one task or spec | Applies to every increment |
+| Changes | Different for each item | Fixed and reused |
+| Answers | "Did we build *this thing*?" | "Is it *ready*?" |
+| Owner | Defined when planning the task | Defined once for the project |
+| Example | "User can reset password via email link" | "Tests pass, no regressions, docs updated" |
+
+The two are complementary. A task is done only when **its** acceptance criteria are met **and** the standing Definition of Done is satisfied. Skipping either leaves work that looks finished but is not.
+
+## The Standing Checklist
+
+Apply this to every change before declaring it done.
+
+### Correctness
+- [ ] All acceptance criteria for the task are met
+- [ ] Code runs and behaves as intended, verified at runtime, not just compiled or typechecked
+- [ ] New behavior is covered by tests that fail without the change and pass with it
+- [ ] Existing tests still pass; no regressions introduced
+- [ ] Edge cases and error paths are handled, not just the happy path
+
+### Quality
+- [ ] Code reveals intent through naming and structure; no comments needed to explain *what* it does
+- [ ] No duplicated business logic
+- [ ] No dead code, debug output, or commented-out blocks left behind
+- [ ] Changes are scoped to the task; no unrelated refactors snuck in
+- [ ] Linting and formatting pass
+
+The depth behind these items lives in `code-review-and-quality` (the five-axis review) and `code-simplification` (reducing complexity without changing behavior).
+
+### Integration
+- [ ] Change works with the rest of the system, not just in isolation
+- [ ] Database migrations, config changes, and feature flags are accounted for
+- [ ] Backward compatibility considered for any public interface or API change
+
+### Documentation
+- [ ] Public interfaces, APIs, and user-facing behavior are documented
+- [ ] Architectural decisions worth preserving are recorded (see `documentation-and-adrs`)
+- [ ] Documentation describes the current state in timeless language, not the change history
+
+### Ship-readiness
+- [ ] Security implications reviewed for any untrusted input, auth, or data handling (see `security-and-hardening`)
+- [ ] Observability in place for new critical paths (logs, metrics, traces) (see `observability-and-instrumentation`)
+- [ ] Rollback path exists for anything risky (see `shipping-and-launch`)
+- [ ] The human has reviewed and approved before merge or deploy
+
+## How to Apply
+
+- **Per task**: confirm the Correctness and Quality sections before checking the task off.
+- **Per feature**: confirm Integration and Documentation before considering the feature complete.
+- **Per release**: the full checklist is the floor; `shipping-and-launch` adds the deploy-specific gates on top.
+
+Tailor the list to the project once, then reuse it unchanged. A Definition of Done that is renegotiated every sprint is not a Definition of Done.
+
+## Red Flags
+
+- "It's done, I just haven't run it yet": unverified work is not done.
+- "Tests pass" used as a synonym for done while docs, regressions, or runtime verification are skipped.
+- A different bar applied depending on deadline pressure.
+- Acceptance criteria treated as the whole bar, with no standing quality floor.
+- "Done" declared before human review on changes that need it.