@claude-flow/cli 3.73.0 → 3.74.0

package/.claude/helpers/.helpers-version

@@ -1 +1 @@
-3.57.1
+3.63.4

package/.claude/helpers/auto-memory-hook.mjs

@@ -9,10 +9,6 @@
  *   node auto-memory-hook.mjs import   # SessionStart: import auto memory files into backend
  *   node auto-memory-hook.mjs sync     # SessionEnd: sync insights back to MEMORY.md
  *   node auto-memory-hook.mjs status   # Show bridge status
- *   node auto-memory-hook.mjs read <namespace> <key>   # Read-only exact lookup, prints JSON
- *
- * import and sync exit 1 when they fail (never 2, which Claude Code treats as
- * "block"), so a failed write is visible without stopping the session.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, rmdirSync, rmSync, statSync } from 'fs';
@@ -61,9 +57,6 @@ function warnMemoryUnavailable() {
 
 const DEBUG = !!(process.env.RUFLO_DEBUG || process.env.DEBUG);
 
-/** A command failure whose message is already complete; main prints it and exits 1. */
-class HookFailure extends Error {}
-
 // ── Graceful shutdown (FIX 3) ───────────────────────────────────────────────
 // Track the backend in use so a SIGTERM/SIGINT mid-run can still flush it
 // (the JSON backend persists; a SQLite-backed one closes/flushes WAL) instead
@@ -83,9 +76,8 @@ async function gracefulExit(signal) {
 process.on('SIGTERM', () => { gracefulExit('SIGTERM'); });
 process.on('SIGINT', () => { gracefulExit('SIGINT'); });
 
-// The data directory is created lazily by import and sync only, so the
-// read-only `read` subcommand never creates directories (#4685).
-function ensureDataDir() { if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true }); }
+// Ensure data dir
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
 
 // ============================================================================
 // Store write safety (#4058): intelligence.cjs read-modify-writes the same
@@ -126,83 +118,6 @@ function writeFileAtomic(filePath, text) {
   }
 }
 
-// ============================================================================
-// Strict store reads (#4685): only ENOENT means "no store yet". A read or
-// parse failure, a non-array document, or an entry without a unique string id
-// is an error, and the file is never rewritten, so its bytes stay intact.
-// ============================================================================
-
-class StoreError extends Error {
-  constructor(code, message, cause) {
-    super(message);
-    this.name = 'StoreError';
-    this.code = code;
-    if (cause) this.cause = cause;
-  }
-}
-
-function parseStoreText(text, filePath) {
-  let data;
-  try { data = JSON.parse(text); } catch (e) {
-    throw new StoreError('STORE_PARSE_FAILED', `${filePath} is not valid JSON (${e.message}); left unchanged`, e);
-  }
-  if (!Array.isArray(data)) {
-    throw new StoreError('STORE_NOT_ARRAY', `${filePath} does not hold a JSON array; left unchanged`);
-  }
-  const seen = new Set();
-  for (let i = 0; i < data.length; i++) {
-    const e = data[i];
-    if (!e || typeof e !== 'object' || Array.isArray(e)) {
-      throw new StoreError('STORE_BAD_ENTRY', `${filePath} entry ${i} is not an object; left unchanged`);
-    }
-    if (typeof e.id !== 'string' || e.id.length === 0) {
-      throw new StoreError('STORE_BAD_ID', `${filePath} entry ${i} has no string id; left unchanged`);
-    }
-    if (seen.has(e.id)) {
-      // intelligence.cjs de-duplicates the store by id when it consolidates,
-      // which repairs a duplicate an older writer left behind.
-      throw new StoreError('STORE_DUPLICATE_ID', `${filePath} holds duplicate id ${JSON.stringify(e.id)}; left unchanged`);
-    }
-    seen.add(e.id);
-  }
-  return data;
-}
-
-/** The parsed entries, or null when the file does not exist. Anything else throws a StoreError. */
-function readStoreFile(filePath) {
-  let text;
-  try { text = readFileSync(filePath, 'utf-8'); } catch (e) {
-    if (e && e.code === 'ENOENT') return null;
-    const why = (e && (e.code || e.message)) || String(e);
-    throw new StoreError('STORE_READ_FAILED', `cannot read ${filePath} (${why}); left unchanged`, e);
-  }
-  return parseStoreText(text, filePath);
-}
-
-/**
- * Re-read the store and check that every expected entry is present and equal
- * under `same`, and that every deleted id is gone. Throws on any mismatch.
- */
-function verifyStoreFile(filePath, expected, deletedIds, same) {
-  const onDisk = readStoreFile(filePath);
-  if (onDisk === null) throw new StoreError('STORE_READBACK_MISMATCH', `${filePath} is missing after the write`);
-  const byId = new Map(onDisk.map((e) => [e.id, e]));
-  for (const [id, want] of expected) {
-    const got = byId.get(id);
-    if (!got) throw new StoreError('STORE_READBACK_MISMATCH', `${filePath} readback is missing entry ${JSON.stringify(id)}`);
-    if (!same(got, want)) throw new StoreError('STORE_READBACK_MISMATCH', `${filePath} readback differs for entry ${JSON.stringify(id)}`);
-  }
-  for (const id of deletedIds) {
-    if (!expected.has(id) && byId.has(id)) {
-      throw new StoreError('STORE_READBACK_MISMATCH', `${filePath} readback still holds deleted entry ${JSON.stringify(id)}`);
-    }
-  }
-  return onDisk;
-}
-
-const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-const sameRecord = (a, b) => a.namespace === b.namespace && a.key === b.key && a.content === b.content;
-
 // Claude Code shares one auto-memory directory across every worktree of a
 // repository, but findGitRoot() in the memory package stops at a worktree's
 // `.git` FILE and keys the directory by the worktree path (#4058). Resolve the
@@ -234,36 +149,21 @@ class JsonFileBackend {
     this.entries = new Map();
     this.loadedIds = new Set();
     this.deletedIds = new Set();
-    // Entries this instance wrote (or deleted), so a caller can confirm them on disk.
-    this.written = new Map();
-    this.storePresent = false;
   }
 
   async initialize() {
-    // Throws on anything but a missing file, so a damaged store is never
-    // mistaken for an empty one and later overwritten (#4685).
-    const data = readStoreFile(this.filePath);
-    this.storePresent = data !== null;
-    for (const entry of data || []) { this.entries.set(entry.id, entry); this.loadedIds.add(entry.id); }
-  }
-
-  _track(entry) {
-    if (!entry || typeof entry.id !== 'string' || entry.id.length === 0) {
-      throw new StoreError('STORE_BAD_ID', 'refusing to store an entry without a string id');
+    if (existsSync(this.filePath)) {
+      try {
+        const data = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+        if (Array.isArray(data)) {
+          for (const entry of data) { this.entries.set(entry.id, entry); this.loadedIds.add(entry.id); }
+        }
+      } catch { /* start fresh */ }
     }
-    this.entries.set(entry.id, entry);
-    this.written.set(entry.id, entry);
-    this.deletedIds.delete(entry.id);
-  }
-
-  _forget(id) {
-    this.deletedIds.add(id);
-    this.written.delete(id);
-    return this.entries.delete(id);
   }
 
   async shutdown() { this._persist(); }
-  async store(entry) { this._track(entry); this._persist(); }
+  async store(entry) { this.entries.set(entry.id, entry); this._persist(); }
   async get(id) { return this.entries.get(id) ?? null; }
   async getByKey(key, ns) {
     for (const e of this.entries.values()) {
@@ -278,11 +178,10 @@ class JsonFileBackend {
     if (updates.content !== undefined) e.content = updates.content;
     if (updates.tags) e.tags = updates.tags;
     e.updatedAt = Date.now();
-    this.written.set(id, e);
     this._persist();
     return e;
   }
-  async delete(id) { return this._forget(id); }
+  async delete(id) { this.deletedIds.add(id); return this.entries.delete(id); }
   async query(opts) {
     let results = [...this.entries.values()];
     if (opts?.namespace) results = results.filter(e => e.namespace === opts.namespace);
@@ -300,8 +199,8 @@ class JsonFileBackend {
     return results;
   }
   async search() { return []; } // No vector search in JSON backend
-  async bulkInsert(entries) { for (const e of entries) this._track(e); this._persist(); }
-  async bulkDelete(ids) { let n = 0; for (const id of ids) { if (this._forget(id)) n++; } this._persist(); return n; }
+  async bulkInsert(entries) { for (const e of entries) this.entries.set(e.id, e); this._persist(); }
+  async bulkDelete(ids) { let n = 0; for (const id of ids) { this.deletedIds.add(id); if (this.entries.delete(id)) n++; } this._persist(); return n; }
   async count() { return this.entries.size; }
   async listNamespaces() {
     const ns = new Set();
@@ -310,8 +209,8 @@ class JsonFileBackend {
   }
   async clearNamespace(ns) {
     let n = 0;
-    for (const [id, e] of [...this.entries]) {
-      if (e.namespace === ns) { this._forget(id); n++; }
+    for (const [id, e] of this.entries) {
+      if (e.namespace === ns) { this.deletedIds.add(id); this.entries.delete(id); n++; }
     }
     this._persist();
     return n;
@@ -336,24 +235,25 @@ class JsonFileBackend {
     };
   }
 
-  // Errors propagate (#4685): a failed read, write or rename must reject the
-  // store/bulkInsert/shutdown call instead of resolving with an in-memory-only
-  // update. The readback runs inside the lock so a parallel writer cannot race it.
   _persist() {
-    withStoreLock(this.filePath, () => {
-      // Keep entries another writer (intelligence.cjs, a parallel hook) added
-      // after we loaded; ours win on the same id, and our own deletes stay deleted.
-      // A missing file is the only case that writes without merging.
-      const merged = new Map(this.entries);
-      for (const e of readStoreFile(this.filePath) || []) {
-        if (!merged.has(e.id) && !this.loadedIds.has(e.id) && !this.deletedIds.has(e.id)) merged.set(e.id, e);
-      }
-      writeFileAtomic(this.filePath, JSON.stringify([...merged.values()], null, 2));
-      verifyStoreFile(this.filePath, merged, this.deletedIds, sameJson);
-      for (const id of merged.keys()) this.loadedIds.add(id);
-      this.entries = merged;
-      this.storePresent = true;
-    });
+    try {
+      withStoreLock(this.filePath, () => {
+        // Keep entries another writer (intelligence.cjs, a parallel hook) added
+        // after we loaded; ours win on the same id, and our own deletes stay deleted.
+        const merged = new Map(this.entries);
+        try {
+          const onDisk = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+          if (Array.isArray(onDisk)) {
+            for (const e of onDisk) {
+              if (e && !merged.has(e.id) && !this.loadedIds.has(e.id) && !this.deletedIds.has(e.id)) merged.set(e.id, e);
+            }
+          }
+        } catch { /* missing or unreadable: write ours */ }
+        writeFileAtomic(this.filePath, JSON.stringify([...merged.values()], null, 2));
+        for (const id of merged.keys()) this.loadedIds.add(id);
+        this.entries = merged;
+      });
+    } catch { /* best effort */ }
   }
 }
 
@@ -465,7 +365,6 @@ async function doImport() {
   }
 
   const config = readConfig();
-  ensureDataDir();
   const backend = trackBackend(new JsonFileBackend(STORE_PATH));
   await backend.initialize();
 
@@ -496,53 +395,23 @@ async function doImport() {
   }
 
   const bridge = new memPkg.AutoMemoryBridge(backend, bridgeConfig);
-  const fileErrors = [];
-  if (typeof bridge.on === 'function') bridge.on('import:file-error', (info) => { fileErrors.push(info?.file || 'unknown'); });
 
-  // Success is reported only after the import, the final persist and a fresh
-  // readback of every entry this run wrote have all succeeded (#4685).
-  const failures = [];
-  let result = null;
-  try {
-    result = await bridge.importFromAutoMemory();
-  } catch (err) {
-    failures.push(`import: ${err.message}`);
-  }
   try {
-    await backend.shutdown();
-    verifyStoreFile(STORE_PATH, backend.written, backend.deletedIds, sameRecord);
+    const result = await bridge.importFromAutoMemory();
+    success(`Imported ${result.imported} entries (${result.skipped} skipped)`);
+    dim(`├─ Backend entries: ${await backend.count()}`);
+    dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
+    dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
+    dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
   } catch (err) {
-    failures.push(`persist: ${err.message}`);
+    dim(`Import failed (non-critical): ${err.message}`);
   }
-  if (fileErrors.length) failures.push(`unreadable source file(s): ${fileErrors.join(', ')}`);
-  if (failures.length) throw new HookFailure(`Import failed: ${failures.join('; ')}`);
-
-  success(`Imported ${result.imported} entries (${result.skipped} skipped), verified in ${STORE_PATH}`);
-  dim(`├─ Backend entries: ${await backend.count()}`);
-  dim(`├─ Learning: ${config.learningBridge.enabled ? 'active' : 'disabled'}`);
-  dim(`├─ Graph: ${config.memoryGraph.enabled ? 'active' : 'disabled'}`);
-  dim(`└─ Agent scopes: ${config.agentScopes.enabled ? 'active' : 'disabled'}`);
-}
 
-// A store committed to the repository came from whoever wrote the repo. Its
-// entries must never be promoted into the user's own Claude Code memory,
-// which the model loads every session as the user's notes.
-function storeIsRepoTracked() {
-  if (!existsSync(STORE_PATH)) return false;
-  try {
-    execFileSync('git', ['ls-files', '--error-unmatch', '--', STORE_PATH], { cwd: PROJECT_ROOT, stdio: 'ignore', timeout: 2000 });
-    return true;
-  } catch {
-    return false;
-  }
+  await backend.shutdown();
 }
 
 async function doSync() {
   log('Syncing insights to auto memory files...');
-  if (storeIsRepoTracked()) {
-    dim('Skipping sync: the memory store is committed to this repository, so its entries are not this machine\'s');
-    return;
-  }
 
   const memPkg = await loadMemoryPackage();
   if (!memPkg || !memPkg.AutoMemoryBridge) {
@@ -551,7 +420,6 @@ async function doSync() {
   }
 
   const config = readConfig();
-  ensureDataDir();
   const backend = trackBackend(new JsonFileBackend(STORE_PATH));
   await backend.initialize();
 
@@ -586,7 +454,6 @@ async function doSync() {
 
   const bridge = new memPkg.AutoMemoryBridge(backend, bridgeConfig);
 
-  let syncError = null;
   try {
     const syncResult = await bridge.syncToAutoMemory();
     success(`Synced ${syncResult.synced} entries to auto memory`);
@@ -600,12 +467,11 @@ async function doSync() {
     if (indexSkipped) dim(`MEMORY.md index unchanged (${indexSkipped.reason || 'nothing to curate'})`);
     else success('Curated MEMORY.md index');
   } catch (err) {
-    syncError = err;
+    dim(`Sync failed (non-critical): ${err.message}`);
   }
 
   if (bridge.destroy) bridge.destroy();
   await backend.shutdown();
-  if (syncError) throw new HookFailure(`Sync failed: ${syncError.message}`);
 }
 
 async function doStatus() {
@@ -623,44 +489,16 @@ async function doStatus() {
   console.log(`  MemoryGraph:    ${config.memoryGraph.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
   console.log(`  AgentScopes:    ${config.agentScopes.enabled ? '✅ Enabled' : '⏸ Disabled'}`);
 
-  try {
-    const data = readStoreFile(STORE_PATH);
-    if (data) console.log(`  Entries:        ${data.length}`);
-  } catch (err) {
-    console.log(`  Entries:        ❌ ${err.message}`);
+  if (existsSync(STORE_PATH)) {
+    try {
+      const data = JSON.parse(readFileSync(STORE_PATH, 'utf-8'));
+      console.log(`  Entries:        ${Array.isArray(data) ? data.length : 0}`);
+    } catch { /* ignore */ }
   }
 
   console.log('');
 }
 
-// Read-only exact lookup (#4685). It never loads the memory package, creates a
-// directory, takes the write lock or calls shutdown, so it cannot change the store.
-const READ_SCHEMA_VERSION = 1;
-async function doRead(namespace, key) {
-  const out = { schemaVersion: READ_SCHEMA_VERSION, store: STORE_PATH, storePresent: false, namespace: namespace ?? null, key: key ?? null, found: false, entry: null };
-  const refuse = (code, message) => {
-    out.error = { code, message };
-    console.log(JSON.stringify(out, null, 2));
-    return 1;
-  };
-  if (typeof namespace !== 'string' || !namespace || typeof key !== 'string' || !key) {
-    return refuse('USAGE', 'usage: auto-memory-hook.mjs read <namespace> <key>');
-  }
-  const backend = new JsonFileBackend(STORE_PATH);
-  try {
-    await backend.initialize();
-  } catch (err) {
-    out.storePresent = true; // initialize() only throws for a file that exists
-    return refuse(err.code || 'STORE_READ_FAILED', err.message);
-  }
-  out.storePresent = backend.storePresent;
-  const matches = await backend.query({ namespace, key });
-  if (matches.length > 1) return refuse('AMBIGUOUS_KEY', `${matches.length} entries share namespace ${JSON.stringify(namespace)} and key ${JSON.stringify(key)}`);
-  if (matches.length === 1) { out.found = true; out.entry = matches[0]; }
-  console.log(JSON.stringify(out, null, 2));
-  return 0;
-}
-
 // ============================================================================
 // Main
 // ============================================================================
@@ -668,10 +506,8 @@ async function doRead(namespace, key) {
 // Older settings.json files run `node -e "…import(file)" import`, where the
 // subcommand lands in argv[1] and argv[2] is empty, so both hooks fell through
 // to `status` and never imported or synced (#4058). Accept that shape too.
-const COMMANDS = ['import', 'sync', 'status', 'read'];
-const argvBase = process.argv[2] ? 2 : 1;
+const COMMANDS = ['import', 'sync', 'status'];
 const command = process.argv[2] || (COMMANDS.includes(process.argv[1]) ? process.argv[1] : 'status');
-const commandArgs = process.argv.slice(argvBase + 1);
 
 // Dynamic import() failures can surface as unhandled rejections on a later
 // microtask even when the awaiting call site already caught them, which would
@@ -685,25 +521,18 @@ process.on('unhandledRejection', (reason) => {
   }
 });
 
-// A failed import or sync exits 1, never 2: Claude Code treats exit 2 from a
-// hook as "block", while exit 1 is a non-blocking error it shows to the user,
-// so the session carries on and the failure is no longer hidden (#4685).
-let exitCode = 0;
 try {
   switch (command) {
     case 'import': await doImport(); break;
     case 'sync': await doSync(); break;
     case 'status': await doStatus(); break;
-    case 'read': exitCode = await doRead(commandArgs[0], commandArgs[1]); break;
     default:
-      console.log('Usage: auto-memory-hook.mjs <import|sync|status|read <namespace> <key>>');
+      console.log('Usage: auto-memory-hook.mjs <import|sync|status>');
       break;
   }
 } catch (err) {
-  exitCode = 1;
-  const detail = err && err.message ? err.message : String(err);
-  const line = err instanceof HookFailure ? `[AutoMemory] ${detail}` : `[AutoMemory] ${command} failed: ${detail}`;
-  try { process.stderr.write(`${line}\n`); } catch (_) {}
+  // Hooks must never crash Claude Code - fail silently
+  try { dim(`Error (non-critical): ${err.message}`); } catch (_) {}
 }
-// Force exit — process.exitCode alone isn't enough if async errors override it
-process.exit(exitCode);
+// Force clean exit — process.exitCode alone isn't enough if async errors override it
+process.exit(0);

package/.claude/helpers/helpers.manifest.json

@@ -1,15 +1,15 @@
 {
   "manifest": {
-    "version": "3.73.0",
+    "version": "3.74.0",
     "files": {
-      "auto-memory-hook.mjs": "6078bd1c6b02dd3f80097f8d7f28904d48b3cdf7a534d2aa13966590694ca403",
-      "hook-handler.cjs": "31db0f7492fbd8b2e48ea9adbc1ba293dfed1e006666d20e93ea76e158986947",
-      "intelligence.cjs": "ffdcfa6d2665a16e417dedd5bc67080c8192820f76265de5013fcb49f668ec71",
-      "statusline.cjs": "284b95629ced4340667872b977de3f2beac90fc6bb7ab1a62dd7f7ae75c5e5d1",
+      "auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
+      "hook-handler.cjs": "24502a3bcb78770971147940515c992e35b6736ae14ee2dc54e07d4cdef6a1d8",
+      "intelligence.cjs": "1d981d6c6a35d70a66450e96458e26169e0cede11523ea246a2c129c197a5b4e",
+      "statusline.cjs": "d72417ecb38634011a19f095a30e07b9929e6f97663520172ece9be7491b2eaa",
       "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d",
       "learning-loop.cjs": "d046cd6f8efb7dd40e1d2451516c181fc8b26477aefb1124c0df5f52a23f9190"
     }
   },
-  "signature": "JPs8pGUFfkmmIj+GpqM7snJ1AX9IJS8olXiwHgZjSTKCIcK0aERAd+Wjy3jfBbK1V8mqP+ZWeX8CRr4aA+3BDA==",
+  "signature": "OSR1FztpUZYdZGE3tNQPgLpD8WZWfd+UljXhcNdJoX7nPfA5OJpWHDRo1NRzSJyiNGowIXcXoiqdspnRM9owBg==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/hook-handler.cjs

@@ -647,8 +647,6 @@ const router = safeRequire(path.join(helpersDir, 'router.cjs'));
 const session = safeRequire(path.join(helpersDir, 'session.cjs'));
 const memory = safeRequire(path.join(helpersDir, 'memory.cjs'));
 const intelligence = safeRequire(path.join(helpersDir, 'intelligence.cjs'));
-// ADR-512: the verified-outcome learning loop, bundled from the ruflo-mods loop source.
-const learningLoop = safeRequire(path.join(helpersDir, 'learning-loop.cjs'));
 
 // ── Intelligence timeout protection (fixes #1530, #1531) ───────────────────
 const INTELLIGENCE_TIMEOUT_MS = 3000;
@@ -682,7 +680,7 @@ const [,, command, ...args] = process.argv;
 
 // Read stdin with timeout — Claude Code sends hook data as JSON via stdin.
 // Timeout prevents hanging when stdin is not properly closed (common on Windows).
-async function readStdin(windowMs = 500) {
+async function readStdin() {
   if (process.stdin.isTTY) return '';
   return new Promise((resolve) => {
     let data = '';
@@ -690,7 +688,7 @@ async function readStdin(windowMs = 500) {
       process.stdin.removeAllListeners();
       process.stdin.pause();
       resolve(data);
-    }, windowMs);
+    }, 500);
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', (chunk) => { data += chunk; });
     process.stdin.on('end', () => { clearTimeout(timer); resolve(data); });
@@ -705,50 +703,6 @@ async function readStdin(windowMs = 500) {
 // keeps it from firing twice. Only side-effect events can be handed over:
 // guards such as pre-bash always run, whatever the variable says.
 const MOD_OWNABLE_EVENTS = new Set(['route', 'post-edit']);
-
-// ADR-512: classic hooks run the verified-outcome learning loop for users without the mod. A
-// mod that records turns itself says so with `learning-loop` (or, before ADR-512, owns
-// `route`), so a turn is never recorded twice.
-function modRecordsTurns(env = process.env) {
-  return String(env.RUFLO_MODS_OWNS || '').split(',').some((owned) => ['learning-loop', 'route'].includes(owned.trim()));
-}
-
-function learningLoopRoot() {
-  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
-}
-
-// Records the turns the session transcript gained since the last look (all of them when the
-// session ends). Returns the number recorded; never throws.
-function recordLearningTurns(hookInput, final) {
-  try {
-    const root = learningLoopRoot();
-    if (!learningLoop || modRecordsTurns() || !learningLoop.enabled(root)) return 0;
-    const agentFor = (text) => {
-      try { return (router && router.routeTask && router.routeTask(text).agent) || 'coder'; } catch (e) { return 'coder'; }
-    };
-    return learningLoop.recordTurns({
-      root,
-      transcriptPath: hookInput.transcript_path || hookInput.transcriptPath,
-      session: hookInput.session_id || hookInput.sessionId,
-      final,
-      agentFor,
-    });
-  } catch (e) { return 0; }
-}
-
-// Trains SONA from the recorded turns in a detached `ruflo hooks verified-ingest` (a hook has
-// seconds; an ingest may take longer). At most one spawn a minute per project.
-function spawnLearningIngest() {
-  try {
-    const root = learningLoopRoot();
-    if (!learningLoop || !learningLoop.enabled(root) || !learningLoop.ingestDue(root)) return;
-    const stamp = path.join(root, '.claude-flow', 'data', 'verified-ingest.spawned');
-    try { if (Date.now() - fs.statSync(stamp).mtimeMs < 60 * 1000) return; } catch (e) { /* never spawned */ }
-    fs.mkdirSync(path.dirname(stamp), { recursive: true });
-    fs.writeFileSync(stamp, String(Date.now()));
-    spawnDetachedHookRefresh('verified-ingest');
-  } catch (e) { /* best-effort only */ }
-}
 function ownedByMod(cmd, env = process.env) {
   if (!MOD_OWNABLE_EVENTS.has(cmd)) return false;
   return String(env.RUFLO_MODS_OWNS || '').split(',').some((owned) => owned.trim() === cmd);
@@ -779,42 +733,22 @@ function claimSideEffectEvent(family, stdinData, event) {
   }
 }
 
-// pre-bash is a gate (#4743): a path that cannot vouch for the command blocks it.
-function blockPreBash(reason) {
-  console.error(`[BLOCKED] ${reason}`);
-  process.exit(2);
-}
-
 async function main() {
   if (ownedByMod(command)) return;
 
   // Global safety timeout: hooks must NEVER hang (#1530, #1531)
   const safetyTimer = setTimeout(() => {
     process.stderr.write("[WARN] Hook handler global timeout (5s), forcing exit\n");
-    if (command === 'pre-bash') blockPreBash('pre-bash timed out before the command was validated');
     process.exit(0);
   }, 5000);
   safetyTimer.unref(); // don't keep process alive just for this timer
 
   let stdinData = '';
-  // pre-bash blocks when it gets no command (#4743), so a slow host gets a
-  // wider window. The read ends at EOF, so a prompt host waits no longer.
-  try { stdinData = await readStdin(command === 'pre-bash' ? 3000 : 500); } catch (e) { /* ignore stdin errors */ }
+  try { stdinData = await readStdin(); } catch (e) { /* ignore stdin errors */ }
 
   let hookInput = {};
-  let stdinUnparsable = false;
   if (stdinData.trim()) {
-    try { hookInput = JSON.parse(stdinData); } catch (e) { stdinUnparsable = true; }
-  }
-
-  // ADR-512: record what finished and train from it, before the dedup below: it keys session-end
-  // on the session id, so after a PreCompact the real SessionEnd would never record the last turn.
-  // Recording is idempotent (a per-session transcript offset, ids from transcript positions).
-  // PreCompact runs mid-session, where the open turn may still edit and verify: only SessionEnd
-  // closes it.
-  if (command === 'session-end') {
-    recordLearningTurns(hookInput, (hookInput.hook_event_name || hookInput.hookEventName) !== 'PreCompact');
-    spawnLearningIngest();
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore parse errors */ }
   }
 
   if ((command === 'post-edit' || command === 'session-end') &&
@@ -855,16 +789,6 @@ async function main() {
 
 const handlers = {
   'route': () => {
-    // ADR-512: record the turns that finished, then cite the verified lessons that fit this prompt.
-    recordLearningTurns(hookInput, false);
-    if (learningLoop && !modRecordsTurns()) {
-      try {
-        if (learningLoop.enabled(learningLoopRoot())) {
-          const block = learningLoop.lessonsForPrompt(learningLoopRoot(), prompt);
-          if (block) console.log(block);
-        }
-      } catch (e) { /* non-fatal */ }
-    }
     // Inject ranked intelligence context before routing
     // ADR-472: keep the detailed recall so ONE bounded log record (ids, scores, router pick; never the prompt) is appended after routing.
     let recall = null;
@@ -964,12 +888,11 @@ const handlers = {
 
   'pre-bash': () => {
     // Basic command safety check — prefer stdin command data from Claude Code.
-    // Only a non-empty string counts as the command (#2017, #4743): input that
-    // arrived late, did not parse, or carried no command blocks instead of passing.
-    if (stdinUnparsable) blockPreBash('pre-bash could not parse the hook input');
-    const raw = [hookInput.command, toolInput.command, prompt].find((c) => typeof c === 'string' && c.trim());
-    if (!raw) blockPreBash('pre-bash received no command to validate');
-    const cmd = raw.toLowerCase();
+    // String() wrap is belt-and-suspenders for #2017: even if a future regression
+    // re-binds `prompt` or `hookInput.command` to a non-string, `.toLowerCase()`
+    // can no longer throw a TypeError that the global try/catch would swallow
+    // (silently exiting 0 and letting the dangerous command through).
+    const cmd = String(hookInput.command || toolInput.command || prompt || '').toLowerCase();
     const dangerous = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:'];
     // Join literal quote fragments and normalize root paths without shell evaluation.
     function hasRootDelete(command, depth = 0) {
@@ -1319,7 +1242,6 @@ const handlers = {
     try {
       await Promise.resolve(handlers[command]());
     } catch (e) {
-      if (command === 'pre-bash') blockPreBash(`pre-bash failed: ${e && e.message}`);
       // Hooks should never crash Claude Code - fail silently
       console.log(`[WARN] Hook ${command} encountered an error: ${e.message}`);
     }
@@ -1331,7 +1253,7 @@ const handlers = {
   }
 }
 
-// Non-blocking hooks exit 0; pre-bash denials and failures exit 2 to block PreToolUse.
+// Non-blocking hooks exit 0; pre-bash denials exit 2 to block PreToolUse.
 // A denial exits immediately, before the normal completion path below.
 //
 // Only dispatch when run directly (node hook-handler.cjs <cmd>). When
@@ -1343,7 +1265,6 @@ const handlers = {
 if (require.main === module) {
   process.exitCode = 0;
   main().catch((e) => {
-    if (command === 'pre-bash') blockPreBash(`pre-bash failed: ${e && e.message}`);
     try { console.log(`[WARN] Hook handler error: ${e.message}`); } catch (_) {}
   }).finally(() => {
     process.exit(0);