@andespindola/brainlink 0.1.0-beta.1 → 0.1.0-beta.11

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.1.0-beta.4
+
+- Added bootstrap session-state persistence in `$BRAINLINK_HOME/session-state.json` for vault/agent readiness tracking.
+- Added MCP `brainlink_policy` tool and default bootstrap enforcement for read tools.
+- Added `agent install --self-test` diagnostics and bootstrap readiness details in `agent status`.
+- Added `agent upgrade` for legacy installations to reapply latest MCP/plugin defaults with self-test diagnostics.
+- Added `config doctor --fix` safe autofix mode with dry-run default behavior.
+- Added detailed per-file migration reporting through `migrate-vault --report`.
+- Added `quickstart` command to run plug-and-play vault + bootstrap + agent setup in one flow.
+- Added structured MCP `nextActions` in bootstrap/policy/preflight responses for automatic client continuation.
+- Added default MCP read auto-bootstrap behavior controlled by `brainlink_policy.autoBootstrapOnRead`.
+- Added default MCP startup bootstrap behavior controlled by `brainlink_policy.autoBootstrapOnStartup`.
+- Added CLI MCP policy presets through `blink agent policy --preset fully-auto|strict`.
+- Added write-time non-orphan enforcement by auto-linking notes without wiki edges to agent hub notes.
+- Added MCP `brainlink_policy` presets (`fully-auto`, `strict`) for one-call policy switching.
+- Added MCP write connectivity metadata in `brainlink_add_note`/`brainlink_add_file` responses.
+- Added MCP `brainlink_recommendations` tool for plug-and-play workflow guidance.
+- Improved graph/index robustness by splitting oversized paragraphs into bounded chunks and dropping self-referential links.
+- Added `agentProfiles` configuration support so CLI and MCP can resolve per-agent defaults for mode/limit/tokens.
+- Added short-lived hybrid search cache with automatic invalidation on index changes.
+- Added `stats --extended` observability output with storage, quality and latency probes.
+- Added `docs/QUICKSTART.md` and aligned README/agent docs with the latest CLI/MCP flows.
+
+## 0.1.0-beta.3
+
+- Added CLI configuration commands for effective vault management, including `config where`, `config get`, `config doctor` and `config set-vault`.
+- Added explicit `migrate-vault` command with `--dry-run` preview and conflict-preserving copy behavior.
+- Added one-command agent setup through `agent install` plus `agent status` diagnostics.
+- Added MCP `brainlink_bootstrap` default entrypoint guidance for plug-and-play agent memory flows.
+- Added migration coverage for S3 bucket vault targets.
+- Updated architecture and agent-usage documentation to reflect current CLI/MCP behavior and configuration precedence.
+
+## 0.1.0-beta.2
+
+- Added MCP installation guidance for direct server configuration and local client stores.
+- Documented MCP vault allowlisting with `BRAINLINK_ALLOWED_VAULTS`.
+- Aligned the documented MCP tool list with the current server tools.
+- Updated release documentation for the beta package line.
+
+## 0.1.0-beta.0
+
+- Promoted the package to the beta prerelease channel.
+- Added built-in MCP stdio server distribution through `brainlink-mcp`.
+- Added agent namespaces, auto-indexing on writes and file ingestion flows.
+- Added S3-compatible bucket vault support and weighted graph relationships.
+
 ## 0.1.0-alpha.0
 
 - Added local-first Markdown vault indexing.

package/README.md

@@ -57,6 +57,8 @@ LLMs do not have infinite context. Brainlink gives agents an external memory lay
 6. Brainlink returns compact, source-backed context.
 
 Markdown is the source of truth. `.brainlink/brainlink.db` is only a rebuildable index.
+Brainlink now keeps an automatic rollback snapshot at `.brainlink/brainlink.db.backup`. If the main SQLite file is corrupted, Brainlink automatically restores from snapshot (or recreates a clean index when no snapshot exists).
+After each index run, Brainlink also writes compressed search packs at `.brainlink/search-packs/*.jsonl.gz`. If SQLite is unavailable, search falls back to these packs automatically.
 
 ## Features
 
@@ -106,6 +108,8 @@ npx @andespindola/brainlink@latest --help
 
 This section is written for agents. If you are an AI agent operating in a user workspace, use this workflow to install and use Brainlink without requiring the user to run commands manually.
 
+For a condensed setup path, see [docs/QUICKSTART.md](./docs/QUICKSTART.md).
+
 ### 1. Check Whether Brainlink Is Installed
 
 ```bash
@@ -380,19 +384,154 @@ Example MCP client configuration:
 }
 ```
 
+### One-Command Agent Setup
+
+If your agent runtime is Codex-compatible, run:
+
+```bash
+blink agent install --self-test
+blink agent upgrade
+```
+
+This configures `~/.codex/config.toml` with Brainlink MCP (`brainlink-mcp`) so Brainlink is available by default in agent sessions.
+
+If you are inside this repository and want plugin gallery setup too:
+
+```bash
+blink agent install --plugin-path ./plugins/brainlink
+```
+
+To verify:
+
+```bash
+blink agent status
+```
+
+For fully automated first run (vault index + health + bootstrap readiness + agent integration):
+
+```bash
+blink quickstart --query "what should I know before this task?" --json
+```
+
+For a locked-down setup, allowlist the vaults that MCP clients may access:
+
+```json
+{
+  "mcpServers": {
+    "brainlink": {
+      "command": "brainlink-mcp",
+      "env": {
+        "BRAINLINK_ALLOWED_VAULTS": "/absolute/path/to/project-vault,/absolute/path/to/team-vault"
+      }
+    }
+  }
+}
+```
+
+### Install In MCP Client Stores
+
+Brainlink can be exposed to MCP-compatible client stores in two ways:
+
+1. Register the stdio server directly when the client accepts `mcpServers` configuration.
+2. Register the local plugin from this repository when the client supports a plugin gallery or local marketplace.
+
+Direct MCP server setup:
+
+```bash
+npm install -g @andespindola/brainlink@latest
+command -v brainlink-mcp
+```
+
+Use this server configuration in any MCP-compatible client that reads a JSON MCP manifest:
+
+```json
+{
+  "mcpServers": {
+    "brainlink": {
+      "command": "brainlink-mcp"
+    }
+  }
+}
+```
+
+Local plugin gallery setup:
+
+```bash
+npm install -g @andespindola/brainlink@latest
+git clone https://github.com/andersonflima/brainlink.git "$HOME/brainlink"
+mkdir -p "$HOME/plugins"
+ln -s "$HOME/brainlink/plugins/brainlink" "$HOME/plugins/brainlink"
+```
+
+Then register the plugin in the local marketplace file used by compatible clients:
+
+```bash
+node <<'NODE'
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+
+const marketplacePath = path.join(os.homedir(), '.agents', 'plugins', 'marketplace.json')
+const pluginEntry = {
+  name: 'brainlink',
+  source: {
+    source: 'local',
+    path: './plugins/brainlink'
+  },
+  policy: {
+    installation: 'AVAILABLE',
+    authentication: 'ON_INSTALL'
+  },
+  category: 'Productivity'
+}
+
+fs.mkdirSync(path.dirname(marketplacePath), { recursive: true })
+
+const marketplace = fs.existsSync(marketplacePath)
+  ? JSON.parse(fs.readFileSync(marketplacePath, 'utf8'))
+  : {
+      name: 'local',
+      interface: {
+        displayName: 'Local'
+      },
+      plugins: []
+    }
+
+const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : []
+marketplace.plugins = [...plugins.filter((plugin) => plugin?.name !== 'brainlink'), pluginEntry]
+
+fs.writeFileSync(marketplacePath, `${JSON.stringify(marketplace, null, 2)}\n`)
+NODE
+```
+
+Restart the client after changing marketplace or MCP configuration so it reloads the Brainlink entry. The plugin starts `brainlink-mcp` and exposes the same tool set listed below.
+
 Available tools:
 
+- `brainlink_bootstrap`: plug-and-play entrypoint that runs index + health checks and can return context in one call.
+- `brainlink_policy`: read or update bootstrap/context-first policy, including presets (`preset: "fully-auto" | "strict"`).
+- `brainlink_recommendations`: return an automatic action plan so agents can run Brainlink in the recommended order.
 - `brainlink_context`: read indexed context for a task or question.
 - `brainlink_search`: search indexed notes.
 - `brainlink_add_note`: write durable Markdown memory and reindex.
 - `brainlink_add_file`: ingest a local file as a note and reindex.
 - `brainlink_index`: rebuild the vault index.
+- `brainlink_stats`: read indexed vault statistics.
 - `brainlink_validate`: validate broken links and orphan notes.
+- `brainlink_sync`: run index, stats, validation, broken-link and orphan checks in one call.
 - `brainlink_graph`: read indexed graph nodes and weighted links.
 - `brainlink_broken_links`: list unresolved wiki links.
 - `brainlink_orphans`: list disconnected notes.
 
-The same linking rule applies through MCP: `brainlink_context` is read-only, and real graph links require Markdown notes with explicit `[[wiki links]]`. `brainlink_add_note` and `brainlink_add_file` reindex by default and include the index result when enabled.
+For the most automatic workflow, start MCP sessions with `brainlink_bootstrap` (optionally with `query`) and then continue with `brainlink_context`/`brainlink_add_note`.
+By default, Brainlink enforces context-first for MCP reads (`enforceContextFirst=true`): non-context read tools return preflight until `brainlink_context` is called for the vault/agent session.
+By default, MCP startup already runs bootstrap on the configured default vault/agent (`autoBootstrapOnStartup=true`), so sessions begin warm.
+By default, Brainlink enforces bootstrap and auto-runs it for read tools when session state is missing or stale (`autoBootstrapOnRead=true`).
+If you disable `autoBootstrapOnRead` through `brainlink_policy`, read tools return a preflight instruction with suggested `brainlink_bootstrap` arguments.
+`brainlink_bootstrap`, `brainlink_policy` and preflight responses include structured `nextActions` so MCP clients can continue automatically without custom parsing.
+For one-call planning, use `brainlink_recommendations` to get the recommended tool sequence for the current vault/agent/query.
+
+The same linking rule applies through MCP: `brainlink_context` is read-only, and real graph links require Markdown notes with explicit `[[wiki links]]`. `brainlink_add_note` and `brainlink_add_file` reindex by default and include index + `writeConnectivity` metadata. Brainlink guarantees at least one edge per new note by auto-linking when needed.
 
 Agents can raise the importance of a relationship by putting priority markers on the same line as a wiki link:
 
@@ -417,11 +556,15 @@ The graph UI shows:
 
 - notes as nodes
 - `[[wiki links]]` as weighted edges
-- backlinks and outgoing links
-- full Markdown content for the selected note
+- details opened on node click (tags, outgoing links, backlinks, full Markdown content)
 - neutral graph nodes with segment/group metadata
 - agent selector for isolated views
+- graph filter matches title, path, tags and note content
 - realtime refresh while `--watch` is enabled
+- graph controls for zoom in, zoom out, fit visible nodes and reset-to-fit-all
+- wheel zoom anchored to cursor position for faster navigation in large graphs
+- floating graph totals (notes, links, tags) below the Brainlink title
+- large-graph rendering safeguards (edge draw caps, lower redraw rate, zoom-aware interaction)
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 
@@ -440,6 +583,7 @@ Routes:
 - `GET /api/agents`
 - `GET /api/graph`
 - `GET /api/graph-layout`
+- `GET /api/graph-node?id=<node-id>`
 - `GET /api/search?q=<query>&limit=10&mode=hybrid`
 - `GET /api/context?q=<query>&limit=12&tokens=2000&mode=hybrid`
 - `GET /api/links`
@@ -461,14 +605,77 @@ Read routes accept `agent=<agent-id>`:
 
 Every command works with either `brainlink` or `blink`.
 
+### `agent`
+
+```bash
+blink agent install
+blink agent install --self-test
+blink agent upgrade
+blink agent policy --preset fully-auto
+blink agent policy --preset strict
+blink agent policy --enforce-context-first false
+blink agent install --plugin-path ./plugins/brainlink
+blink agent install --mcp-only --allowed-vaults "/absolute/vault,/absolute/team-vault"
+blink agent status
+```
+
+Installs/checks agent integration. `install` writes Brainlink MCP config into `~/.codex/config.toml`.
+When plugin files are available, it also links Brainlink plugin files into `~/plugins/brainlink` and updates `~/.agents/plugins/marketplace.json`.
+With `--self-test`, install also validates MCP block presence, command wiring and local plugin registration signals.
+Use `agent upgrade` on legacy installations to reapply current defaults and run the same self-test diagnostics.
+Use `agent policy --preset fully-auto` for plug-and-play defaults, or `agent policy --preset strict` to require explicit bootstrap calls.
+Both presets keep `enforceContextFirst=true` so Brainlink stays the primary context source for MCP sessions.
+
+### `quickstart`
+
+```bash
+blink quickstart --json
+blink quickstart --vault ./team-vault --agent coding-agent --query "architecture decisions" --json
+blink quickstart --vault ./team-vault --mcp-only --json
+```
+
+Runs index + doctor + stats + validation, refreshes bootstrap session readiness, optionally returns context for a query, and (by default) upgrades local agent integration for plug-and-play MCP usage.
+When `--mode`, `--limit` or `--tokens` are omitted, quickstart uses agent profile defaults when available.
+
+### `config`
+
+```bash
+blink config where
+blink config get vault
+blink config doctor
+blink config doctor --fix
+blink config set-vault /absolute/path/to/existing-vault
+blink config set-vault /absolute/path/to/existing-vault --migrate-from ~/.brainlink/vault
+blink config set-vault "s3://my-memory-bucket/brainlink" --global
+```
+
+`config set-vault` writes configuration through CLI (no manual file edits required).  
+By default it writes local config (`./brainlink.config.json`), appends the vault to `allowedVaults`, and migrates Markdown memory from the current configured vault when the target is empty.  
+Use `--global` to write to `$BRAINLINK_HOME/brainlink.config.json`, `--no-migrate` to skip migration, and `--no-index` to skip post-migration indexing.
+`config doctor` is dry-run by default; use `--fix` to apply safe config normalization and allowlist fixes.
+
+### `migrate-vault`
+
+```bash
+blink migrate-vault --from ~/.brainlink/vault --to ./team-vault --dry-run
+blink migrate-vault --from ~/.brainlink/vault --to ./team-vault
+blink migrate-vault --from ~/.brainlink/vault --to "s3://my-memory-bucket/brainlink"
+blink migrate-vault --from ~/.brainlink/vault --to ./team-vault --report ./migration-report.json
+```
+
+Runs explicit markdown migration between vaults while preserving conflicts as `.conflict-<timestamp>` files.  
+Use `--dry-run` to preview `copied`, `conflicted` and `unchanged` counts before writing.
+
 ### `init`
 
 ```bash
 blink init
 blink init ./vault
+blink init ./team-vault --migrate-from ~/.brainlink/vault
 ```
 
 Initializes vault metadata. Without an argument, Brainlink initializes the default vault at `$HOME/.brainlink/vault`.
+When initializing an empty custom vault, existing Markdown content from the default vault is copied into it and reindexed so context is not left behind. Use `--no-migrate-existing` to start with an empty custom vault, or `--migrate-from <vault>` to copy from a specific source. Existing target files are never overwritten; conflicting source files are preserved with a `.conflict-<timestamp>` suffix.
 
 ### `add`
 
@@ -482,6 +689,7 @@ blink add "Note Title" --vault ./vault --content-file ./notes.md --no-auto-index
 `--content` and `--content-file` are mutually exclusive. Add `--no-auto-index` when you want to defer reindexing.
 
 Creates a Markdown note under `agents/<agent-id>/`. Common secret patterns are blocked by default; use `--allow-sensitive` only for an intentionally protected vault.
+To avoid disconnected memory, Brainlink auto-adds a fallback wiki edge when a note is written without links, creating agent hub notes when needed.
 
 ### `index`
 
@@ -510,6 +718,7 @@ blink search "query" --vault ./vault --mode semantic --json
 ```
 
 Runs retrieval over indexed chunks.
+If `--mode` or `--limit` is omitted, Brainlink resolves values from the current agent profile before falling back to global defaults.
 
 Modes:
 
@@ -517,6 +726,8 @@ Modes:
 - `fts`: exact lexical retrieval through SQLite FTS.
 - `semantic`: local deterministic embedding similarity only.
 
+Hybrid results are cached in-memory for a short TTL and invalidated automatically when the local index file changes.
+
 ### `context`
 
 ```bash
@@ -559,9 +770,11 @@ Prints indexed graph data. Edges include `weight` and `priority` so agents can c
 ```bash
 blink stats --vault ./vault
 blink stats --vault ./vault --agent coding-agent --json
+blink stats --vault ./vault --agent coding-agent --extended --json
 ```
 
 Prints vault metrics.
+Use `--extended` to include storage footprint, link quality ratios and observability probes (`index`, `search`, `context` latencies).
 
 ### `broken-links`
 
@@ -593,7 +806,7 @@ Validates graph health. The command exits non-zero when required checks fail.
 blink doctor --vault ./vault
 ```
 
-Runs environment and vault checks.
+Runs environment and vault checks. When vault has zero markdown and zero indexed documents, `doctor` prints recommended next steps (add note, inspect config source, migrate memory).
 
 ### `watch`
 
@@ -630,7 +843,13 @@ npm run --silent dev -- context "question" --vault ./vault --json
 
 ## Configuration
 
-Brainlink reads `brainlink.config.json` or `.brainlink.json` from the current working directory. If no `vault` is configured and no `--vault` flag is passed, Brainlink uses `$HOME/.brainlink/vault`.
+Brainlink merges configuration in this order:
+
+1. Global: `$BRAINLINK_HOME/brainlink.config.json` (or `$HOME/.brainlink/brainlink.config.json` by default)
+2. Local: `brainlink.config.json` in the current working directory
+3. Local legacy compatibility: `.brainlink.json` in the current working directory
+
+If no `vault` is configured and no `--vault` flag is passed, Brainlink uses `$HOME/.brainlink/vault`.
 
 ```json
 {
@@ -644,13 +863,24 @@ Brainlink reads `brainlink.config.json` or `.brainlink.json` from the current wo
   "defaultContextTokens": 2000,
   "embeddingProvider": "local",
   "defaultSearchMode": "hybrid",
-  "chunkSize": 1200
+  "chunkSize": 1200,
+  "agentProfiles": {
+    "coding-agent": {
+      "defaultSearchMode": "semantic",
+      "defaultSearchLimit": 8,
+      "defaultContextTokens": 2400
+    },
+    "*": {
+      "defaultSearchMode": "hybrid"
+    }
+  }
 }
+```
 
 `defaultAgent` is optional. When set, CLI and MCP calls that omit `--agent`/`agent` use this value automatically. If not set, behavior remains as before.
+`agentProfiles` is optional. When present, CLI and MCP resolve `mode`, `limit` and `tokens` per agent automatically, then fallback to global defaults.
 
 `autoIndexOnWrite` is optional and defaults to `true`. Set it to `false` to defer indexing after writes.
-``` 
 
 Use `"embeddingProvider": "none"` when you want FTS-only indexing.
 
@@ -763,17 +993,18 @@ Detailed notes:
 - HTTP API is local and unauthenticated.
 - Watch mode depends on the platform filesystem watcher.
 
-## Alpha Scope
+## Beta Scope
 
-`0.1.0-alpha.0` is intended to prove the local-first memory loop:
+The `0.1.0-beta` line is intended to stabilize the local-first memory loop:
 
 - Markdown as durable memory.
 - SQLite FTS plus local embeddings and semantic buckets as rebuildable retrieval index.
 - CLI as the primary agent interface.
 - HTTP graph API and frontend as inspection tools.
 - Agent namespaces to avoid context mixing.
+- MCP tools for context retrieval, durable memory writes and graph maintenance.
 
-The alpha includes local semantic retrieval. Remote embedding providers, remote auth, advanced deduplication and graph editing are future milestones.
+The beta includes local semantic retrieval. Remote embedding providers, remote auth, advanced deduplication and graph editing are future milestones.
 
 ## Security
 

package/dist/application/add-note.js

@@ -1,30 +1,79 @@
+import { access } from 'node:fs/promises';
+import { join } from 'node:path';
 import { writeMarkdownFile } from '../infrastructure/file-system-vault.js';
 import { sanitizeAgentId, sharedAgentId } from '../domain/agents.js';
+import { extractWikiLinks } from '../domain/markdown.js';
 import { validateNoteInput } from '../domain/note-safety.js';
+import { ensureVault } from '../infrastructure/file-system-vault.js';
 const slugify = (title) => title
     .normalize('NFKD')
     .replace(/[\u0300-\u036f]/g, '')
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-+|-+$/g, '');
-export const addNote = async (vaultPath, title, content, agentId = sharedAgentId, options = {}) => {
+const systemHubTitle = 'Memory Hub';
+const systemRootTitle = 'Knowledge Root';
+const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '').toLowerCase();
+const noteFilename = (agentId, title) => `agents/${agentId}/${slugify(title) || 'untitled'}.md`;
+const buildNote = (title, content, agentId) => [
+    `---`,
+    `title: "${title.replaceAll('"', '\\"')}"`,
+    `agent: "${agentId}"`,
+    `---`,
+    '',
+    `# ${title}`,
+    '',
+    content.trim(),
+    ''
+].join('\n');
+const ensureSystemNote = async (vaultPath, absoluteVaultPath, agentId, title, content) => {
+    const filename = noteFilename(agentId, title);
+    const absolutePath = join(absoluteVaultPath, filename);
+    try {
+        await access(absolutePath);
+        return;
+    }
+    catch { }
+    await writeMarkdownFile(vaultPath, filename, buildNote(title, content, agentId));
+};
+const ensureNonOrphanContent = async (vaultPath, absoluteVaultPath, title, content, agentId) => {
+    const links = extractWikiLinks(content).filter((link) => normalizeTitle(link) !== normalizeTitle(title));
+    if (links.length > 0) {
+        return {
+            content: content.trim(),
+            autoLinked: false,
+            linkTarget: null
+        };
+    }
+    const fallbackTitle = normalizeTitle(title) === normalizeTitle(systemHubTitle) ? systemRootTitle : systemHubTitle;
+    if (fallbackTitle === systemRootTitle) {
+        await ensureSystemNote(vaultPath, absoluteVaultPath, agentId, systemRootTitle, `Entry point for agent memory. [[${systemHubTitle}]] #memory #root`);
+    }
+    else {
+        await ensureSystemNote(vaultPath, absoluteVaultPath, agentId, systemHubTitle, 'Central memory index for this agent namespace. #memory #hub');
+    }
+    return {
+        content: `${content.trim()}\n\nRelated: [[${fallbackTitle}]]`,
+        autoLinked: true,
+        linkTarget: fallbackTitle
+    };
+};
+export const addNoteWithMetadata = async (vaultPath, title, content, agentId = sharedAgentId, options = {}) => {
     validateNoteInput({
         title,
         content,
         allowSensitive: options.allowSensitive
     });
     const sanitizedAgentId = sanitizeAgentId(agentId);
+    const absoluteVaultPath = await ensureVault(vaultPath);
     const filename = `agents/${sanitizedAgentId}/${slugify(title) || 'untitled'}.md`;
-    const note = [
-        `---`,
-        `title: "${title.replaceAll('"', '\\"')}"`,
-        `agent: "${sanitizedAgentId}"`,
-        `---`,
-        '',
-        `# ${title}`,
-        '',
-        content.trim(),
-        ''
-    ].join('\n');
-    return writeMarkdownFile(vaultPath, filename, note);
+    const linkedContent = await ensureNonOrphanContent(vaultPath, absoluteVaultPath, title, content, sanitizedAgentId);
+    const note = buildNote(title, linkedContent.content, sanitizedAgentId);
+    const path = await writeMarkdownFile(vaultPath, filename, note);
+    return {
+        path,
+        autoLinked: linkedContent.autoLinked,
+        linkTarget: linkedContent.linkTarget
+    };
 };
+export const addNote = async (vaultPath, title, content, agentId = sharedAgentId, options = {}) => (await addNoteWithMetadata(vaultPath, title, content, agentId, options)).path;

package/dist/application/analyze-vault.js

@@ -1,10 +1,91 @@
+import { stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { performance } from 'node:perf_hooks';
+import { join } from 'node:path';
 import { validateGraph, getBrokenLinks, getOrphanNodes, getVaultStats } from '../domain/graph-analysis.js';
-import { ensureVault, readMarkdownFiles } from '../infrastructure/file-system-vault.js';
-import { getGraph } from './get-graph.js';
-export const getStats = async (vaultPath, agentId) => getVaultStats(await getGraph(vaultPath, agentId));
-export const getBrokenLinksReport = async (vaultPath, agentId) => getBrokenLinks(await getGraph(vaultPath, agentId));
-export const getOrphansReport = async (vaultPath, agentId) => getOrphanNodes(await getGraph(vaultPath, agentId));
-export const validateVault = async (vaultPath, agentId) => validateGraph(await getGraph(vaultPath, agentId));
+import { ensureVault, listVaultFiles, readMarkdownFiles } from '../infrastructure/file-system-vault.js';
+import { resolveAgentRuntimeDefaults } from '../infrastructure/config.js';
+import { getGraphSummary } from './get-graph-summary.js';
+import { buildContextPackage } from './build-context.js';
+import { indexVault } from './index-vault.js';
+import { searchKnowledge } from './search-knowledge.js';
+import { loadBrainlinkConfig } from '../infrastructure/config.js';
+export const getStats = async (vaultPath, agentId) => getVaultStats(await getGraphSummary(vaultPath, agentId));
+export const getBrokenLinksReport = async (vaultPath, agentId) => getBrokenLinks(await getGraphSummary(vaultPath, agentId));
+export const getOrphansReport = async (vaultPath, agentId) => getOrphanNodes(await getGraphSummary(vaultPath, agentId));
+export const validateVault = async (vaultPath, agentId) => validateGraph(await getGraphSummary(vaultPath, agentId));
+const toRatio = (part, total) => total === 0 ? 0 : Number((part / total).toFixed(4));
+export const getExtendedStats = async (vaultPath, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const graph = await getGraphSummary(absoluteVaultPath, agentId);
+    const stats = getVaultStats(graph);
+    const markdownFiles = await readMarkdownFiles(absoluteVaultPath);
+    const allFiles = await listVaultFiles(absoluteVaultPath);
+    const totalBytes = (await Promise.all(allFiles.map(async (filePath) => {
+        try {
+            return (await stat(filePath)).size;
+        }
+        catch {
+            return 0;
+        }
+    }))).reduce((sum, value) => sum + value, 0);
+    const updatedAt = markdownFiles
+        .map((file) => file.updatedAt.getTime())
+        .filter((time) => Number.isFinite(time))
+        .sort((left, right) => left - right);
+    const priorities = graph.edges.reduce((state, edge) => ({
+        ...state,
+        [edge.priority]: state[edge.priority] + 1
+    }), {
+        low: 0,
+        normal: 0,
+        high: 0,
+        critical: 0
+    });
+    const config = await loadBrainlinkConfig();
+    const defaults = resolveAgentRuntimeDefaults(config, agentId);
+    const probeQuery = graph.nodes[0]?.title ?? 'architecture';
+    const indexStart = performance.now();
+    await indexVault(absoluteVaultPath);
+    const indexLatency = performance.now() - indexStart;
+    const searchStart = performance.now();
+    await searchKnowledge(absoluteVaultPath, probeQuery, Math.min(defaults.defaultSearchLimit, 8), agentId, 'hybrid');
+    const searchLatency = performance.now() - searchStart;
+    const contextStart = performance.now();
+    await buildContextPackage(absoluteVaultPath, probeQuery, Math.min(defaults.defaultSearchLimit, 8), defaults.defaultContextTokens, agentId, 'hybrid');
+    const contextLatency = performance.now() - contextStart;
+    return {
+        stats,
+        storage: {
+            markdownFileCount: markdownFiles.length,
+            totalFileCount: allFiles.length,
+            totalBytes,
+            averageMarkdownBytes: markdownFiles.length === 0
+                ? 0
+                : Math.round(markdownFiles.reduce((sum, file) => sum + Buffer.byteLength(file.content, 'utf8'), 0) / markdownFiles.length),
+            ...(updatedAt.length > 0
+                ? {
+                    oldestNoteUpdatedAt: new Date(updatedAt[0]).toISOString(),
+                    newestNoteUpdatedAt: new Date(updatedAt[updatedAt.length - 1]).toISOString()
+                }
+                : {})
+        },
+        quality: {
+            resolvedLinkRatio: toRatio(stats.resolvedLinkCount, stats.linkCount),
+            brokenLinkRatio: toRatio(stats.brokenLinkCount, stats.linkCount),
+            orphanRatio: toRatio(stats.orphanCount, Math.max(stats.documentCount, 1)),
+            priorityDistribution: priorities
+        },
+        observability: {
+            probeQuery,
+            latenciesMs: {
+                index: Number(indexLatency.toFixed(2)),
+                search: Number(searchLatency.toFixed(2)),
+                context: Number(contextLatency.toFixed(2))
+            }
+        }
+    };
+};
 const createCheck = (name, ok, message) => ({
     name,
     ok,
@@ -13,16 +94,30 @@ const createCheck = (name, ok, message) => ({
 export const doctorVault = async (vaultPath) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
     const files = await readMarkdownFiles(absoluteVaultPath);
-    const graph = await getGraph(absoluteVaultPath);
+    const graph = await getGraphSummary(absoluteVaultPath);
     const validation = validateGraph(graph);
+    const backupPath = join(absoluteVaultPath, '.brainlink', 'brainlink.db.backup');
+    const hasBackup = existsSync(backupPath);
+    const backupReady = graph.nodes.length === 0 || hasBackup;
     const checks = [
         createCheck('vault', true, `Vault ready at ${absoluteVaultPath}`),
         createCheck('markdown-files', files.length > 0, `${files.length} markdown files found`),
         createCheck('index', graph.nodes.length > 0, `${graph.nodes.length} indexed documents found`),
-        createCheck('broken-links', validation.brokenLinks.length === 0, `${validation.brokenLinks.length} broken links found`)
+        createCheck('broken-links', validation.brokenLinks.length === 0, `${validation.brokenLinks.length} broken links found`),
+        createCheck('index-backup', backupReady, backupReady
+            ? (hasBackup ? 'SQLite recovery snapshot is available' : 'No index yet. Snapshot will be created after first indexing run')
+            : 'Recovery snapshot missing. Run blink index to create a rollback snapshot')
     ];
+    const recommendations = files.length === 0 && graph.nodes.length === 0
+        ? [
+            `Vault is empty. Add your first note: blink add "Architecture" --vault "${absoluteVaultPath}" --content "Markdown source of truth. #architecture"`,
+            `If this path is not the expected vault, inspect active config: blink config where`,
+            `If you changed vault recently, migrate existing memory: blink migrate-vault --from ~/.brainlink/vault --to "${absoluteVaultPath}"`
+        ]
+        : [];
     return {
         ok: checks.every((check) => check.ok),
-        checks
+        checks,
+        ...(recommendations.length > 0 ? { recommendations } : {})
     };
 };