Total Patterns: 3,000
Strategic Links: 20,494
Database Size: 8.92 MB
Query Latency: 1.13 ms (avg)

Pattern Distribution:
  ✓ Success Strategies: 1,400 (46.7%)
  ✗ Failure Learnings: 1,200 (40.0%)
  ⚡ Parallel MaTTS: 500 (16.7%)
  🔄 Sequential MaTTS: 500 (16.7%)

Confidence Metrics:
  Avg Confidence: 88.0%
  Avg Success Rate: 59.5%

Domain Coverage:
  - web-automation: 496 patterns
  - api-integration: 499 patterns
  - data-processing: 516 patterns
  - system-design: 475 patterns
  - testing: 498 patterns
  - deployment: 516 patterns

"Use CSS selector #login-button to log in"

"Chain selector strategies: try CSS → XPath → text-content fallback.
Rationale: CSS selectors break across website versions. Fallback
hierarchy increases robustness from 71% to 94%."

description: "Assuming synchronous API behavior when operations are actually async"
domain: "api-integration"
outcome_analysis: "Polled too early, got stale data 63% of time.
                   Solution: Implemented webhook callbacks instead."
success_rate: 0.18  # Low rate indicates this is a failure mode to avoid
confidence: 0.92    # High confidence we should NOT do this

description: "Generate 5 diverse selector strategies simultaneously,
              use first successful match"
strategy: "parallel"
outcome_analysis: "Parallel attempt with CSS, XPath, text-content, ARIA,
                   data-testid. Success rate: 96% vs 74% sequential."

description: "Iteratively refine web scraping xpath by analyzing failure patterns"
strategy: "sequential"
outcome_analysis: "Start generic, analyze missed elements, refine selector.
                   Converged to 98% accuracy in 4 iterations."

# Navigate to model directory
cd /workspaces/claude-code-flow/docs/reasoningbank/models/google-research

# The model is ready to use (memory.db)

# Using claude-flow CLI
npx claude-flow@alpha memory search "web-automation success" \
  --namespace google-research \
  --reasoningbank \
  --limit 10

# Or query directly with SQL
sqlite3 memory.db "
  SELECT description, outcome_analysis, confidence
  FROM patterns
  WHERE domain = 'web-automation'
    AND strategy_type = 'success'
  ORDER BY confidence DESC
  LIMIT 5;
"

# Find failure patterns to avoid
sqlite3 memory.db "
  SELECT description, outcome_analysis, success_rate
  FROM patterns
  WHERE strategy_type = 'failure'
    AND domain = 'api-integration'
  ORDER BY confidence DESC;
"

# Parallel strategies for fast solution exploration
sqlite3 memory.db "
  SELECT description, outcome_analysis
  FROM patterns
  WHERE mats_mode = 'parallel'
  LIMIT 10;
"

# Sequential strategies for iterative refinement
sqlite3 memory.db "
  SELECT description, outcome_analysis
  FROM patterns
  WHERE mats_mode = 'sequential'
  LIMIT 10;
"

# Get strategy refinement chains
sqlite3 memory.db "
  SELECT
    p1.description AS original_strategy,
    pl.link_type,
    p2.description AS related_strategy,
    pl.strength
  FROM patterns p1
  JOIN pattern_links pl ON p1.id = pl.source_id
  JOIN patterns p2 ON pl.target_id = p2.id
  WHERE p1.domain = 'system-design'
  ORDER BY pl.strength DESC
  LIMIT 10;
"

# Store decision using Google Research patterns
npx claude-flow@alpha memory store \
  "project/decision/authentication" \
  "Using OAuth2 with JWT tokens based on google-research pattern #427" \
  --namespace project \
  --reasoningbank

# Query for similar past decisions
npx claude-flow@alpha memory search "authentication oauth jwt" \
  --namespace project \
  --reasoningbank

-- High-confidence success strategies
SELECT description, domain, success_rate, confidence
FROM patterns
WHERE strategy_type = 'success'
  AND success_rate > 0.90
  AND confidence > 0.85
ORDER BY success_rate DESC, confidence DESC;

-- High-confidence failure patterns (what to avoid)
SELECT description, domain, outcome_analysis, success_rate
FROM patterns
WHERE strategy_type = 'failure'
  AND confidence > 0.85
ORDER BY success_rate ASC;  -- Lowest success = most critical to avoid

-- Find strategies that work across multiple domains
SELECT
  tags,
  COUNT(DISTINCT domain) as domain_count,
  AVG(success_rate) as avg_success,
  GROUP_CONCAT(DISTINCT domain) as domains
FROM patterns
WHERE strategy_type = 'success'
GROUP BY tags
HAVING domain_count >= 3
ORDER BY avg_success DESC;

-- When to use parallel vs sequential MaTTS
SELECT
  mats_mode,
  AVG(success_rate) as avg_success,
  AVG(confidence) as avg_confidence,
  COUNT(*) as pattern_count
FROM patterns
WHERE mats_mode IN ('parallel', 'sequential')
GROUP BY mats_mode;

-- Core pattern storage
CREATE TABLE patterns (
  id INTEGER PRIMARY KEY,
  description TEXT NOT NULL,
  tags TEXT NOT NULL,
  confidence REAL DEFAULT 0.5,
  success_rate REAL DEFAULT 0.5,
  usage_count INTEGER DEFAULT 0,
  domain TEXT NOT NULL,
  strategy_type TEXT NOT NULL,    -- success, failure, closed-loop
  mats_mode TEXT NOT NULL,         -- parallel, sequential, adaptive, iterative
  outcome_analysis TEXT,           -- Why this strategy worked/failed
  created_at INTEGER,
  updated_at INTEGER
);

-- Semantic embeddings for vector search
CREATE TABLE pattern_embeddings (
  pattern_id INTEGER PRIMARY KEY,
  embedding BLOB NOT NULL,         -- 384-dim float32 vector
  FOREIGN KEY (pattern_id) REFERENCES patterns(id)
);

-- Strategic relationships between patterns
CREATE TABLE pattern_links (
  source_id INTEGER NOT NULL,
  target_id INTEGER NOT NULL,
  link_type TEXT NOT NULL,         -- refines, contradicts, complements, requires
  strength REAL DEFAULT 0.5,
  created_at INTEGER,
  PRIMARY KEY (source_id, target_id, link_type)
);

-- Paper-specific indexes for strategy-level queries
CREATE INDEX idx_patterns_strategy_type ON patterns(tags)
  WHERE tags LIKE '%strategy%';
CREATE INDEX idx_patterns_outcome ON patterns(success_rate, confidence);
CREATE INDEX idx_embeddings_semantic ON pattern_embeddings(pattern_id);
CREATE INDEX idx_links_type ON pattern_links(link_type);

@article{zhou2025reasoningbank,
  title={ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory},
  author={Zhou, Haotian and Wang, Xin and Song, Jiajun and Chen, Xiaohan
          and Hao, Shibo and Yue, Xiang and Zha, Zhiwei and Zhu, Wenwu},
  journal={arXiv preprint arXiv:2509.25140},
  year={2025}
}