docs: clarify yaad is a library embedded in hawk, not a standalone binary

Rewrites the README to reflect that yaad ships no CLI — it is the
memory engine consumed by hawk. Adds Library API section, adjusts
gitignore for bin/ dist/ build artifacts.

Author: Patel230

.gitignore

@@ -2,6 +2,10 @@
 /yaad
 /yaad.exe
 
+# Build output (yaad is library-only; any local sample build lands here)
+bin/
+dist/
+
 # Database / local cache
 elrond*.db
 *.codegraph.db

README.md

@@ -26,30 +26,20 @@ Every coding agent forgets everything when the session ends.
 
 ### The Fix
 
-Add one line to your agent's MCP config:
-
-```json
-{ "mcpServers": { "yaad": { "command": "yaad", "args": ["mcp"] } } }
-```
-
-Now your agent remembers everything — across sessions, across models, across projects.
-
----
-
-## 30-Second Setup
-
-```bash
-# Install
-go install github.com/GrayCodeAI/yaad/cmd/yaad@latest
-
-# Add to your project
-cd your-project && yaad init
-
-# Connect your agent (generates .mcp.json + hooks)
-yaad setup
-```
-
-**That's it.** Your agent now has persistent, graph-native memory.
+Yaad is the **memory engine** behind the [`hawk`](https://github.com/GrayCodeAI/hawk)
+coding agent. Run `hawk` and your agent gets persistent, graph-native memory — across
+sessions, across models, across projects — with no separate install or daemon to manage.
+
+> **Yaad is a Go library, not a standalone binary.** It ships no `yaad` command of its
+> own; its memory features are surfaced through the host agent (hawk). To embed Yaad in
+> your own Go program, import it directly:
+>
+> ```go
+> import (
+>     yaad "github.com/GrayCodeAI/yaad/engine"
+>     "github.com/GrayCodeAI/yaad/storage"
+> )
+> ```
 
 ---
 
@@ -240,7 +230,7 @@ Zep-style `valid_at` / `invalid_at` intervals on edges let recall filter to fact
 <details>
 <summary><b>Versions & Rollback</b></summary>
 
-Every edit is versioned. Inspect history with `yaad versions <node-id>` and restore a prior state with `yaad rollback <node-id> <version>` — the rollback itself is recorded as a new version.
+Every edit is versioned. The engine can list a node's version history and restore a prior state — the rollback itself is recorded as a new version.
 </details>
 
 <details>
@@ -269,9 +259,10 @@ Detects topic boundaries in a session to segment memories into coherent units be
 
 ---
 
-## MCP Tools (23 tools)
+## Memory Tools (23 tools)
 
-Your agent gets these tools automatically via `yaad mcp`:
+When Yaad is embedded in a host agent (such as hawk), it exposes these operations to the
+agent. Yaad implements the logic; the host surfaces them (e.g. as MCP tools):
 
 | Tool | What it does |
 |---|---|
@@ -318,34 +309,35 @@ Your agent gets these tools automatically via `yaad mcp`:
 └─────────────────────────────────────────────────────────────────┘
 ```
 
-**Single binary. Zero dependencies. Pure Go. No CGO. No Docker. No cloud.**
+**Zero dependencies. Pure Go. No CGO. No Docker. No cloud.** Embedded by the host agent;
+all data stays local (SQLite, WAL mode).
 
 ---
 
-## CLI Commands
+## Library API
 
-```bash
-yaad init              # Initialize .yaad/ in current project
-yaad setup             # Configure MCP + hooks for your agent
-yaad serve             # Start REST API server
-yaad mcp               # Start MCP server on stdio (used by agents)
-
-yaad remember "..."    # Store a memory
-yaad recall "..."      # Search memories
-yaad link A B type     # Create edge between nodes
-yaad status            # Show graph stats
-yaad doctor            # Diagnose setup issues
-
-yaad decay             # Apply confidence decay
-yaad gc                # Garbage collect low-confidence nodes
-yaad bench             # Run retrieval benchmark
-
-yaad export-json       # Export as JSON
-yaad export-md         # Export as Markdown
-yaad export-obsidian   # Export as Obsidian vault
-yaad import-json       # Import from JSON
+Yaad is consumed as a Go library. The core entry points:
+
+```go
+import (
+    yaad "github.com/GrayCodeAI/yaad/engine"
+    "github.com/GrayCodeAI/yaad/storage"
+)
+
+// Open (or create) a memory store rooted at the repo / working dir.
+store, err := storage.Open(".yaad")
+eng := yaad.New(store)
+
+// Store, recall, link, and inspect impact — the same operations the
+// host agent exposes as tools (see the table above).
+eng.Remember(ctx, yaad.Note{Type: "decision", Text: "Chose NATS for backpressure"})
+hits, _ := eng.Recall(ctx, "why did we choose NATS?")
 ```
 
+See [ARCHITECTURE.md](ARCHITECTURE.md) and [api/openapi.yaml](api/openapi.yaml) for the
+full surface. Versioning/rollback, export/import, decay, and GC are all available as
+engine methods (the host agent decides which to expose).
+
 ---
 
 ## Configuration
@@ -385,9 +377,10 @@ auto_stale = true
 ```bash
 git clone https://github.com/GrayCodeAI/yaad.git
 cd yaad
-make build           # Build binary
+make build           # go build ./... (library packages; no standalone binary)
 make test            # Run all tests
-make install         # Install to $GOPATH/bin
+make cover           # Coverage report (coverage.out + coverage.html)
+make ci              # Everything CI runs (tidy, fmt, vet, lint, test-race, security)
 ```
 
 ---