// Re-export ReasoningBank plugin for npm package users
export * as reasoningbank from "./reasoningbank/index.js";

// Import from agentic-flow package
import { reasoningbank } from 'agentic-flow';

// Initialize
await reasoningbank.initialize();

// Run task with memory
const result = await reasoningbank.runTask({
  taskId: 'task-001',
  agentId: 'agent-web',
  query: 'Login to admin panel',
  executeFn: async (memories) => {
    console.log(`Retrieved ${memories.length} memories`);
    // ... execute task with memories
    return { steps: [...], metadata: {} };
  }
});

console.log(`Verdict: ${result.verdict.label}`);
console.log(`New memories: ${result.newMemories.length}`);

# Run hooks directly
npx agentic-flow hooks pre-task --query "Login to admin panel"
npx agentic-flow hooks post-task --task-id task-001

# Run integration test
npx agentic-flow reasoningbank test-integration

# Run benchmarks
npx agentic-flow reasoningbank benchmark

npm install agentic-flow

# TypeScript execution
npx tsx node_modules/agentic-flow/dist/reasoningbank/test-integration.js

✅ Database connection
✅ Schema verification (10 tables, 3 views)
✅ Memory insertion
✅ Memory retrieval
✅ Usage tracking
✅ Metrics logging
✅ Database views

✅ Inserted 5 test memories
✅ Retrieval with domain filtering (3 candidates)
✅ Cosine similarity validation

✅ Database connection: 0.001ms (1.6M ops/sec)
✅ Config loading: 0.000ms (2.6M ops/sec)
✅ Memory insertion: 1.175ms (851 ops/sec)
✅ Batch insertion (100): 111.96ms (1.120ms/memory)
✅ Retrieval (no filter): 3.014ms (332 ops/sec)
✅ Retrieval (domain filter): 0.924ms (1083 ops/sec)
✅ Usage increment: 0.047ms (21K ops/sec)
✅ Metrics logging: 0.070ms (14K ops/sec)
✅ Cosine similarity: 0.005ms (208K ops/sec)
✅ View queries: 0.130ms (7.6K ops/sec)
✅ getAllActiveMemories: 1.117ms (895 ops/sec)
✅ Scalability test: 1000 memories inserted successfully

✅ Initialization complete
✅ Full task execution (retrieve → judge → distill)
✅ Memory retrieval working
✅ MaTTS parallel mode (3 trajectories)
✅ Database statistics

npm run build

export ANTHROPIC_API_KEY=sk-ant-...  # For LLM-based judge/distill
export OPENAI_API_KEY=sk-...     # Optional: for real embeddings
export REASONINGBANK_ENABLED=true
export CLAUDE_FLOW_DB_PATH=.swarm/memory.db

sqlite3 .swarm/memory.db < src/reasoningbank/migrations/000_base_schema.sql
sqlite3 .swarm/memory.db < src/reasoningbank/migrations/001_reasoningbank_schema.sql

{
  "hooks": {
    "preTaskHook": {
      "command": "tsx",
      "args": ["src/reasoningbank/hooks/pre-task.ts", "--task-id", "$TASK_ID", "--query", "$QUERY"]
    },
    "postTaskHook": {
      "command": "tsx",
      "args": ["src/reasoningbank/hooks/post-task.ts", "--task-id", "$TASK_ID"]
    }
  }
}

# Test integration
npx tsx src/reasoningbank/test-integration.ts

# Run benchmarks
npx tsx src/reasoningbank/benchmark.ts

# Check CLI export
node -e "import('agentic-flow').then(m => console.log(Object.keys(m.reasoningbank)))"

// Core algorithms
export { retrieveMemories, formatMemoriesForPrompt } from './core/retrieve.js';
export { judgeTrajectory } from './core/judge.js';
export { distillMemories } from './core/distill.js';
export { consolidate, shouldConsolidate } from './core/consolidate.js';
export { mattsParallel, mattsSequential } from './core/matts.js';

// Utilities
export { computeEmbedding, clearEmbeddingCache } from './utils/embeddings.js';
export { mmrSelection, cosineSimilarity } from './utils/mmr.js';
export { scrubPII, containsPII } from './utils/pii-scrubber.js';
export { loadConfig } from './utils/config.js';

// Database
export { db } from './db/queries.js';
export type {
  ReasoningMemory,
  PatternEmbedding,
  TaskTrajectory,
  MattsRun,
  Trajectory
} from './db/schema.js';

// Main functions
export async function initialize(): Promise<void>;
export async function runTask(options): Promise<{
  verdict: Verdict;
  usedMemories: RetrievedMemory[];
  newMemories: string[];
  consolidated: boolean;
}>;

// Version info
export const VERSION = '1.0.0';
export const PAPER_URL = 'https://arxiv.org/html/2509.25140v1';

# Initialize and test
npx tsx src/reasoningbank/test-integration.ts

# Run benchmarks
npx tsx src/reasoningbank/benchmark.ts

# Test retrieval
npx tsx src/reasoningbank/test-retrieval.ts

# Test database
npx tsx src/reasoningbank/test-validation.ts

# Pre-task: Retrieve memories
npx tsx src/reasoningbank/hooks/pre-task.ts \
  --task-id task-001 \
  --query "Login to admin panel" \
  --domain web \
  --agent agent-web

# Post-task: Learn from execution
npx tsx src/reasoningbank/hooks/post-task.ts \
  --task-id task-001 \
  --trajectory-file trajectory.json

import { reasoningbank } from 'agentic-flow';

// Initialize plugin
await reasoningbank.initialize();

// Retrieve memories for a task
const memories = await reasoningbank.retrieveMemories(
  'How to handle CSRF tokens?',
  { domain: 'web', k: 3 }
);

// Judge a trajectory
const verdict = await reasoningbank.judgeTrajectory(
  trajectory,
  'Login to admin panel'
);

// Distill new memories
const memoryIds = await reasoningbank.distillMemories(
  trajectory,
  verdict,
  'Login task',
  { taskId: 'task-001', agentId: 'agent-web' }
);

// Check if consolidation needed
if (reasoningbank.shouldConsolidate()) {
  const result = await reasoningbank.consolidate();
  console.log(`Pruned ${result.itemsPruned} old memories`);
}

governance:
  tenant_scoped: true