name: rta-smriti-brain description: Use Rta-Smriti Brain before project work to retrieve local repo memory, context packs, graph facts, and stale-file status.

Rta-Smriti Brain

Use this skill when working in a project that has a Rta-Smriti SQLite brain or when the user asks for durable local project memory.

First Command

Verify the brain:

rta-brain.cmd doctor --json --db <brain.sqlite>

If rta-brain.cmd is not on PATH, run it by absolute path from the Rta-Smriti deliverable folder.

Install For Reuse

To make wrappers available from any project:

rta-brain.cmd install-local --target "$env:USERPROFILE\.local\bin" --json

Add that target folder to PATH if needed.

Bootstrap A Project

Create one brain per project. Use the exact rta-brain wrapper path returned by install-local; Windows wrappers end in .cmd, while macOS and Linux wrappers have no suffix. The examples below assume the wrapper directory is on PATH.

Windows PowerShell:

rta-brain.cmd bootstrap-project <repo-path> --project <project-name> --brain-dir "$env:USERPROFILE\Documents\Rta-Smriti\brains" --write-agents --json

Then verify readiness:

rta-brain.cmd --db "$env:USERPROFILE\Documents\Rta-Smriti\brains\<project-name>.sqlite" self-check --project <project-name> --json

macOS or Linux:

rta-brain bootstrap-project <repo-path> --project <project-name> --brain-dir "$HOME/.local/share/rta-smriti/brains" --write-agents --json
rta-brain --db "$HOME/.local/share/rta-smriti/brains/<project-name>.sqlite" self-check --project <project-name> --json

MCP Server

If the host supports MCP, generate a native configuration from the CLI:

rta-brain.cmd --db <brain.sqlite> --json mcp-config --project <project-name> --name rta-smriti

rta-brain --db <brain.sqlite> --json mcp-config --project <project-name> --name rta-smriti

Available MCP tools:

• brain_search
• brain_context_pack
• brain_remember
• brain_ingest_repo
• brain_ingest_thread
• brain_repo_map
• brain_stale_check
• brain_checkpoint
• brain_continuation_prompt
• brain_reflect
• brain_doctor

Before Coding

Generate a context pack:

rta-brain.cmd context-pack "<task>" --project <project-name> --db <brain.sqlite>

Verify the canonical root and Git identity at the top of the pack. Read the freshness line; if it says stale, re-read changed or missing files before relying on memory-derived context.

Search

rta-brain.cmd search "<query>" --project <project-name> --json --db <brain.sqlite>

Prefer exact project-scoped searches. Use results as pointers to evidence, not as a replacement for current file reads.

Remember

Use one atomic memory per command:

rta-brain.cmd remember "<durable fact>" --type decision --pramana sabda --project <project-name> --priority 8 --db <brain.sqlite>

For a verified claim, attach --source-path, --source-hash, --verification-command, and --verification-status verified.

Pramana policy:

• pratyaksha: directly observed from file, test, tool, or command output.
• sabda: user instruction or trusted documentation.
• anumana: inference.
• smriti: prior memory.
• kalpana: hypothesis or creative possibility.

Repo Refresh

rta-brain.cmd ingest-repo <repo-path> --project <project-name> --db <brain.sqlite>

Run after meaningful code or documentation changes.

Thread Ingestion

When a long thread, rollout summary, handoff, or JSONL session contains useful context:

rta-brain.cmd ingest-thread <thread-or-handoff-path> --project <project-name> --title "<short title>" --db <brain.sqlite>

Then run reflection:

rta-brain.cmd reflect --project <project-name> --json --db <brain.sqlite>

End A Work Session

Save a structured checkpoint before handing work to another task or agent:

rta-brain.cmd checkpoint --project <project-name> --db <brain.sqlite> --objective "<objective>" --verified-evidence "<verified evidence>" --remaining-gaps "<remaining gaps>" --next-action "<next action>" --prohibited-repetition "<do not repeat>"

Use continue-prompt or the dashboard's Copy New Task Prompt action for the next task.

Do Not

• Do not store secrets or credentials.
• Do not use stale memory as current truth.
• Do not mix unrelated projects into one brain unless explicitly authorized.
• Do not store broad transcripts when one durable fact is enough.

Rta-Smriti Brain

A sovereign, local project-memory and evidence layer for AI coding agents.

Rta-Smriti gives every project a durable memory: repository structure, agent sessions, decisions, evidence, and the exact state needed to continue work without retelling the story.

Install | Current release | Live website | Documentation | Discussions

v1.1.0-alpha

Current release: v1.1.0-alpha. Trusted lifecycle operation now sits beside Project Reality, governed context, temporal truth, repository intelligence, and local capture.

Current maturity: v1.1.0-alpha is an advanced early-adopter release for Windows, macOS, and Linux. It is useful for real projects, but it is not yet presented as a broadly supported production platform. Read the bounded release verification record.

The Problem

Every new agent session begins with an expensive question: what is true about this project right now? Repositories hold code, chats hold decisions, tools hold test results, and people hold the constraints. Ordinary retrieval collapses them into text.

Rta-Smriti keeps them local, connected, time-aware, and evidence-labelled.

flowchart LR
    A[Repository] --> B[Rta-Smriti Brain]
    C[Agent sessions] --> B
    D[Decisions and checkpoints] --> B
    E[Local evidence] --> B
    B --> F[Project Reality]
    B --> G[Governed context pack]
    B --> H[Fresh-session continuation]
    B --> I[Impact and conflict signals]

What You Get

See The Product

The 60-second v1 product demo was captured from v1.0.2. It demonstrates the Project Reality foundation; the v1.1 Trusted Lifecycle Supervisor shown above was added later.

How It Works

1. Build a local project brain

Rta-Smriti indexes the canonical Git checkout into project-scoped SQLite. It records content hashes, symbols, imports, evidence, temporal state, and durable memories without uploading the project to a hosted service.

2. Separate evidence from memory

flowchart TB
    O[Direct observation<br/>pratyaksha] --> T[Accepted project truth]
    S[Trusted instruction<br/>sabda] --> T
    I[Inference<br/>anumana] --> R[Review required]
    M[Prior memory<br/>smriti] --> R
    K[Hypothesis<br/>kalpana] --> R
    R -->|verified and promoted| T

A test result, a human instruction, an inference, and a brainstorm are not treated as the same kind of fact. Claims retain their source, verification state, and valid time.

3. Compile only the context the next task needs

The context compiler selects direct evidence before low-trust history, obeys explicit token budgets and privacy grants, and emits a selection receipt explaining what was included and why.

4. Operate through one trustworthy boundary

flowchart LR
    A[Inspect] --> B[Plan]
    B --> C[Review risks and backups]
    C --> D[Approve]
    D --> E[Apply]
    E --> F[Verify]
    F --> G[Immutable receipt]
    F -->|degraded| H[Repair or rollback]
    H --> F

Database, repository, capture, continuation, MCP, and federation health remain independent. A running process alone never proves that continuation is ready.

Ten-Minute Start

Requirements: Python 3.11 or newer and Git. Node.js is needed only to modify the dashboard or website source.

The v1 Project Reality CLI is the shared entry point for onboarding, search, continuation, lifecycle operation, MCP configuration, and the local console.

Windows PowerShell

git clone https://github.com/sulabhdubey/rta-smriti-brain.git
cd .\rta-smriti-brain
python -m venv .venv
& .\.venv\Scripts\python.exe -m pip install .
$RtaBrain = Join-Path $PWD ".venv\Scripts\rta-brain.exe"
$BrainDir = "$env:USERPROFILE\Documents\Rta-Smriti\brains"
& $RtaBrain start C:\path\to\my-project --project my-project --brain-dir $BrainDir --write-agents

git clone https://github.com/sulabhdubey/rta-smriti-brain.git
cd rta-smriti-brain
python3 -m venv .venv
./.venv/bin/python -m pip install .
RtaBrain="$PWD/.venv/bin/rta-brain"
BrainDir="$HOME/.local/share/rta-smriti/brains"
"$RtaBrain" start /path/to/my-project --project my-project --brain-dir "$BrainDir" --write-agents

start detects the canonical Git root, creates or migrates the brain, indexes the repository, starts managed sync, starts matching Codex continuity capture when local sessions exist, and opens an authorized local console. Use --no-continuity on machines without local Codex sessions.

Prefer a standalone binary? Download the Windows, macOS, or Linux artifact and its SBOM from the v1.1.0-alpha release, then verify it against SHA256SUMS.txt.

Private By Default

flowchart LR
    subgraph Machine[Your machine]
        P[Project checkout] --> R[Rta-Smriti]
        A[Authorized agent sessions] --> R
        R --> S[(Local SQLite brain)]
        R --> C[Loopback operator console]
        R --> M[Local MCP server]
    end
    R -. no telemetry .-> X[No Rta-Smriti cloud]

• Capture is opt-in, source-scoped, bounded, and redacted before durable queuing.
• Captured text remains untrusted evidence until verified or promoted.
• The console binds to loopback and uses short-lived session capabilities.
• Project names, paths, transcript content, databases, keys, and snapshots must not be published. Public diagnostics use bounded counts and fingerprints.
• Signed or encrypted snapshots are private backup artifacts, not publication formats.

Read the complete security and privacy policy before handling sensitive repositories. Report vulnerabilities through the private process documented there.

Architecture At A Glance

flowchart TB
    CLI[CLI] --> K[Project Cognition Kernel]
    MCP[stdio MCP] --> K
    UI[Local Operator Console] --> K
    K --> ID[Canonical identity]
    K --> EV[Append-only event journal]
    K --> BT[Bitemporal truth]
    K --> RG[Repository graph]
    K --> CP[Governed context compiler]
    K --> LS[Trusted lifecycle supervisor]
    ID --> DB[(Project-scoped SQLite)]
    EV --> DB
    BT --> DB
    RG --> DB

Rta-Smriti is deliberately an evidence and continuity layer. It does not execute project work, choose models, silently edit host configuration, or replace an agent harness such as RTA-Net AI.

Release Evidence

The current prerelease includes:

• cross-platform CI and native binaries for Windows, macOS, and Linux;
• CycloneDX SBOMs and a signed workflow provenance trail;
• anonymous-download checksum verification;
• installed-package, CLI, dashboard, lifecycle, MCP, privacy, and security checks;
• an explicit record of host recipes versus hosts exercised live.

Green tests are not presented as proof of universal correctness. Exact scope, known limits, and remaining external-host gates are recorded in Release Verification.

Documentation