@claude-flow/cli 3.65.0 → 3.66.0

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

@@ -1,14 +1,15 @@
 {
   "manifest": {
-    "version": "3.65.0",
+    "version": "3.66.0",
     "files": {
       "auto-memory-hook.mjs": "631fac9d518835e2852a406888316bbbddddb49e7ed8e406d2e971f46833df9a",
-      "hook-handler.cjs": "24502a3bcb78770971147940515c992e35b6736ae14ee2dc54e07d4cdef6a1d8",
+      "hook-handler.cjs": "0ce70981aa33f76d008b6f49626effaf4269918c4094f1a28c1ef6fceb097d6f",
       "intelligence.cjs": "1d981d6c6a35d70a66450e96458e26169e0cede11523ea246a2c129c197a5b4e",
       "statusline.cjs": "d72417ecb38634011a19f095a30e07b9929e6f97663520172ece9be7491b2eaa",
-      "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d"
+      "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d",
+      "learning-loop.cjs": "d046cd6f8efb7dd40e1d2451516c181fc8b26477aefb1124c0df5f52a23f9190"
     }
   },
-  "signature": "cwZNQ9x3YdIZ8qur+qzjhgVAubgv3FSXoWEfhkPtNc86sTPBOg6zlIb8Z2bt8ogZ8PnVmNgKas6Ft6QswIBiBg==",
+  "signature": "0JTgpgicsDJAdV6HhU9yPawpjklEbbSsyFjLJAqSh2jX9Jx8w4I5wS/EPnd5yp66HNpgU0up0Shay0qTdHeZAA==",
   "algorithm": "ed25519"
 }

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

@@ -647,6 +647,8 @@ 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;
@@ -703,6 +705,50 @@ async function readStdin() {
 // 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);
@@ -751,6 +797,16 @@ async function main() {
     try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore parse errors */ }
   }
 
+  // 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();
+  }
+
   if ((command === 'post-edit' || command === 'session-end') &&
       !claimSideEffectEvent(command, stdinData, hookInput)) {
     return;
@@ -789,6 +845,16 @@ 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;