π 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(bridge): wire bridgeRecordFeedback to real intelligence.recordTrajectory (#2786 fix-3)
ruv469a901edaf6
diff --git a/scripts/loop-checkpoint.mjs b/scripts/loop-checkpoint.mjsnew file mode 100755index 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.tsindex 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