05 Apr 20:40

RMANOV

97c40e1

v3.4.0 — Causal Ledger, Bug Hunt Hardening, and 54 MCP Tools Latest

Latest

v3.4.0 — Causal Ledger, Bug Hunt Hardening, and 54 MCP Tools

sqlite-memory-mcp is now at v3.4.0.

This release adds an event-backed causal ledger for memory integrity,
file attachments, and 12 bug fixes from a systematic bug hunt across
the merge engine, FTS triggers, and audit system.

Deltas since v3.3.3

MCP tool count: 50 → 54
intelligence server: 8 → 12 tools
test count: ~190 → 244
codebase: ~35,000 lines across 7 focused servers

New features

Causal ledger and event-backed repair

A memory_events table now records every task mutation with Lamport
clocks and machine IDs. rebuild_task_from_events() can replay the
event stream to detect and repair drift between the task row and its
recorded history. Fact governance (govern_fact) supports supersede,
contradict, invalidate, and revalidate actions with bidirectional
provenance links.

File attachments

Tasks can now have file attachments stored in a dedicated
task_attachments table. The bridge export/import pipeline syncs
attachments across machines. Path traversal is defended via
_resolve_attachment_path() with Path.resolve() + parent check.

Extended memory file split

The 13 extended memory sections (memory_events, conflicts, audit
issues, artifacts, context chunks, etc.) are now exported to
individual extended_memory/<key>.json files instead of being
embedded in shared.json. This reduced shared.json from 28 MB to
5 MB and unblocked Cloudflare Pages deploys.

Bug Hunt system

A structured bug hunting methodology with 6 questionnaire documents
and 81 checkpoints, tracked in docs/bug_hunt/. Includes run
registries, checkpoint logs, and cluster analysis per wave.

Hardening: 12 bugs fixed from Bug Hunt Phase 1 and 2

Merge safety (6 fixes)

tombstone materialization no longer silently drops tasks with
title=None (TS-01)
tombstone status "done" is preserved instead of forced to "archived"
(TS-02)
NULL-fill now respects the import_content=False flag, preventing
content from arriving during metadata-only sync (PF-02)
status authority corrections are no longer overwritten by LWW
(PF-01)
future timestamps from clock-skewed machines are clamped to now
instead of permanently winning all merges (LW-02)
extended memory import uses not payload.get(key) instead of
== [], handling null and other falsy values correctly (EM-01)

FTS and audit (4 fixes)

observations table now has INSERT and DELETE triggers that update
memory_fts, fixing entity search by observation content (FT-01,
FT-02)
entity UPDATE trigger now aggregates observation text instead of
inserting an empty string
rebuild_task_from_events(repair=True) now records its changes in
memory_events so repairs are auditable (EB-03)
the audit repair guard no longer blocks on manually advanced
updated_at timestamps (EB-01)

Infrastructure (2 fixes)

merge events are now recorded in memory_events so the audit trail
sees cross-machine merges (PF-03)
schema migrations run under the same BEGIN EXCLUSIVE lock as table
creation, preventing a race where two concurrent init_db() calls
could both attempt the same ALTER TABLE (SM-01)

Sync improvements in the v3.3.4–v3.4.0 line

cross-machine merge ordering hardened with event-authoritative task
status resolution
tombstone and legacy task ID preservation during merge
auto-heal for bridge content shrink (restores richer content from
bridge files when local content was suspiciously truncated)
bridge push identity failure prevention
periodic pull no longer triggers a push
project alias normalization in the tray UI
centralized bridge import/merge helpers in db_utils.py
bridge sync lock moved outside the git repo to prevent lock file
conflicts

Architecture today

server.py: 9 core memory tools
task_server.py: 6 task tools
session_server.py: 5 session/context tools
bridge_server.py: 6 bridge/task-sharing tools
collab_server.py: 9 collaboration/public-knowledge tools
entity_server.py: 7 entity-linking and merge tools
intel_server.py: 12 intelligence tools (was 8 at v3.3.3)
unified_server.py: optional all-in-one server exposing the full
54-tool set

Upgrade notes

existing databases migrate forward automatically; the new
memory_events, memory_cursors, task_attachments, and related
tables are created on first init_db() call
the FTS observation triggers are applied via migration to existing
databases
shared.json shrinks significantly after the first bridge push;
extended memory data moves to extended_memory/ files
users on pre-v3.3.3 releases should read the v3.3.3 release notes
for the server split and hardening context

Summary

v3.4.0 adds structural integrity guarantees through the causal event
ledger, fixes 12 confirmed bugs found via systematic questionnaire-
driven analysis, and grows the tool surface to 54 while keeping the
same local-first SQLite/WAL foundation.

Assets 2

20 Mar 11:18

RMANOV

v3.2.0

6153e19

v3.2.0 — Task-Relevant Intelligence

SQLite Memory MCP Server v3.2.0 — Task-Relevant Intelligence

A persistent memory layer designed for human–AI collaboration.

Every feature in this project exists to solve one problem: Claude forgets between sessions. sqlite-memory-mcp gives Claude a knowledge graph, task tracking, and hybrid search — so that the human and AI can build on previous work instead of starting from scratch every conversation.

v3.2.0 solves the next problem: context relevance. Before this release, every task saw the same intelligence panel — all facts, all claims, all chunks, globally. Now context packs are scoped to the task: only the knowledge that matters for this specific task appears.

NEW: Task-Relevant Context Packs

build_context_pack(target_ref="<task_id>") now returns content filtered and ranked by relevance to that specific task.

Before: Task A (accounting report) and Task B (UI refactor) both saw the same 40 facts about everything in the knowledge graph. The Intelligence panel was noise.

After: Task A sees facts about financial reports, BG GAAP, and ReportsGenerator. Task B sees facts about PyQt6, task_tray.py, and widget patterns. Each task gets its own relevant slice of the knowledge graph.

Pipeline:

Task (title + project + description + notes)
    ↓ tokenize
FTS5 keyword search ──┐
                      ├── RRF Merge → 6-signal Rerank → relevant entity names
vec0 KNN semantic  ───┘
    ↓
Filter facts/claims/chunks by matching entity names
    ↓ score = confidence × role_weight × relevance
Greedy budget fill → task-scoped context pack

3 new helpers: _build_task_query(), _find_relevant_entities(), _format_ts()
Timestamps on every item: [2026-03-18 14:30] [FACT] SQLite Memory uses WAL mode
Graceful fallback chain: task not found → no FTS results → no linked entities → global pack (backwards compatible)
Facts/claims filtered by subject ∈ relevant_entities
Questions/chunks filtered by entity name overlap in text body
Linked entities (via task_entity_links) always included with base score 0.5

NEW: Unified Task Search Engine

task_search.py — a dedicated search engine for tasks, combining FTS5 keyword matching with optional vector similarity via RRF fusion.

Consistency layer: exact-match verification eliminates phantom FTS5 results
GUI-safe: vector search disabled in UI context to prevent model-loading freezes
Single engine shared across all query_tasks calls

NEW: Async Entity Search in Task Tray

Entity search is now integrated into all Task Tray search bars with pre-cached enrichment.

EntityLinkDialog search runs async — no more UI freezes on large knowledge graphs
Entity results pre-cached on dialog open for instant filtering
All task detail views can link/unlink entities inline

Bug Fixes: 98 fixes across 2 hunt waves

Bug Hunt v13 (33 fixes, 13 files)

Bug Hunt v14 (22 fixes, 9 files)

Bug Hunt v15 (43 fixes, 13 files)

Key fixes:

Leaked DB connections in Task Tray UI dialogs — conn.close() added to all dialog destructors
sqlite3.Row → dict conversion in serialize_entity to support .get() access
Overdue color signaling matched between TrayPopup and FullWindow
FTS5-first strategy for GUI search prevents crash when vector deps unavailable

Tool Rename: `create_task` → `create_task_or_note`

The dual-purpose tool (type=task | type=note) was renamed so Claude correctly discovers it for both task creation and note-taking use cases.

Task Tray UI Overhaul (+983 lines)

Major expansion of the system tray desktop application:

Per-tab filtered views with section-aware rendering
Unified tooltip and clipboard copy across all item types
Business palette consistency (dark blue, grey, black, white)
Improved recurring task and reminder handling

Why this matters for human–AI collaboration

Before v3.2.0	After v3.2.0
Intelligence panel shows same content for every task	Each task gets its own relevant knowledge slice
No timestamps — impossible to judge freshness	Every item timestamped `[YYYY-MM-DD HH:MM]`
Task search = basic SQL LIKE	Task search = FTS5 + vector + RRF fusion
Entity linking = separate workflow	Entity search integrated into task detail views
`create_task` name hides note-creation capability	`create_task_or_note` discoverable for both use cases

Stats

Metric	Value
MCP tools	50
Python lines	20,869
Commits since v3.1.0	21
Files changed	18
Lines added	+1,891
Lines removed	-361
Bug fixes	98 (across v13, v14, v15 hunt waves)

Breaking changes: create_task renamed to create_task_or_note. Update settings.json auto-approve entries accordingly. All other APIs are 100% backward compatible.

Assets 2

18 Mar 12:10

RMANOV

v3.1.0

3be36e6

v3.1.0 — Hybrid Semantic Search

SQLite Memory MCP Server v3.1.0 — Hybrid Semantic Search

A persistent memory layer designed for human–AI collaboration.

Every feature in this project exists to solve one problem: Claude forgets between sessions. sqlite-memory-mcp gives Claude a knowledge graph, task tracking, and now semantic search — so that the human and AI can build on previous work instead of starting from scratch every conversation.

v3.1.0 adds the missing piece: semantic understanding. Before this release, Claude could only find what it remembered by exact keywords. Now it finds concepts by meaning.

NEW: Hybrid Search (BM25 + Semantic + Graph)

search_nodes("puppy") now finds entity "Dog" — even though the word "puppy" appears nowhere in the knowledge graph. FTS5 keyword search returns nothing; sqlite-vec cosine similarity returns Dog at distance 0.88.

This matters for real collaboration: when you ask Claude about "финансови отчети" (financial reports), it should find "ReportsGenerator" — even without an explicit relation in the graph.

Pipeline:
```
Query → FTS5 BM25 ──┐
├── RRF Merge → 6-signal Rerank → Results
Query → vec0 KNN ───┘
```

Reciprocal Rank Fusion (k=60) merges keyword + semantic rankings — entities found by both sources get a natural boost
6-signal re-ranker on top: recency, project affinity, graph proximity, observation richness, canonical facts, active session context
Embedding model: `all-MiniLM-L6-v2` (384-dim, ~90MB, Apache 2.0)
`sqlite-vec`: pure C, zero deps, ~2MB — replaces deprecated sqlite-vss
Fully optional: without the vector dependencies, behavior is identical to v3.0.0
Latency: ~21ms per search (50 entities, full pipeline)

Enable semantic search

```bash
pip install sqlite-vec sentence-transformers

or: pip install sqlite-memory-mcp[vector]

```

Why this matters for human–AI collaboration

Before v3.1.0	After v3.1.0
Claude finds only exact keyword matches	Claude finds concepts by meaning
"What did we discuss about dogs?" → misses "Пес" (Bulgarian for dog)	Semantic match finds related entities across languages
Orphan entities invisible without explicit relations	Vector proximity surfaces semantically close nodes
FTS5 or nothing	BM25 + Vector + Graph — triple coverage, single file

The knowledge graph becomes genuinely useful at scale: with 500+ entities, keyword search alone misses too much. Semantic search closes the gap between what the human meant and what Claude stored.

Also in this release (since v3.0.0)

Architecture

7 micro-servers — split from monolithic server.py for Claude Code tool visibility limit
`db_utils.py` extraction — shared helpers, -280 LOC from server.py
50 MCP tools across 7 domain servers

Search & Intelligence

3-layer context enrichment: smart retrieval (L1) + lazy enrichment (L2)
`auto_layer1` promotion mode with chunk→fact impact edges
Lazy inline claim extraction on entity writes

Bridge & Sync

Auto-sync after MCP writes (60s debounce)
Entity loss prevention during cross-machine sync
Eliminated bridge push spam

UI (Task Tray)

Per-tab views + single-instance launcher
Unified tooltip & clipboard copy
Business palette consistency

Competitive position

No other MCP memory server combines all three search modalities — the three ways a human might look for something — in a single file:

Server	Keywords (BM25)	Meaning (Vector)	Connections (Graph)	Single file
sqlite-memory-mcp	✓	✓	✓	✓
Official MCP Memory	✗	✗	✗	✓
ChromaDB (mcp-memory-service)	✗	✓	✗	✗
Qdrant (memsearch)	✗	✓	✗	✗
Neo4j (MemoryGraph)	✗	✗	✓	✗

Stats

Metric	Value
MCP tools	50
DB tables	34
Python lines	17,108
Tests	120
Changes since v3.0.0	21 files, +7,893 / -5,271 lines

Breaking changes: None. 100% backward compatible with v3.0.0.

Assets 2

13 Mar 12:51

RMANOV

v3.0.0

902e6a9

v3.0.0 — Intelligence v2: The Knowledge Sovereignty Engine

  ╔══════════════════════════════════════════════════════════════╗
  ║                                                              ║
  ║   ███████╗ ██████╗ ██╗     ██╗████████╗███████╗             ║
  ║   ██╔════╝██╔═══██╗██║     ██║╚══██╔══╝██╔════╝             ║
  ║   ███████╗██║   ██║██║     ██║   ██║   █████╗               ║
  ║   ╚════██║██║▄▄ ██║██║     ██║   ██║   ██╔══╝               ║
  ║   ███████║╚██████╔╝███████╗██║   ██║   ███████╗             ║
  ║   ╚══════╝ ╚══▀▀═╝ ╚══════╝╚═╝   ╚═╝   ╚══════╝             ║
  ║                                                              ║
  ║         M E M O R Y   M C P   S E R V E R                   ║
  ║                                                              ║
  ║              v 3 . 0 . 0                                     ║
  ║                                                              ║
  ║     ─── Intelligence v2: Knowledge Sovereignty ───           ║
  ║                                                              ║
  ╚══════════════════════════════════════════════════════════════╝

The Philosophy

"The problem is not retrieval. It is coordination — how human and Claude work on the same context fragments without polluting canonical memory with weak inferences."

v3.0.0 fundamentally changes the relationship between AI and knowledge. Previous versions let Claude freely write to memory. Intelligence v2 introduces human sovereignty — a principled architecture where AI proposes, humans confirm, and knowledge earns its way from raw context to canonical truth through evidence and governance gates.

The shift: v2: "store everything" --> v3: "manage the validity, boundaries, and impact of knowledge"

What Is New

Intelligence v2 — The Knowledge State Machine

A complete context lifecycle management system built on 6 core principles:

Principle	What It Means
Human Sovereignty	No enrichment by default. Opt-in only via signal phrases
No Silent Mutation	AI never writes "truths" at first inference. Claims require governance
Uncertainty First	If Claude does not understand — it asks, not guesses
Delta-Aware	Same unresolved source + same hash = skip, do not reprocess
Bridge-Aware	Knows which sessions/snapshots/mappings can be affected
Materiality Over Volume	Accounting invariants > mapping correctness > bridge > export

4-Tier Knowledge Pipeline

 Raw Context        Managed Context       Candidate Claims       Canonical Facts
+--------------+   +-----------------+   +-------------------+   +------------------+
| Chunks,      |-->| State machine,  |-->| Typed SPO tuples, |-->| Validated, safe  |
| notes,       |   | signals, policy |   | evidence attached |   | for downstream   |
| descriptions |   |                 |   |                   |   |                  |
+--------------+   +-----------------+   +-------------------+   +------------------+
                                                                         |
                    <---- GOVERNANCE GATE ---->                           |
                    human_confirmed | multi_evidence                      v
                                                               Impact propagation
                                                               to sessions, mappings,
                                                               validations, exports

Context State Machine

Every context chunk follows a strict lifecycle:

no_enrich --[ENRICH_OK]--> enrichable --[AI parse]--> uncertain --> awaiting_human
    |                          |                                         |
    |                          +--[claims extracted]--> candidate ----> validated
    |                          |
    +--[FREEZE_CONTEXT]--> frozen (immutable)
    +--[age/evidence]--> stale --> archived

Signal phrases control transitions: ENRICH_OK, NO_ENRICH, WAIT_HUMAN, FREEZE_CONTEXT

9 New MCP Tools (49 total)

Tool	Purpose
`assess_context`	Classify chunk, detect signals, compute materiality + uncertainty
`queue_clarification`	Generate typed AWAITING_HUMAN questions, lock chunk
`record_human_answer`	Ingest answer, resolve questions, transition state
`extract_candidate_claims`	Typed (Subject, Predicate, Object, Scope) extraction
`promote_candidate`	Governance gate to canonical fact (human or multi-evidence)
`build_context_pack`	Role-specific context (planner/reviewer/executor/bridge/handoff)
`explain_impact`	BFS downstream propagation — what breaks if this changes?
`resume_context`	Session continuity — handoff pack + open questions + changed facts
`enrich_context`	Compatibility wrapper (quick / standard / deep)

9 New Tables (22 total)

context_chunks          — managed text fragments with lifecycle state
context_annotations     — human/AI/system annotations with provenance
context_questions       — structured clarification queue
candidate_claims        — provisional (S, P, O, scope) knowledge
claim_evidence          — provenance graph linking claims to sources
canonical_facts         — validated knowledge, safe for downstream use
context_packs           — compiled role-specific context with token budgets
impact_edges            — downstream impact graph (BFS-traversable)
enrichment_runs         — complete audit trail of every tool invocation

Architecture: 4 New Modules

sqlite_memory/
  intelligence_v2.py      <-- Core state machine, signals, assess/queue/answer (838 lines)
  claim_graph.py           <-- SPO extraction + evidence + governance gates (423 lines)
  context_packer.py        <-- Greedy coverage pack compiler (399 lines)
  impact_graph.py          <-- Weighted BFS impact propagation (242 lines)
  intelligence_config.json <-- Toggles, thresholds, scope policies

Also In This Release

Bridge Sync v2 — Per-Field LWW CRDT

Per-task files (tasks/{id}.json) replace monolithic shared.json task list
Per-field Last-Write-Wins with (timestamp, machine_id) comparison
Cloudflare Pages deploy after git push for instant Kanban board updates
Safety valve blocks push if >10 content fields would be removed

Knowledge Collaboration v2

P2P publishing with request_publish / cancel_publish
TruthScore rating system — unhackable composite quality metric
Burst detection for rating anomalies
Entity merge with observation/relation/task-link preservation

Task Tray UI Overhaul

SmartKey fuzzy search with CVM personal boost across all fields
3-state filter chips (include/exclude/off)
Reading mode v2.1 — Kindle Dark typography (+30% font, optimized line spacing)
Status field in task dialog + notes visible in all tabs
TaskDAO centralization — all SQL extracted from UI to data layer

Hardening and Quality

66 new tests — TaskDAO (32), LWW merge (17), bridge export (17)
5-phase safety overhaul — atomic transactions, retry, NULL-fill, timestamp validation
17 bug fixes from structured code review across 5 waves
5 root cause generators eliminated (bug hunt v5)

By The Numbers

        +-------------------------------------+
        |        v0.9.0  -->  v3.0.0          |
        +-------------------------------------+
        |  Commits         58                  |
        |  Files changed   19                  |
        |  Lines added     +9,682              |
        |  Lines removed   -1,200              |
        |  Net growth      +8,482              |
        |                                      |
        |  MCP Tools       31 --> 49 (+58%)    |
        |  DB Tables       13 --> 22 (+69%)    |
        |  Test Coverage   0 --> 66 tests      |
        |  New Modules     +5 files            |
        |                                      |
        |  Workstreams     8 merged            |
        |  Bug Hunts       v1-v7 complete      |
        |  Code Reviews    3 full-system       |
        +-------------------------------------+

Workstream Archaeology

Every feature was developed on an isolated branch, merged --no-ff, tagged, and deleted:

Tag	What
`ws/PHASE0-SAFETY`	Atomic writes, retry logic, NULL-fill, timestamp validation
`ws/PHASE1-DAO`	TaskDAO extraction — centralize all SQL in db_utils.py
`ws/PHASE2-PACKAGING`	pip install, build backend, console scripts
`ws/PHASE3-SYNC`	Safety check ordering, clock skew detection, LWW honesty
`ws/PHASE4-TESTS`	66 tests for DAO, merge, and bridge export
`ws/MEMORY-MCP-REVIEW`	17 confirmed fixes across 5 review waves
`ws/TASK-TRAY-OPTIMIZATION`	TaskDAO in UI, status field, notes in all tabs
`ws/INTELLIGENCE-V2`	Context state machine + knowledge tiers (crown jewel)

Configuration

{
  "enabled": true,
  "default_enrich_policy": "manual",
  "respect_signal_phrases": true,
  "skip_same_unresolved_source": true,
  "max_questions_per_chunk": 5,
  "auto_promote_scopes": ["memory"],
  "human_required_scopes": ["mapping", "validation", "bridge", "export"],
  "context_pack_token_budget_default": 4000
}

intelligence_config.json — safe defaults if missing. enabled: false disables all 9 tools gracefully.

Migration

Automatic. 23 migration entries in _MIGRATIONS handle schema evolution from any previous version. New tables are created via both _SCHEMA_SQL (fresh installs) and migrations (existing DBs). Zero manual intervention required.

Rollback. Pre-upgrade snapshot recommended:

python -c "import sqlite3,os; c=sqlite3.connect(os.path.expanduser('~/.claude/memory/memory.db')); c.execute('PRAGMA wal_checkpoint(TRUNCATE)'); c.close()"
cp ~/.claude/memory/memory.db ~/.claude/memory/memory.db.pre-v3-snapshot

...

Assets 2

08 Mar 08:21

RMANOV

v0.9.0

03d1c7c

v0.9.0 — TruthScore: Quality That Can't Be Gamed

🛡️ TruthScore — Content-Deterministic Quality Ratings

Public knowledge (v0.7.0) gave every human-Claude pair a voice. But a voice without signal is noise.

TruthScore is a cryptographically-bound rating system where the score is a function of content quality — not popularity, not volume, not social proof. You cannot game the score without genuinely improving the knowledge.

What Makes It Robust

Threat	Defense
Vote stuffing	One rating per rater per content version — cryptographic dedup
Self-promotion	Publisher cannot rate their own work — enforced at write time
Content SEO	Algorithm rewards genuine specificity — padding dilutes the score
Volume gaming	Every entity scored independently — publishing more changes nothing
Coordinated attacks	Logarithmic diminishing returns + automatic anomaly detection
Version manipulation	Ratings bound to exact content via SHA256 — edit anything, ratings reset to zero
Identity spoofing	Rater identity set server-side from environment — never from user input
Stale ratings	Content-hash binding auto-invalidates when content changes

New MCP Tools

rate_public_knowledge — Structured quality analysis with anti-gaming enforcement
get_knowledge_ratings — TruthScore breakdown with dimensional analysis
update_verification — Update ratings after testing knowledge in practice

Enhanced Tools

search_public_knowledge — Now supports sort_by (relevance/truth_score/rating_count) and min_truth_score filtering. Every result includes its TruthScore, confidence level, and rating count.
bridge_push/pull — Ratings travel with knowledge across machines, with anti-gaming validation on import
bridge_status — Shows total ratings, rated entities, and unresolved anomalies

Task Tray

Public knowledge items now show color-coded TruthScore badges:

🟢 High quality (>0.7)
🟡 Moderate (0.4–0.7)
🔴 Low (<0.4)
⬜ Unrated

Schema

Two new tables (knowledge_ratings, rating_anomalies), 6 migrations, 4 indexes. Fully backward-compatible — existing databases auto-migrate on startup.

Philosophy

The best anti-spam system is one where gaming requires doing the thing you're pretending to do.

TruthScore doesn't fight bad actors with rules — it makes the rules unnecessary. The only way to get a high score is to publish knowledge that is specific, falsifiable, internally consistent, and novel. The only way to get verified is to have your knowledge tested in practice by independent Claude instances.

The score algorithm is sealed and hardcoded. No configuration. No knobs to turn. No policy to argue about. Just content quality, measured structurally.

Full Changelog: v0.8.0...v0.9.0

Assets 2

08 Mar 07:40

RMANOV

v0.8.0

140b5b9

v0.8.0 — Public Knowledge: Collaborative Intelligence Across Human-Claude Pairs

Public Knowledge — v0.8.0

The collaboration boundary just expanded. Any human-Claude pair can now publish verified knowledge that all other pairs can discover, review, and build upon — forming an emergent mesh of shared understanding across independent collaborations.

Three-Gate Publish Safety

Every piece of public knowledge passes through three safety gates:

Explicit opt-in — safety_confirmed=True required (default: DO NOT publish)
Harm verification — explicit confirmation that content won't endanger anyone
Standby timer — 15-minute cooling period before pending becomes public

No accidental publishing. No bypassing. Safe defaults at every step.

New MCP Tools

Tool	Purpose
`request_publish`	Two-gate safety flow for entities and tasks
`cancel_publish`	Revert during standby period
`search_public_knowledge`	FTS5 BM25-ranked search across public entities

Bridge Integration

Standby promotion — bridge_push auto-promotes after timer elapses
public_knowledge key in shared.json — entities + tasks visible to all
Auto GitHub releases — every push with public content creates a tagged release
bridge_pull — stages incoming public knowledge for review
bridge_status — shows public/pending counts

Task Tray UI

Context menu: Publish / Cancel Publish / Unpublish actions
Dual QMessageBox warnings with safe defaults (Don't Publish pre-selected)
Visual badges in task list for pending and public visibility
Sync integration: standby promotion + public_knowledge export

Schema

visibility TEXT DEFAULT 'private' on entities and tasks
publish_requested_at TEXT on both tables
2 new indexes, 6 auto-migrations for existing databases

The Vision

A human-Claude pair discovers a pattern. They verify it, publish it.
Another pair across the world searches for exactly that — and finds it.
They build on it, refine it, publish the refinement. The mesh grows.

This is networked collaborative intelligence — not just within a single
human-Claude conversation, but across all of them. Each pair contributes to
a growing commons of verified, searchable knowledge. The network effect
compounds: more pairs publishing means more knowledge to discover, which
means better solutions, which means more worth publishing.

535 lines added across 3 files. Zero lines of waste.

Full Changelog: v0.7.0...v0.8.0

Assets 2

08 Mar 06:47

RMANOV

v0.7.0

44f6c70

v0.7.0 — Task Tray: Human + AI Task Management

Efficient human-Claude collaboration for tasks and notes — plus a fully standalone desktop app when you don't need AI.

The Idea

sqlite-memory-mcp gives Claude a persistent memory (knowledge graph + tasks + notes). Task Tray (v0.7.0) adds a professional desktop UI so humans can manage the same data — alongside Claude or completely independently.

Works Two Ways

With Claude — AI creates, prioritizes, and manages tasks via 26 MCP tools. You review and act in Task Tray.
Without Claude — Full standalone task manager. Free alternative to Asana, Notion, Todoist. Your data, your machine.

	Asana	Notion	Todoist	Task Tray
Price	$10.99/mo	$10/mo	$4/mo	Free
Data	Cloud	Cloud	Cloud	Local SQLite
Offline	No	No	Limited	Always
AI collaboration	$$ add-on	$$ add-on	No	Built-in (free)
CLI	No	No	No	Yes
Multi-machine sync	Cloud	Cloud	Cloud	Git (your repo)

What's New in v0.7.0 (17 commits since v0.6.0)

Task Tray Desktop App

System tray + full window dual-mode
8 tabs: Suggested, Today, Inbox, Next, Projects, Notes, All, Done
3 themes: Blue, True Black, Light — dark business palette
Toolbar mega-buttons: Sort ▾ / View ▾ dropdowns (replace 10+ buttons)
Filter chip bar: Priority, Due, Project — one-click filtering
Smart suggestions with priority-aware auto-sorting

Recurring Tasks

Daily, weekly, monthly schedules with auto-recreate
Visual 🔄 indicators + RecurringDialog UI
CLI: `task add "Standup" --recurring '{"every":"week","day":"monday"}'`
MCP tool: `process_recurring_tasks` with dry-run

Per-Machine State Persistence

Sort mode, active tab, filters persist across restarts
Per-machine profiles (`hostname`) synced via bridge
First-run recovery from shared.json on new machine

CLI (`task` command)

```bash
task add "Title" --priority high --due 2026-03-15 --project work
task note "Meeting notes" --content "..."
task done "Title"
task ls [--section today] [--project X]
```

Reliability

Thread-safe SQLite (WAL + autocommit)
DB locking eliminated
Auto-promote tasks when due date arrives
Enum validation at all sync points

Quick Start

Standalone (no Claude):
```bash
pip install PyQt6
python3 task_tray.py
```

With Claude Code (MCP server):
```json
{
"mcpServers": {
"sqlite-memory": {
"command": "python3",
"args": ["/path/to/server.py"]
}
}
}
```

Claude creates tasks → you manage them in Task Tray → both see the same SQLite DB.

Assets 2

06 Mar 11:20

RMANOV

v0.6.0

53164cc

v0.6.0 — Multi-Account P2P Knowledge Collaboration

What's New

P2P Knowledge Sharing (3 new tools → 26 total)

Claude Code instances can now share knowledge through the existing git-based bridge infrastructure:

manage_collaborators — Address book with trust levels (read_only / read_write)
share_knowledge — Queue entities for sharing with priority signals (critical / high / medium / low)
review_shared_knowledge — Staged import with diff / approve / reject actions

Priority-Based P2P Coordination

Shared knowledge carries a priority signal:

Priority	Semantics
`critical`	Adopt immediately, propagate to others
`high`	Important, review soon
`medium`	Standard sharing
`low`	Informational, no urgency

Architecture: Hub-and-Spoke Mailbox Model

Each user controls their own memory-bridge repo. Knowledge flows through shared_knowledge[] in shared.json (v3 format, backward compatible with v2).

Staging is mandatory — all cross-account data enters pending_shared_* tables first
Additive-only merge (CRDT-like) — observations are union'd, never overwritten
Trust tiers control who can push knowledge back
Git credentials = auth layer — no additional auth needed

Schema Changes

4 new tables: collaborators, pending_shared_entities, pending_shared_relations, sharing_rules
2 new columns on entities: shared_by, origin
Auto-migration for existing databases

UI Hotfixes

Suggested tab in FullWindow now preserves overdue-first sort order (was re-sorted by priority only)
Overdue markers (⚠ red background) now visible in FullWindow task lists (previously only in mini popup)

Bridge Enhancements

bridge_push now pushes queued knowledge to collaborator repos
bridge_pull stages incoming shared_knowledge[] with trust verification
bridge_status shows collaborator info, pending knowledge counts, sharing rules
bridge_auto_sync.py tracks all 3 new tool names

Full Changelog: v0.5.0...v0.6.0

Assets 2

06 Mar 09:54

RMANOV

v0.5.1

e6ed79c

v0.5.1 — Bridge for Two: Human Tasks + Claude Knowledge

The memory bridge now serves two audiences through a single shared.json:

┌─────────────────────────────────────────────────┐
│              shared.json (GitHub)                │
├────────────────────┬────────────────────────────┤
│  FOR HUMANS        │  FOR CLAUDE                │
│  ─────────────     │  ──────────────            │
│  Tasks & Notes     │  Entities & Relations      │
│  (actionable,      │  (knowledge graph,         │
│   readable,        │   observations,            │
│   personal)        │   project memory)          │
└────────────────────┴────────────────────────────┘

Human side: Tasks and Notes are what you manage — deadlines, priorities, statuses, descriptions. They sync bidirectionally so you can track work across machines via GitHub Pages Kanban.

Claude side: Entities, Relations, and Observations are Claude's persistent memory — patterns learned, architectural decisions, debugging insights. They travel with you across sessions and machines.

One bridge, two audiences. Both benefit from GitHub sync.

What's new in v0.5.1

Full Bridge Export (was partial)

The bridge sync now exports everything — not just git-tracked changes:

Data	v0.5.0	v0.5.1
Entities + Observations	❌ manual	✅ auto-exported
Relations	❌ not synced	✅ auto-exported
Tasks (non-archived)	❌ not synced	✅ auto-exported
Remote entity import	❌	✅ pull-before-push

Progress Bar

Bridge sync now shows real-time progress in the status bar:

[████████░░░░░░░░░░░░]  40%  Exporting tasks...

Steps: git pull → export entities → export relations → export tasks → write JSON → git add → commit → push.

Pull-Before-Push

Before exporting, the bridge now:

git pull --rebase to get remote changes
Imports new entities from remote shared.json (if any)
Then exports local state and pushes

This prevents overwriting collaborator changes.

QProgressBar Hotfix

Fixed NameError: name 'QProgressBar' is not defined — the import was removed by ruff's F401 rule during a race condition (import added before usage code existed).

Auto-Migration

TaskDB._ensure_table() now detects missing v0.5.0 columns (type, assignee, shared_by, description) and adds them automatically. No manual migration needed.

Windows Console Suppression

CREATE_NO_WINDOW flag prevents git subprocess console flashes on Windows.

Full changelog

e6ed79c feat(ui): full bridge export with progress bar + QProgressBar hotfix

Full diff: v0.5.0...v0.5.1

MIT license.

Assets 2

06 Mar 08:24

RMANOV

v0.5.0

258d638

v0.5.0 — Notes, Collaboration & Shared Task Review

sqlite-memory-mcp now supports persistent Notes (never auto-archived), cross-account task assignment via GitHub, and a security-gated review workflow for incoming shared tasks.

Tool count: 24 (was 21). Total codebase: ~3,400 lines across 8 Python files.

What's new

Notes — Persistent Reference Items

A new type column distinguishes between tasks (actionable, lifecycle-managed) and notes (persistent references — meeting notes, decisions, ideas):

Never auto-archived: archive_done_tasks skips notes entirely
Never purged: 30-day auto-purge in tray UI excludes notes
Always visible: Notes tab in Full Window is always shown (even when empty)
Visual indicators: [N] prefix + blue background in task lists
Bidirectional conversion: Right-click any item → "Convert to Note" / "Convert to Task"

# Create a note
create_task(title="Q1 architecture decisions", type="note")

# Convert existing task to note
update_task(task_id="...", type="note")

# Query notes only
query_tasks(type="note")

Cross-Account Collaboration

Tasks and notes can now be assigned to other GitHub users for collaboration:

Column	Purpose
`assignee`	GitHub username of the person assigned
`shared_by`	Who assigned it (from `git config user.name`)

# Assign a task to another user
assign_task(task_id="...", assignee="colleague-username")
# On next bridge_push, the item is pushed to their memory-bridge repo

How it works:

assign_task() sets assignee + shared_by fields
bridge_push() detects assigned items, groups by assignee
For each assignee: clones github.com/{assignee}/memory-bridge, merges items into shared_tasks key, commits + pushes
Last-write-wins conflict resolution via updated_at

Shared Task Review — Security Gate

Critical security feature: Incoming shared tasks from other accounts are never auto-imported. They are staged in a quarantine table (pending_shared_tasks) and require explicit approval.

# List pending shared tasks
review_shared_tasks(action="list")

# Approve specific tasks (imports them into your tasks table)
review_shared_tasks(action="approve", task_ids=["uuid-1", "uuid-2"])

# Reject (deletes from staging)
review_shared_tasks(action="reject", task_ids=["uuid-1"])

# Approve all pending
review_shared_tasks(action="approve")

This prevents untrusted data injection — no external user can silently add items to your task database.

UI Improvements (post-v0.4.0)

Several tray UI enhancements shipped between v0.4.0 and v0.5.0:

Feature	Description
Search	Real-time search across all tabs in Full Window
Suggested tab	Smart task suggestions (overdue + due today + high priority)
Done tab	Separate tab for completed tasks with 30-day auto-purge
Hide empty tabs	Tabs with no items are hidden (except Suggested + Notes)
Sort by priority	Tasks sorted by priority rank within each tab
Type dropdown	Task/Note selector in both popup and edit dialog
Notes tab	Dedicated tab for notes — always visible
Bridge sync button	Refresh button triggers memory bridge GitHub sync
Wayland fix	Window type changed from Popup to Tool to fix Wayland grab failures
TaskReaderDialog	Double-click to read full task descriptions

Schema Changes

New columns on `tasks` table

type        TEXT NOT NULL DEFAULT 'task',   -- 'task' or 'note'
assignee    TEXT DEFAULT NULL,              -- GitHub username
shared_by   TEXT DEFAULT NULL,              -- who assigned it

New table

CREATE TABLE pending_shared_tasks (
    id          TEXT PRIMARY KEY,
    data        TEXT NOT NULL,     -- JSON blob of the shared task
    shared_by   TEXT,
    received_at TEXT NOT NULL,
    status      TEXT DEFAULT 'pending'  -- pending | approved | rejected
);

New indexes

CREATE INDEX idx_tasks_type ON tasks(type);
CREATE INDEX idx_tasks_assignee ON tasks(assignee);

All migrations run automatically via _MIGRATIONS list (7 entries). Existing rows get type='task' by default.

New Tools

#	Tool	Description
22	`assign_task`	Assign task/note to a GitHub user for collaboration
23	`review_shared_tasks`	List/approve/reject staged shared tasks (security gate)
24	(bridge_push enhanced)	Cross-account push to assignee's memory-bridge repo

Full changelog

258d638 chore: bump version to 0.5.0 in pyproject.toml
b280294 feat: add Notes type, collaboration, and shared task review
22edd88 feat(ui): add memory bridge GitHub sync to Refresh button
1077859 fix(ui): replace Popup with Tool window type to fix Wayland grab failure
394ed6b fix(ui): add description param to add_task() preventing crash
9186504 fix(ui): set explicit white background on TaskReaderDialog scroll area
68fd047 refactor(ui): simplify TaskReaderDialog after review
41f53b4 feat(ui): add TaskReaderDialog for reading long task descriptions
9f6cbd7 feat(ui): add description support to task tray UX
cd631d8 refactor(ui): consolidate DRY violations + redesign TrayPopup
f496bdb feat(ui): show suggested tasks in tray popup
870cee9 feat(ui): add search, suggested tab, sort, and hide empty tabs
728b41f feat(ui): separate Done tab with 30-day auto-purge
5f0a3da fix(bridge): merge all *_tasks keys on pull, preserve on push
a4680dc fix(ui): maximum contrast for all task_tray elements
d9e58ca chore: remove press-releases from git, add to .gitignore

Architecture

┌──────────────┐     stdio      ┌──────────────────┐
│  Claude Code  │◄──────────────►│  FastMCP Server   │
│  (session N)  │               │  server.py         │
├──────────────┤               │  24 MCP Tools      │
│  Task Tray    │──── direct ──►│  ┌──────────────┐ │
│  (PyQt6 GUI)  │   sqlite3     │  │  SQLite WAL   │ │
├──────────────┤               │  │  memory.db    │ │
│  Utility      │──── direct ──►│  │  FTS5 index   │ │
│  Scripts      │   sqlite3     │  └──────────────┘ │
└──────────────┘               │         │          │
                               │  pending_shared_   │
                               │  tasks (staging)   │
                               └──────────────────┘
                                        │
                                   db_utils.py
                               (shared constants,
                                connection, helpers)
                                        │
                               ┌────────┴────────┐
                               │  memory-bridge   │
                               │  (GitHub sync)   │
                               │  ┌────────────┐  │
                               │  │ shared.json │  │
                               │  │ + tasks     │  │
                               │  │ + shared_   │  │
                               │  │   tasks     │  │
                               │  └────────────┘  │
                               └─────────────────┘

Total tools: 24

 9 KG tools     (drop-in compatible with @modelcontextprotocol/server-memory)
 3 session tools (session_save, session_recall, search_by_project)
 8 task tools    (create_task, update_task, query_tasks, task_digest,
                  archive_done_tasks, bump_overdue_priority,
                  assign_task, review_shared_tasks)
 3 bridge tools  (bridge_push, bridge_pull, bridge_status)
──────────────────
24 total

Dependencies

Python 3.10+
fastmcp>=2.0.0 (MCP protocol)
PyQt6 (optional — only for task_tray.py)

MIT license.

Assets 2

Releases: RMANOV/sqlite-memory-mcp