Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(bridge): wire bridgeRecordFeedback to real intelligence.recordTrajectory (#2786 fix-3)

ruv469a901edaf6
diff --git a/scripts/loop-checkpoint.mjs b/scripts/loop-checkpoint.mjs
new file mode 100755
index 0000000000..0e2d2480b4
--- /dev/null
+++ b/scripts/loop-checkpoint.mjs
@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Loop checkpoint β€” tiny durable state for autonomous /loop iterations.
+ *
+ * Usage:
+ * node scripts/loop-checkpoint.mjs read
+ * node scripts/loop-checkpoint.mjs write --iteration N --done-criteria "<cmd>" --next "<step>" --blockers "<or empty>"
+ * node scripts/loop-checkpoint.mjs check
+ *
+ * Exit codes for `check`:
+ * 0 β€” progress made, keep going
+ * 3 β€” DONE (done-criteria command exits 0) β€” stop and report
+ * 4 β€” NO-PROGRESS (2 strikes on the same `next`) β€” stop, state blocker
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(here, '..');
+const stateDir = resolve(repoRoot, '.ruvnet-brain');
+const stateFile = resolve(stateDir, 'checkpoint.json');
+
+function readState() {
+ if (!existsSync(stateFile)) return null;
+ try { return JSON.parse(readFileSync(stateFile, 'utf-8')); } catch { return null; }
+}
+
+function writeState(state) {
+ mkdirSync(stateDir, { recursive: true });
+ writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+function parseArgs(argv) {
+ const out = {};
+ for (let i = 0; i < argv.length; i++) {
+ if (argv[i].startsWith('--')) { out[argv[i].slice(2)] = argv[i + 1]; i++; }
+ }
+ return out;
+}
+
+const [, , cmd, ...rest] = process.argv;
+
+if (cmd === 'read') {
+ const state = readState();
+ if (!state) { console.log('(no checkpoint)'); process.exit(0); }
+ console.log(JSON.stringify(state, null, 2));
+ process.exit(0);
+}
+
+if (cmd === 'write') {
+ const args = parseArgs(rest);
+ const prev = readState() || { history: [] };
+ const state = {
+ iteration: Number(args.iteration ?? (prev.iteration ?? 0) + 1),
+ doneCriteria: args['done-criteria'] ?? prev.doneCriteria ?? '',
+ next: args.next ?? '',
+ blockers: args.blockers ?? '',
+ lastNext: prev.next ?? '',
+ stalledOnSameNextCount: (prev.next && args.next === prev.next) ? (prev.stalledOnSameNextCount ?? 0) + 1 : 0,
+ updatedAt: new Date().toISOString(),
+ history: [...(prev.history ?? []).slice(-9), { iteration: prev.iteration, next: prev.next, at: prev.updatedAt }],
+ };
+ writeState(state);
+ console.log(`checkpoint written Β· iter=${state.iteration} Β· stalledOnSameNextCount=${state.stalledOnSameNextCount}`);
+ process.exit(0);
+}
+
+if (cmd === 'check') {
+ const state = readState();
+ if (!state) { console.error('no checkpoint β€” nothing to check'); process.exit(0); }
+ if (state.doneCriteria) {
+ try {
+ execSync(state.doneCriteria, { stdio: 'ignore', shell: '/bin/bash' });
+ console.log(`DONE β€” done-criteria satisfied: ${state.doneCriteria}`);
+ process.exit(3);
+ } catch { /* not done yet */ }
+ }
+ if ((state.stalledOnSameNextCount ?? 0) >= 2) {
+ console.error(`NO-PROGRESS β€” same next repeated ${state.stalledOnSameNextCount} times: ${state.next}`);
+ console.error(`Blockers: ${state.blockers || '(none stated)'}`);
+ process.exit(4);
+ }
+ console.log(`ok β€” iter=${state.iteration} Β· next="${state.next}"`);
+ process.exit(0);
+}
+
+console.error(`unknown command: ${cmd}. Use: read | write | check`);
+process.exit(1);
diff --git a/v3/@claude-flow/cli/src/memory/memory-bridge.ts b/v3/@claude-flow/cli/src/memory/memory-bridge.ts
index 5b5fa21cd1..619d555325 100644
--- a/v3/@claude-flow/cli/src/memory/memory-bridge.ts
+++ b/v3/@claude-flow/cli/src/memory/memory-bridge.ts
@@ -1905,44 +1905,68 @@ export async function bridgeRecordFeedback(options: {
let controller = 'none';
let updated = 0;
- // Try LearningSystem first (Phase 4)
- const learningSystem = registry.get('learningSystem');
- if (learningSystem) {
- try {
- if (typeof learningSystem.recordFeedback === 'function') {
- await learningSystem.recordFeedback({
- taskId: options.taskId, success: options.success, quality: options.quality,
- agent: options.agent, duration: options.duration, timestamp: Date.now(),
+ // Real intelligence-pipeline write (#2786 fix-3, 2026-07-26 sweep follow-up).
+ // The prior code called `learningSystem.recordFeedback/.record` and
+ // `reasoningBank.recordOutcome/.record` β€” none of those methods exist on
+ // the LocalSonaCoordinator / LocalReasoningBank instances the bridge
+ // actually wires into the registry (see initializeIntelligence in
+ // memory/intelligence.ts). The silent catch made it look successful.
+ //
+ // The REAL public API is `intelligence.recordTrajectory(steps, verdict)`
+ // β€” same call `hooks_post-command` already uses (hooks-tools.ts).
+ // It initializes lazily, embeds the step, and drives both the SONA
+ // coordinator and pattern distillation.
+ try {
+ const intelligence = await import('./intelligence.js');
+ const verdict = options.success ? 'success' : 'failure';
+ const recorded = await intelligence.recordTrajectory(
+ [{
+ type: 'action',
+ content: `Task ${options.taskId} completed by ${options.agent || 'unknown'} β€” success=${options.success}, quality=${options.quality.toFixed(3)}`,
+ metadata: {
+ taskId: options.taskId,
+ agent: options.agent,
+ quality: options.quality,
+ duration: options.duration,
// ADR-147 P2: forward spawn-tree lineage if present
- parentAgentId: options.parentAgentId, depth: options.depth,
- });
- controller = 'learningSystem';
- updated++;
- } else if (typeof learningSystem.record === 'function') {
- await learningSystem.record(options.taskId, options.quality, options.success ? 'success' : 'failure');
- controller = 'learningSystem';
- updated++;
- }
- } catch { /* API mismatch β€” skip */ }
+ parentAgentId: options.parentAgentId,
+ depth: options.depth,
+ },
+ timestamp: Date.now(),
+ }],
+ verdict,
+ );
+ if (recorded) {
+ controller = 'intelligence';
+ updated++;
+ }
+ } catch {
+ // Intelligence init failed (missing embeddings backend etc.). Fall
+ // through to the memory-store write below β€” that always succeeds via
+ // sql.js fallback so feedback is never fully lost.
}
- // Also record in ReasoningBank for pattern reinforcement
+ // Optional pattern store: if the caller supplied learned patterns,
+ // add them to LocalReasoningBank via its real `.store()` method (the
+ // one method that DOES exist on the class).
const reasoningBank = registry.get('reasoningBank');
- if (reasoningBank) {
- try {
- if (typeof reasoningBank.recordOutcome === 'function') {
- await reasoningBank.recordOutcome({
- taskId: options.taskId, verdict: options.success ? 'success' : 'failure',
- score: options.quality, timestamp: Date.now(),
- });
- controller = controller === 'none' ? 'reasoningBank' : `${controller}+reasoningBank`;
- updated++;
- } else if (typeof reasoningBank.record === 'function') {
- await reasoningBank.record(options.taskId, options.quality);
- controller = controller === 'none' ? 'reasoningBank' : `${controller}+reasoningBank`;
- updated++;
- }
- } catch { /* API mismatch β€” skip */ }
+ if (reasoningBank && Array.isArray(options.patterns) && options.patterns.length) {
+ for (const pattern of options.patterns) {
+ try {
+ if (typeof reasoningBank.store === 'function') {
+ reasoningBank.store({
+ id: `feedback-pattern-${options.taskId}-${updated}`,
+ content: pattern,
+ category: options.agent || 'general',
+ confidence: options.quality,
+ source: 'bridge-feedback',
+ });
+ updated++;
+ }
+ } catch { /* pattern rejected β€” non-critical */ }
+ }
+ if (updated > 0 && controller === 'intelligence') controller = 'intelligence+reasoningBank';
+ else if (updated > 0 && controller === 'none') controller = 'reasoningBank';
}
// Phase 4: SkillLibrary promotion for high-quality patterns