The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
fix: route continuous learning observe hooks through node
Affaan Mustafa3fadc3780261
diff --git a/docs/ARCHITECTURE-IMPROVEMENTS.md b/docs/ARCHITECTURE-IMPROVEMENTS.mdindex f8a5e605e..5a2803e56 100644--- a/docs/ARCHITECTURE-IMPROVEMENTS.md+++ b/docs/ARCHITECTURE-IMPROVEMENTS.md@@ -110,7 +110,7 @@ This document captures architect-level improvements for the Everything Claude Co### 5.1 Hook Runtime Consistency-**Issue:** Most hooks invoke Node scripts via `run-with-flags.js`; one path uses `run-with-flags-shell.sh` + `observe.sh`. The mixed runtime is documented but could be simplified over time.+**Issue:** Hooks should keep a consistent Node-mode dispatch surface. Continuous-learning observation now dispatches through `run-with-flags.js` and `observe-runner.js`, which delegates to the existing `observe.sh` implementation without exposing a shell-mode hook entry.**Recommendation:**diff --git a/hooks/README.md b/hooks/README.mdindex d712d94f0..0d0383261 100644--- a/hooks/README.md+++ b/hooks/README.md@@ -228,7 +228,7 @@ Async hooks run in the background. They cannot block tool execution.## Cross-Platform Notes-Hook logic is implemented in Node.js scripts for cross-platform behavior on Windows, macOS, and Linux. A small number of shell wrappers are retained for continuous-learning observer hooks; those wrappers are profile-gated and have Windows-safe fallback behavior.+Hook logic is implemented in Node.js scripts for cross-platform behavior on Windows, macOS, and Linux. The continuous-learning observer is exposed as a Node-mode hook and delegates to its existing `observe.sh` implementation through a profile-gated runner with Windows-safe fallback behavior.## Relateddiff --git a/hooks/hooks.json b/hooks/hooks.jsonindex ceb3e6c8a..5c5aad843 100644--- a/hooks/hooks.json+++ b/hooks/hooks.json@@ -40,7 +40,7 @@"hooks": [{"type": "command",- "command": "node -e \"const p=require('path');const r=(()=>{var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var p=require('path'),f=require('fs'),h=require('os').homedir(),d=p.join(h,'.claude'),q=p.join('scripts','lib','utils.js');if(f.existsSync(p.join(d,q)))return d;for(var s of [[\\\"ecc\\\"],[\\\"ecc@ecc\\\"],[\\\"marketplace\\\",\\\"ecc\\\"],[\\\"everything-claude-code\\\"],[\\\"everything-claude-code@everything-claude-code\\\"],[\\\"marketplace\\\",\\\"everything-claude-code\\\"]]){var l=p.join(d,'plugins',...s);if(f.existsSync(p.join(l,q)))return l}try{for(var g of [\\\"ecc\\\",\\\"everything-claude-code\\\"]){var b=p.join(d,'plugins','cache',g);for(var o of f.readdirSync(b,{withFileTypes:true})){if(!o.isDirectory())continue;for(var v of f.readdirSync(p.join(b,o.name),{withFileTypes:true})){if(!v.isDirectory())continue;var c=p.join(b,o.name,v.name);if(f.existsSync(p.join(c,q)))return c}}}}catch(x){}return d})();const s=p.join(r,'scripts/hooks/plugin-hook-bootstrap.js');process.env.CLAUDE_PLUGIN_ROOT=r;process.argv.splice(1,0,s);require(s)\" shell scripts/hooks/run-with-flags-shell.sh pre:observe skills/continuous-learning-v2/hooks/observe.sh standard,strict",+ "command": "node -e \"const p=require('path');const r=(()=>{var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var p=require('path'),f=require('fs'),h=require('os').homedir(),d=p.join(h,'.claude'),q=p.join('scripts','lib','utils.js');if(f.existsSync(p.join(d,q)))return d;for(var s of [[\\\"ecc\\\"],[\\\"ecc@ecc\\\"],[\\\"marketplace\\\",\\\"ecc\\\"],[\\\"everything-claude-code\\\"],[\\\"everything-claude-code@everything-claude-code\\\"],[\\\"marketplace\\\",\\\"everything-claude-code\\\"]]){var l=p.join(d,'plugins',...s);if(f.existsSync(p.join(l,q)))return l}try{for(var g of [\\\"ecc\\\",\\\"everything-claude-code\\\"]){var b=p.join(d,'plugins','cache',g);for(var o of f.readdirSync(b,{withFileTypes:true})){if(!o.isDirectory())continue;for(var v of f.readdirSync(p.join(b,o.name),{withFileTypes:true})){if(!v.isDirectory())continue;var c=p.join(b,o.name,v.name);if(f.existsSync(p.join(c,q)))return c}}}}catch(x){}return d})();const s=p.join(r,'scripts/hooks/plugin-hook-bootstrap.js');process.env.CLAUDE_PLUGIN_ROOT=r;process.argv.splice(1,0,s);require(s)\" node scripts/hooks/run-with-flags.js pre:observe scripts/hooks/observe-runner.js standard,strict","async": true,"timeout": 10}@@ -212,7 +212,7 @@"hooks": [{"type": "command",- "command": "node -e \"const p=require('path');const r=(()=>{var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var p=require('path'),f=require('fs'),h=require('os').homedir(),d=p.join(h,'.claude'),q=p.join('scripts','lib','utils.js');if(f.existsSync(p.join(d,q)))return d;for(var s of [[\\\"ecc\\\"],[\\\"ecc@ecc\\\"],[\\\"marketplace\\\",\\\"ecc\\\"],[\\\"everything-claude-code\\\"],[\\\"everything-claude-code@everything-claude-code\\\"],[\\\"marketplace\\\",\\\"everything-claude-code\\\"]]){var l=p.join(d,'plugins',...s);if(f.existsSync(p.join(l,q)))return l}try{for(var g of [\\\"ecc\\\",\\\"everything-claude-code\\\"]){var b=p.join(d,'plugins','cache',g);for(var o of f.readdirSync(b,{withFileTypes:true})){if(!o.isDirectory())continue;for(var v of f.readdirSync(p.join(b,o.name),{withFileTypes:true})){if(!v.isDirectory())continue;var c=p.join(b,o.name,v.name);if(f.existsSync(p.join(c,q)))return c}}}}catch(x){}return d})();const s=p.join(r,'scripts/hooks/plugin-hook-bootstrap.js');process.env.CLAUDE_PLUGIN_ROOT=r;process.argv.splice(1,0,s);require(s)\" shell scripts/hooks/run-with-flags-shell.sh post:observe skills/continuous-learning-v2/hooks/observe.sh standard,strict",+ "command": "node -e \"const p=require('path');const r=(()=>{var e=process.env.CLAUDE_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var p=require('path'),f=require('fs'),h=require('os').homedir(),d=p.join(h,'.claude'),q=p.join('scripts','lib','utils.js');if(f.existsSync(p.join(d,q)))return d;for(var s of [[\\\"ecc\\\"],[\\\"ecc@ecc\\\"],[\\\"marketplace\\\",\\\"ecc\\\"],[\\\"everything-claude-code\\\"],[\\\"everything-claude-code@everything-claude-code\\\"],[\\\"marketplace\\\",\\\"everything-claude-code\\\"]]){var l=p.join(d,'plugins',...s);if(f.existsSync(p.join(l,q)))return l}try{for(var g of [\\\"ecc\\\",\\\"everything-claude-code\\\"]){var b=p.join(d,'plugins','cache',g);for(var o of f.readdirSync(b,{withFileTypes:true})){if(!o.isDirectory())continue;for(var v of f.readdirSync(p.join(b,o.name),{withFileTypes:true})){if(!v.isDirectory())continue;var c=p.join(b,o.name,v.name);if(f.existsSync(p.join(c,q)))return c}}}}catch(x){}return d})();const s=p.join(r,'scripts/hooks/plugin-hook-bootstrap.js');process.env.CLAUDE_PLUGIN_ROOT=r;process.argv.splice(1,0,s);require(s)\" node scripts/hooks/run-with-flags.js post:observe scripts/hooks/observe-runner.js standard,strict","async": true,"timeout": 10}diff --git a/scripts/hooks/observe-runner.js b/scripts/hooks/observe-runner.jsnew file mode 100644index 000000000..28e7f4fb0--- /dev/null+++ b/scripts/hooks/observe-runner.js@@ -0,0 +1,196 @@+#!/usr/bin/env node+'use strict';++const fs = require('fs');+const path = require('path');+const { spawnSync } = require('child_process');++const OBSERVE_RELATIVE_PATH = path.join('skills', 'continuous-learning-v2', 'hooks', 'observe.sh');+const DEFAULT_TIMEOUT_MS = 9000;++function getPluginRoot(options = {}) {+ if (options.pluginRoot && String(options.pluginRoot).trim()) {+ return String(options.pluginRoot).trim();+ }+ if (process.env.CLAUDE_PLUGIN_ROOT && process.env.CLAUDE_PLUGIN_ROOT.trim()) {+ return process.env.CLAUDE_PLUGIN_ROOT.trim();+ }+ if (process.env.ECC_PLUGIN_ROOT && process.env.ECC_PLUGIN_ROOT.trim()) {+ return process.env.ECC_PLUGIN_ROOT.trim();+ }+ return path.resolve(__dirname, '..', '..');+}++function resolveTarget(rootDir, relPath) {+ const resolvedRoot = path.resolve(rootDir);+ const resolvedTarget = path.resolve(rootDir, relPath);+ if (+ resolvedTarget !== resolvedRoot &&+ !resolvedTarget.startsWith(resolvedRoot + path.sep)+ ) {+ throw new Error(`Path traversal rejected: ${relPath}`);+ }+ return resolvedTarget;+}++function toShellPath(filePath) {+ const normalized = String(filePath || '');+ if (process.platform !== 'win32') {+ return normalized;+ }++ return normalized+ .replace(/^([A-Za-z]):[\\/]/, (_, driveLetter) => `/${driveLetter.toLowerCase()}/`)+ .replace(/\\/g, '/');+}++function findShellBinary() {+ const candidates = [];+ if (process.env.BASH && process.env.BASH.trim()) {+ candidates.push(process.env.BASH.trim());+ }++ if (process.platform === 'win32') {+ candidates.push('bash.exe', 'bash', 'sh');+ } else {+ candidates.push('bash', 'sh');+ }++ for (const candidate of candidates) {+ const probe = spawnSync(candidate, ['-c', ':'], {+ stdio: 'ignore',+ windowsHide: true+ });+ if (!probe.error) {+ return candidate;+ }+ }++ return null;+}++function getPhaseFromHookId(hookId) {+ const prefix = String(hookId || process.env.ECC_HOOK_ID || '').split(':')[0];+ return prefix === 'pre' || prefix === 'post' ? prefix : null;+}++function getTimeoutMs() {+ const parsed = Number.parseInt(process.env.ECC_OBSERVE_RUNNER_TIMEOUT_MS || '', 10);+ return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;+}++function combineStderr(stderr, message) {+ const prefix = typeof stderr === 'string' && stderr.length > 0+ ? stderr.endsWith('\n') ? stderr : `${stderr}\n`+ : '';+ return `${prefix}${message}\n`;+}++function run(raw, options = {}) {+ const input = typeof raw === 'string' ? raw : String(raw ?? '');+ const phase = getPhaseFromHookId(options.hookId);+ if (!phase) {+ return {+ stderr: '[Hook] observe runner received an unsupported hook id; skipping observation',+ exitCode: 0+ };+ }++ const pluginRoot = getPluginRoot(options);+ let observePath;+ try {+ observePath = resolveTarget(pluginRoot, OBSERVE_RELATIVE_PATH);+ } catch (error) {+ return {+ stderr: `[Hook] observe runner path resolution failed: ${error.message}`,+ exitCode: 0+ };+ }++ if (!fs.existsSync(observePath)) {+ return {+ stderr: `[Hook] observe script not found: ${observePath}`,+ exitCode: 0+ };+ }++ const shell = findShellBinary();+ if (!shell) {+ return {+ stderr: '[Hook] shell runtime unavailable; skipping continuous-learning observation',+ exitCode: 0+ };+ }++ const result = spawnSync(shell, [toShellPath(observePath), phase], {+ input,+ encoding: 'utf8',+ env: {+ ...process.env,+ CLAUDE_PLUGIN_ROOT: pluginRoot,+ ECC_PLUGIN_ROOT: pluginRoot+ },+ cwd: process.cwd(),+ timeout: getTimeoutMs(),+ windowsHide: true+ });++ const output = {+ exitCode: Number.isInteger(result.status) ? result.status : 0+ };++ if (typeof result.stdout === 'string' && result.stdout.length > 0) {+ output.stdout = result.stdout;+ }+ if (typeof result.stderr === 'string' && result.stderr.length > 0) {+ output.stderr = result.stderr;+ }++ if (result.error || result.signal || result.status === null) {+ const reason = result.error+ ? result.error.message+ : result.signal+ ? `terminated by signal ${result.signal}`+ : 'missing exit status';+ output.stderr = combineStderr(output.stderr, `[Hook] observe runner failed: ${reason}`);+ output.exitCode = 0;+ }++ return output;+}++function emitHookResult(raw, output) {+ if (output && typeof output === 'object') {+ if (output.stderr) {+ process.stderr.write(String(output.stderr).endsWith('\n') ? String(output.stderr) : `${output.stderr}\n`);+ }+ if (Object.prototype.hasOwnProperty.call(output, 'stdout')) {+ process.stdout.write(String(output.stdout ?? ''));+ } else if (!Number.isInteger(output.exitCode) || output.exitCode === 0) {+ process.stdout.write(raw);+ }+ return Number.isInteger(output.exitCode) ? output.exitCode : 0;+ }++ process.stdout.write(raw);+ return 0;+}++if (require.main === module) {+ let raw = '';+ try {+ raw = fs.readFileSync(0, 'utf8');+ } catch (_error) {+ raw = '';+ }+ const output = run(raw, { hookId: process.argv[2] || process.env.ECC_HOOK_ID });+ process.exit(emitHookResult(raw, output));+}++module.exports = {+ OBSERVE_RELATIVE_PATH,+ findShellBinary,+ getPhaseFromHookId,+ run,+ toShellPath+};diff --git a/scripts/hooks/run-with-flags.js b/scripts/hooks/run-with-flags.jsindex 1391a4541..84aed34a6 100755--- a/scripts/hooks/run-with-flags.js+++ b/scripts/hooks/run-with-flags.js@@ -137,7 +137,13 @@ async function main() {if (hookModule && typeof hookModule.run === 'function') {try {- const output = hookModule.run(raw, { truncated, maxStdin: MAX_STDIN });+ const output = hookModule.run(raw, {+ hookId,+ pluginRoot,+ scriptPath,+ truncated,+ maxStdin: MAX_STDIN+ });process.exit(emitHookResult(raw, output));} catch (runErr) {process.stderr.write(`[Hook] run() error for ${hookId}: ${runErr.message}\n`);@@ -152,6 +158,9 @@ async function main() {encoding: 'utf8',env: {...process.env,+ CLAUDE_PLUGIN_ROOT: pluginRoot,+ ECC_PLUGIN_ROOT: pluginRoot,+ ECC_HOOK_ID: hookId,ECC_HOOK_INPUT_TRUNCATED: truncated ? '1' : '0',ECC_HOOK_INPUT_MAX_BYTES: String(MAX_STDIN)},diff --git a/tests/hooks/continuous-learning-observe-runner.test.js b/tests/hooks/continuous-learning-observe-runner.test.jsnew file mode 100644index 000000000..5abb1907f--- /dev/null+++ b/tests/hooks/continuous-learning-observe-runner.test.js@@ -0,0 +1,194 @@+/**+ * Tests for continuous-learning-v2 observe hook dispatch.+ *+ * Run with: node tests/hooks/continuous-learning-observe-runner.test.js+ */++'use strict';++const assert = require('assert');+const fs = require('fs');+const os = require('os');+const path = require('path');+const { spawnSync } = require('child_process');++const repoRoot = path.resolve(__dirname, '..', '..');+const hooksJsonPath = path.join(repoRoot, 'hooks', 'hooks.json');+const runWithFlagsPath = path.join(repoRoot, 'scripts', 'hooks', 'run-with-flags.js');+const observeRunner = require(path.join(repoRoot, 'scripts', 'hooks', 'observe-runner.js'));++function test(name, fn) {+ try {+ fn();+ console.log(` \u2713 ${name}`);+ return true;+ } catch (err) {+ console.log(` \u2717 ${name}`);+ console.log(` Error: ${err.message}`);+ return false;+ }+}++function loadHook(id) {+ const hookGroups = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf8')).hooks;+ const hooks = Object.values(hookGroups).flat();+ const hook = hooks.find(candidate => candidate.id === id);+ assert.ok(hook, `Expected ${id} in hooks/hooks.json`);+ assert.ok(Array.isArray(hook.hooks), `Expected ${id} to define hook commands`);+ assert.strictEqual(hook.hooks.length, 1, `Expected ${id} to have one command`);+ return hook.hooks[0].command;+}++function withTempPluginRoot(fn) {+ const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ecc-observe-runner-'));+ try {+ fs.mkdirSync(path.join(tempRoot, 'scripts', 'hooks'), { recursive: true });+ fs.mkdirSync(path.join(tempRoot, 'scripts', 'lib'), { recursive: true });+ fs.copyFileSync(+ path.join(repoRoot, 'scripts', 'lib', 'hook-flags.js'),+ path.join(tempRoot, 'scripts', 'lib', 'hook-flags.js')+ );+ return fn(tempRoot);+ } finally {+ fs.rmSync(tempRoot, { recursive: true, force: true });+ }+}++function withEnv(vars, fn) {+ const saved = {};+ for (const [key, value] of Object.entries(vars)) {+ saved[key] = process.env[key];+ if (value === undefined) {+ delete process.env[key];+ } else {+ process.env[key] = value;+ }+ }++ try {+ return fn();+ } finally {+ for (const [key, value] of Object.entries(saved)) {+ if (value === undefined) {+ delete process.env[key];+ } else {+ process.env[key] = value;+ }+ }+ }+}++function writeFakeObserveScript(tempRoot) {+ const scriptPath = path.join(tempRoot, 'skills', 'continuous-learning-v2', 'hooks', 'observe.sh');+ fs.mkdirSync(path.dirname(scriptPath), { recursive: true });+ fs.writeFileSync(+ scriptPath,+ [+ '#!/usr/bin/env bash',+ 'input="$(cat)"',+ 'printf "phase=%s input=%s root=%s" "$1" "$input" "${CLAUDE_PLUGIN_ROOT:-}"',+ ''+ ].join('\n'),+ 'utf8'+ );+ fs.chmodSync(scriptPath, 0o755);+}++function runWithFlags(tempRoot, hookId, relScriptPath, stdin) {+ return spawnSync(process.execPath, [runWithFlagsPath, hookId, relScriptPath, 'standard,strict'], {+ input: stdin,+ encoding: 'utf8',+ env: {+ ...process.env,+ CLAUDE_PLUGIN_ROOT: tempRoot,+ ECC_HOOK_PROFILE: 'standard'+ },+ stdio: ['pipe', 'pipe', 'pipe'],+ timeout: 10000+ });+}++function runTests() {+ console.log('\n=== Testing continuous-learning observe hook dispatch ===\n');++ let passed = 0;+ let failed = 0;++ if (test('observe hooks use node-mode runner instead of shell-mode dispatch', () => {+ for (const hookId of ['pre:observe:continuous-learning', 'post:observe:continuous-learning']) {+ const command = loadHook(hookId);+ const phase = hookId.startsWith('pre:') ? 'pre:observe' : 'post:observe';++ assert.ok(command.includes(`node scripts/hooks/run-with-flags.js ${phase} scripts/hooks/observe-runner.js standard,strict`));+ assert.ok(!command.includes('shell scripts/hooks/run-with-flags-shell.sh'), `${hookId} should not use shell-mode bootstrap`);+ assert.ok(!command.includes('skills/continuous-learning-v2/hooks/observe.sh'), `${hookId} should not call observe.sh directly from hooks.json`);+ }+ })) passed++; else failed++;++ if (test('run-with-flags passes hookId to direct run exports', () => {+ withTempPluginRoot(tempRoot => {+ const scriptPath = path.join(tempRoot, 'scripts', 'hooks', 'capture-hook-id.js');+ fs.writeFileSync(+ scriptPath,+ [+ "'use strict';",+ 'module.exports.run = function run(raw, options) {',+ ' return { stdout: JSON.stringify({ raw, hookId: options.hookId, truncated: options.truncated }) };',+ '};',+ ''+ ].join('\n'),+ 'utf8'+ );++ const result = runWithFlags(tempRoot, 'post:observe', 'scripts/hooks/capture-hook-id.js', '{"ok":true}');+ assert.strictEqual(result.status, 0, result.stderr);+ const payload = JSON.parse(result.stdout);+ assert.deepStrictEqual(payload, { raw: '{"ok":true}', hookId: 'post:observe', truncated: false });+ });+ })) passed++; else failed++;++ if (test('observe-runner derives the observe phase from the hook id', () => {+ assert.strictEqual(observeRunner.getPhaseFromHookId('pre:observe'), 'pre');+ assert.strictEqual(observeRunner.getPhaseFromHookId('post:observe'), 'post');+ assert.strictEqual(observeRunner.getPhaseFromHookId('pre:observe:continuous-learning'), 'pre');+ assert.strictEqual(observeRunner.getPhaseFromHookId('unknown'), null);+ })) passed++; else failed++;++ if (test('observe-runner invokes observe.sh with phase, stdin, and plugin root', () => {+ withTempPluginRoot(tempRoot => {+ writeFakeObserveScript(tempRoot);+ const env = fs.existsSync('/bin/sh') ? { BASH: '/bin/sh' } : {};+ withEnv(env, () => {+ const output = observeRunner.run('payload', {+ hookId: 'pre:observe',+ pluginRoot: tempRoot+ });++ assert.strictEqual(output.exitCode, 0, output.stderr);+ assert.strictEqual(output.stdout, `phase=pre input=payload root=${tempRoot}`);+ });+ });+ })) passed++; else failed++;++ if (test('observe-runner fails open when no shell runtime is available', () => {+ withTempPluginRoot(tempRoot => {+ writeFakeObserveScript(tempRoot);+ withEnv({ BASH: '', PATH: '' }, () => {+ const output = observeRunner.run('payload', {+ hookId: 'post:observe',+ pluginRoot: tempRoot+ });++ assert.strictEqual(output.exitCode, 0);+ assert.ok(!Object.prototype.hasOwnProperty.call(output, 'stdout'), 'disabled observe should preserve stdin via runner passthrough');+ assert.ok(output.stderr.includes('shell runtime unavailable'));+ });+ });+ })) passed++; else failed++;++ console.log(`\nPassed: ${passed}`);+ console.log(`Failed: ${failed}`);+ process.exit(failed > 0 ? 1 : 0);+}++runTests();