nano-brain 2026.1.0

package/AGENTS_SNIPPET.md

@@ -0,0 +1,36 @@
+<!-- OPENCODE-MEMORY:START -->
+<!-- Managed block - do not edit manually. Updated by: npx nano-brain init -->
+
+## Memory System (nano-brain)
+
+This project uses **nano-brain** for persistent context across sessions.
+
+### Quick Reference
+
+| I want to... | Command |
+|--------------|---------|
+| Recall past work on a topic | `memory_query("topic")` |
+| Find exact error/function name | `memory_search("exact term")` |
+| Explore a concept semantically | `memory_vsearch("concept")` |
+| Save a decision for future sessions | `memory_write("decision context")` |
+| Check index health | `memory_status` |
+
+### Session Workflow
+
+**Start of session:** Check memory for relevant past context before exploring the codebase.
+```
+memory_query("what have we done regarding {current task topic}")
+```
+
+**End of session:** Save key decisions, patterns discovered, and debugging insights.
+```
+memory_write("## Summary\n- Decision: ...\n- Why: ...\n- Files: ...")
+```
+
+### When to Search Memory vs Codebase
+
+- **"Have we done this before?"** → `memory_query` (searches past sessions)
+- **"Where is this in the code?"** → grep / ast-grep (searches current files)
+- **"How does this concept work here?"** → Both (memory for past context + grep for current code)
+
+<!-- OPENCODE-MEMORY:END -->

package/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Changelog
+
+## [2026.1.0] - 2026-02-23
+
+### Added
+
+- **AI agent routing instructions (SKILL.md)**: Enhanced SKILL.md with trigger phrases, when-to-use rules, tool selection guide, collection filtering, and integration patterns for orchestrator and subagent workflows. Agents now auto-route to memory for recall, past decisions, cross-session context, and repeated patterns.
+- **AGENTS_SNIPPET.md**: Optional managed block for project-level AGENTS.md installation. Provides quick reference table, session workflow (start/end), and memory vs codebase search guidance. Designed for `npx nano-brain init` injection.
+- **`memory_index_codebase` documented**: Added to SKILL.md, README, and site API reference.
+- **`workspace` parameter documented**: Added to search tool docs showing workspace scoping.
+
+## [0.3.0] - 2026-02-23
+
+### Added
+
+- **Codebase indexing**: Opt-in source code indexing via `codebase: { enabled: true }` in config.yml. Indexes source files from the current workspace into the search pipeline for semantic code search.
+- **Source code chunker**: Line-based chunking with structural boundary detection (function/class/type definitions, import blocks). Same 900-token target and 15% overlap as markdown chunker. Metadata headers (`File:`, `Language:`, `Lines:`) prepended to each chunk.
+- **Project type auto-detection**: Detects project type from marker files (package.json, pyproject.toml, go.mod, Cargo.toml, etc.) and selects appropriate file extensions to index. Falls back to all common extensions.
+- **Exclude pattern merging**: Combines exclude patterns from three sources: config `codebase.exclude`, `.gitignore`, and built-in defaults (node_modules, .git, dist, build, etc.).
+- **Codebase storage budget**: Independent `codebase.maxSize` (default 2GB) limits codebase storage separately from session storage. Indexing stops when budget is exceeded. Storage usage reported in `memory_status`.
+- **Max file size guard**: Skips files larger than `codebase.maxFileSize` (default 5MB) to avoid indexing generated/minified files.
+- **`memory_index_codebase` MCP tool**: On-demand full codebase scan and index with summary stats (files scanned, indexed, skipped, storage usage).
+- **Codebase stats in `memory_status`**: Shows enabled state, document count, storage used/limit, resolved extensions, and exclude pattern count.
+- **Watcher integration**: File watcher monitors workspace directory for source code changes with exclude patterns, triggering incremental reindex.
+- **`getCollectionStorageSize()`**: New Store method to query per-collection storage usage.
+- **118 new tests**: `codebase.test.ts` (68 tests), `codebase-chunker.test.ts` (50 tests). Total: 428 tests.
+
+### Changed
+
+- Increased vitest worker heap size to 8GB to prevent OOM during test runs with large test suites.
+
+## [0.2.0] - 2026-02-23
+
+### Added
+
+- **Workspace scoping**: Search results are now scoped to the current workspace by default. Each workspace is identified by a SHA-256 hash of its directory path, matching the harvester convention. Cross-workspace search is available via `workspace: "all"` parameter.
+- **Storage limits**: Configurable `maxSize` (default 2GB), `retention` (default 90d), and `minFreeDisk` (default 100MB) in `config.yml` under a `storage` section. Human-readable values like `500MB`, `30d`, `1y` are supported.
+- **Disk safety guard**: Checks available disk space via `fs.statfsSync()` before writes. Skips harvest/reindex/embed when disk is critically low.
+- **Retention-based eviction**: Automatically deletes harvested session markdown older than the retention period during each harvest cycle.
+- **Size-based eviction**: If total storage exceeds `maxSize` after retention eviction, deletes oldest sessions until under limit. Original OpenCode session JSON is never touched.
+- **Orphan embedding cleanup**: Removes embedding vectors for deleted documents every 10 harvest cycles.
+- **Incremental harvesting**: Tracks session file mtimes in `.harvest-state.json` to skip unchanged files, reducing harvest time from O(all) to O(changed).
+- **`workspace` parameter** on `memory_search`, `memory_vsearch`, and `memory_query` MCP tools. Omit for current workspace, `"all"` for cross-workspace.
+- **Per-workspace stats** in `memory_status` output showing document counts per workspace hash.
+- **45 new tests**: `workspace.test.ts` (18), `storage.test.ts` (27), plus integration tests in `server.test.ts` and `watcher.test.ts`. Total: 310 tests.
+
+### Changed
+
+- Switched embedding model from EmbeddingGemma-300M (384d) to **nomic-embed-text-v1.5** (768d) for better search quality.
+- Switched reranker from Qwen3-Reranker-0.6B to **bge-reranker-v2-m3** (8192 context) for improved reranking.
+- Updated prompt format to nomic `search_query:`/`search_document:` convention.
+- `documents` table now has a `project_hash` column with automatic migration and backfill on first startup.
+
+### Fixed
+
+- Crash when session JSON has undefined `slug` field (now falls back to session id).
+
+## [0.1.0] - 2026-02-16
+
+### Added
+
+- Initial release with hybrid search (BM25 + vector + LLM reranking).
+- 8 MCP tools: `memory_search`, `memory_vsearch`, `memory_query`, `memory_get`, `memory_multi_get`, `memory_write`, `memory_status`, `memory_update`.
+- SQLite storage with FTS5 and sqlite-vec.
+- Heading-aware markdown chunking.
+- YAML-configured collections with auto-indexing via chokidar.
+- OpenCode session harvesting (JSON to markdown).
+- GGUF model inference via node-llama-cpp.

package/README.md

@@ -0,0 +1,281 @@
+# nano-brain
+
+Persistent memory system for AI coding agents. Hybrid search (BM25 + vector + LLM reranking) across past sessions, codebase, curated notes, and daily logs.
+
+## What It Does
+
+An MCP server that gives AI coding agents persistent memory across sessions. Indexes markdown documents, past sessions, and daily logs into a searchable SQLite database with FTS5 and vector embeddings. Provides 10 MCP tools for search, retrieval, and memory management using a sophisticated hybrid search pipeline with query expansion, RRF fusion, and neural reranking.
+
+Inspired by [QMD](https://github.com/tobi/qmd) and [OpenClaw](https://github.com/openclaw/openclaw).
+
+## Architecture
+
+```
+User Query
+    │
+    ▼
+┌─────────────────┐
+│ Query Expansion  │ ← qmd-query-expansion-1.7B (GGUF)
+│ (optional)       │   generates 2-3 query variants
+└────────┬────────┘
+         │
+    ┌────┴────┐
+    ▼         ▼
+┌────────┐ ┌──────────┐
+│ BM25   │ │ Vector   │
+│ (FTS5) │ │(sqlite-  │
+│        │ │  vec)    │
+└───┬────┘ └────┬─────┘
+    │           │
+    ▼           ▼
+┌─────────────────┐
+│  RRF Fusion     │ ← k=60, original query 2× weight
+│                 │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  LLM Reranking  │ ← bge-reranker-v2-m3 (GGUF)
+│  (optional)     │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│ Position-Aware  │ ← top 3: 75/25, 4-10: 60/40, 11+: 40/60
+│ Blending        │   (RRF weight / rerank weight)
+└────────┬────────┘
+         │
+         ▼
+    Final Results
+```
+
+## How It Works
+
+### Storage Layer
+
+- **SQLite** via better-sqlite3 for document metadata and content
+- **FTS5** virtual table with porter stemming for BM25 full-text search
+- **sqlite-vec** extension for vector similarity search (cosine distance)
+- **Content-addressed storage** using SHA-256 hash deduplication
+
+### Chunking
+
+Heading-aware markdown chunking that respects document structure:
+
+- **Target size:** 900 tokens (~3600 characters)
+- **Overlap:** 15% between chunks (~540 characters)
+- **Respects boundaries:** Code fences, headings, paragraphs
+- **Break point scoring:** h1=100, h2=90, h3=80, code-fence=80, hr=60, blank-line=40
+
+### Search Pipeline (3 Tiers)
+
+**`memory_search`** — BM25 only (fast, exact keyword matching)
+
+**`memory_vsearch`** — Vector only (semantic similarity via embeddings)
+
+**`memory_query`** — Full hybrid pipeline:
+1. Query expansion generates 2-3 variants (optional)
+2. Parallel BM25 + vector search
+3. RRF fusion (k=60, original query weighted 2×)
+4. LLM reranking with bge-reranker-v2-m3 (optional)
+5. Position-aware blending:
+   - Top 3 results: 75% RRF / 25% rerank
+   - Ranks 4-10: 60% RRF / 40% rerank
+   - Ranks 11+: 40% RRF / 60% rerank
+
+### Collections
+
+- **YAML-configured** directories of markdown files
+- **Auto-indexing** via chokidar file watcher
+- **Incremental updates** using dirty-flag tracking
+- **Session harvesting** converts OpenCode JSON sessions into searchable markdown
+
+## MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `memory_search` | BM25 keyword search (fast) |
+| `memory_vsearch` | Semantic vector search |
+| `memory_query` | Full hybrid search with expansion + reranking |
+| `memory_get` | Retrieve document by path or docid (#abc123) |
+| `memory_multi_get` | Batch retrieve by glob pattern |
+| `memory_write` | Write to daily log or MEMORY.md |
+| `memory_status` | Index health, collections, model status |
+| `memory_index_codebase` | Index codebase files in current workspace |
+| `memory_update` | Trigger reindex of all collections |
+
+## Installation
+
+```bash
+# Clone and install
+git clone <repo-url>
+cd nano-brain
+npm install
+```
+
+Add to OpenCode config (`~/.config/opencode/opencode.json`):
+
+```json
+{
+  "mcp": {
+    "nano-brain": {
+      "type": "local",
+      "command": ["node", "/path/to/nano-brain/bin/cli.js", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+## Configuration
+
+Create `~/.config/nano-brain/config.yml`:
+
+```yaml
+collections:
+  memory:
+    path: ~/.nano-brain
+    pattern: "**/*.md"
+    update: auto
+  
+  project-docs:
+    path: /path/to/project/docs
+    pattern: "**/*.md"
+    update: auto
+  
+  sessions:
+    path: ~/.local/share/opencode/sessions
+    pattern: "**/*.json"
+    update: auto
+```
+
+**Collection options:**
+- `path` — Directory to index
+- `pattern` — Glob pattern for files
+- `update` — `auto` (watch for changes) or `manual`
+
+## CLI Usage
+
+```bash
+# MCP server
+nano-brain mcp              # Start MCP server (stdio)
+nano-brain mcp --http       # Start MCP server (HTTP, port 8282)
+
+# Index management
+nano-brain status           # Show index health
+nano-brain update           # Reindex all collections
+
+# Search
+nano-brain search "query"   # BM25 search
+nano-brain vsearch "query"  # Vector search
+nano-brain query "query"    # Hybrid search
+
+# Collections
+nano-brain collection add <name> <path>     # Add collection
+nano-brain collection remove <name>         # Remove collection
+nano-brain collection list                  # List collections
+```
+
+## Project Structure
+
+```
+src/
+├── index.ts          # CLI entry point
+├── server.ts         # MCP server (10 tools, stdio/HTTP)
+├── store.ts          # SQLite storage (FTS5 + sqlite-vec)
+├── search.ts         # Hybrid search pipeline (RRF, reranking, blending)
+├── chunker.ts        # Heading-aware markdown chunking
+├── collections.ts    # YAML config, collection scanning
+├── embeddings.ts     # GGUF embedding model (nomic-embed-text-v1.5)
+├── reranker.ts       # GGUF reranker model (bge-reranker-v2-m3)
+├── expansion.ts      # GGUF query expansion (qmd-query-expansion-1.7B)
+├── harvester.ts      # OpenCode session → markdown converter
+├── watcher.ts        # File watcher (chokidar, dirty flags)
+└── types.ts          # TypeScript interfaces
+bin/
+└── cli.js            # CLI wrapper
+
+test/
+└── *.test.ts         # 428 tests (vitest)
+SKILL.md              # AI agent routing instructions (auto-loaded by OpenCode)
+AGENTS_SNIPPET.md     # Optional project-level AGENTS.md managed block
+```
+
+## Tech Stack
+
+- **TypeScript + Node.js** (via tsx)
+- **better-sqlite3** + **sqlite-vec** for storage
+- **@modelcontextprotocol/sdk** for MCP server
+- **node-llama-cpp** for GGUF model inference
+- **chokidar** for file watching
+- **vitest** for testing (428 tests)
+
+## Models
+
+All models are GGUF format, loaded on-demand:
+
+- **Embeddings:** nomic-embed-text-v1.5 (~270MB)
+- **Reranker:** bge-reranker-v2-m3 (~1.1GB)
+- **Query Expansion:** qmd-query-expansion-1.7B (~1GB)
+
+Models are downloaded automatically on first use to `~/.cache/nano-brain/models/`.
+
+## How nano-brain Compares
+
+| | nano-brain | Mem0 / OpenMemory | Zep / Graphiti | OMEGA | Letta (MemGPT) | Claude Native |
+|---|---|---|---|---|---|---|
+| **Search** | Hybrid (BM25 + vector + LLM reranking) | Vector only | Graph traversal + vector | Semantic + BM25 | Agent-managed | Text file read |
+| **Storage** | SQLite (single file) | PostgreSQL + Qdrant | Neo4j | SQLite | PostgreSQL / SQLite | Flat text files |
+| **MCP Tools** | 10 | 4-9 | 9-10 | 12 | 7 | 0 |
+| **Local-First** | Yes (zero cloud) | Requires OpenAI API key | Requires Docker + Neo4j | Yes | Yes | Yes |
+| **AI Models** | Local GGUF (nomic-embed, bge-reranker) | Cloud API (OpenAI) | Cloud API | Local ONNX | Cloud API | None |
+| **Codebase Indexing** | Yes (structural boundary detection) | No | No | No | No | No |
+| **Session Recall** | Yes (auto-harvests past sessions) | No | No | No | No | Limited (CLAUDE.md) |
+| **Query Expansion** | Yes (local LLM) | No | No | No | No | No |
+| **LLM Reranking** | Yes (bge-reranker-v2-m3) | No | No | No | No | No |
+| **Privacy** | 100% local, no data leaves machine | Cloud API calls | Cloud or self-host | 100% local | Self-host or cloud | Local files |
+| **Dependencies** | SQLite + GGUF models (~1.5GB) | Docker + PostgreSQL + Qdrant + OpenAI key | Docker + Neo4j | SQLite + ONNX | PostgreSQL | None |
+| **Pricing** | Free (open source, MIT) | Free tier / Pro $249/mo | Free self-host / Cloud $25-475/mo | Free (Apache-2.0) | Free (Apache-2.0) | Free (with Claude) |
+| **GitHub Stars** | New | ~47K | ~23K | ~25 | ~21K | N/A |
+
+### Where nano-brain shines
+
+- **Hybrid search pipeline** — the only MCP memory server with BM25 + vector + query expansion + LLM reranking in a single pipeline
+- **Codebase indexing** — index your source files with structural boundary detection, not just conversations
+- **Session recall** — automatically harvests and indexes past AI coding sessions
+- **Zero dependencies** — single SQLite file, local GGUF models, no Docker/PostgreSQL/Neo4j/API keys
+- **Privacy** — 100% local processing, your code and conversations never leave your machine
+
+### Consider alternatives if
+
+- You need a knowledge graph with temporal reasoning (Zep/Graphiti)
+- You want a full agent framework, not just memory (Letta)
+- You need cloud-hosted memory shared across teams (Mem0 Cloud)
+- You only need basic session notes (Claude native memory)
+
+## AI Agent Integration
+
+nano-brain ships with a SKILL.md that teaches AI agents when and how to use memory tools. When loaded as an OpenCode skill, agents automatically:
+
+- **Check memory before starting work** — recall past decisions, patterns, and context
+- **Save context after completing work** — persist key decisions and debugging insights
+- **Route queries to the right search tool** — BM25 for exact terms, vector for concepts, hybrid for best quality
+
+### SKILL.md (Auto-loaded)
+
+The skill file at `SKILL.md` provides routing rules, trigger phrases, tool selection guides, and integration patterns. It's automatically loaded when any agent references the `nano-brain` skill.
+
+### AGENTS_SNIPPET.md (Optional, project-level)
+
+For project-level integration, `AGENTS_SNIPPET.md` provides a managed block that can be injected into a project's `AGENTS.md`:
+
+```bash
+# Future: npx nano-brain init
+# For now: copy the managed block from AGENTS_SNIPPET.md into your project's AGENTS.md
+```
+
+See [SKILL.md](./SKILL.md) for full routing rules and [AGENTS_SNIPPET.md](./AGENTS_SNIPPET.md) for the project-level snippet.
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,153 @@
+# nano-brain
+
+Persistent memory system for OpenCode. Hybrid search across past sessions, codebase, curated notes, and daily logs.
+
+## When to Use (Routing Rules)
+
+### ALWAYS use memory BEFORE starting work when:
+
+- **Resuming or continuing work** — "continue", "pick up where we left off", "what were we doing"
+- **Referencing past decisions** — "we decided", "last time", "previously", "remember when"
+- **Cross-session context** — "what did we do about X", "how did we solve Y before"
+- **Unfamiliar codebase area** — search memory for past exploration sessions before re-exploring
+- **Repeated patterns** — "same as before", "like we did for X", "follow the same approach"
+
+### ALWAYS use memory AFTER completing work:
+
+- **Save key decisions** — architecture choices, tradeoffs, rejected alternatives
+- **Save implementation patterns** — reusable approaches discovered during work
+- **Save debugging insights** — root causes, non-obvious fixes, gotchas
+- **Save project context** — domain knowledge, business rules, conventions learned
+
+### Trigger Phrases (auto-route to memory)
+
+| Phrase | Action |
+|--------|--------|
+| "what did we...", "have we ever...", "did we already..." | `memory_query` → recall past work |
+| "remember", "last time", "before", "previously" | `memory_query` → find past context |
+| "save this", "remember this", "note that" | `memory_write` → persist to memory |
+| "what's the status of memory", "is memory indexed" | `memory_status` → check health |
+| Starting a new feature in a known area | `memory_query` → find past sessions in that area |
+| Debugging a recurring issue | `memory_search` → find past fixes |
+
+## Tool Selection Guide
+
+### Which search tool to use:
+
+| Scenario | Tool | Why |
+|----------|------|-----|
+| Exact function/variable name, error message | `memory_search` (BM25) | Fast exact keyword matching |
+| Conceptual question ("how does X work") | `memory_vsearch` (semantic) | Understands meaning, not just keywords |
+| Complex question, best quality needed | `memory_query` (hybrid) | BM25 + vector + LLM reranking |
+| Retrieve a specific known document | `memory_get` | Direct fetch by path or docid |
+| Save a decision or insight | `memory_write` | Persist to daily log or MEMORY.md |
+
+### Search strategy for best results:
+
+1. **Start with `memory_query`** for complex/conceptual questions (best quality)
+2. **Use `memory_search`** for exact terms — function names, error codes, specific strings
+3. **Use `memory_vsearch`** when you want semantic similarity without reranking overhead
+4. **Combine with native tools** — memory excels at recall and semantic search; grep/ast-grep excel at precise code pattern matching
+
+### Collection filtering:
+
+- `collection: "codebase"` — search only indexed source files
+- `collection: "sessions-{project}"` — search only past sessions for a specific project
+- `collection: "curated"` — search only manually saved notes
+- Omit `collection` — search everything (recommended default)
+
+## Available Tools
+
+### memory_search
+BM25 keyword search. Fast, exact matching.
+- query: Search query (required)
+- limit: Max results (default: 10)
+- collection: Filter by collection
+
+### memory_vsearch
+Semantic vector search using embeddings.
+- query: Search query (required)
+- limit: Max results (default: 10)
+- collection: Filter by collection
+
+### memory_query
+Full hybrid search with query expansion, RRF fusion, and LLM reranking. Best quality.
+- query: Search query (required)
+- limit: Max results (default: 10)
+- collection: Filter by collection
+- minScore: Minimum score threshold
+
+### memory_get
+Retrieve a document by path or docid.
+- id: Document path or #docid (required)
+- fromLine: Start line number
+- maxLines: Number of lines to return
+
+### memory_multi_get
+Batch retrieve documents by glob pattern or comma-separated list.
+- pattern: Glob pattern or comma-separated docids/paths (required)
+- maxBytes: Maximum total bytes to return (default: 50000)
+
+### memory_write
+Write content to daily log or MEMORY.md.
+- content: Content to write (required)
+- target: "daily" for daily log, "memory" for MEMORY.md (default: "daily")
+
+### memory_status
+Show index health, collection info, and model status.
+
+### memory_index_codebase
+Index codebase files in the current workspace.
+- root: Workspace root path (optional, defaults to current workspace)
+
+### memory_update
+Trigger immediate reindex of all collections.
+
+## Integration with Agent Workflow
+
+### As an orchestrator (Sisyphus):
+
+```
+# Before starting any non-trivial task, check memory:
+memory_query("what have we done regarding {topic}")
+
+# After completing significant work, save context:
+memory_write("## {date} - {topic}\n- Decision: ...\n- Reason: ...\n- Files changed: ...")
+
+# When delegating to subagents, include memory context:
+task(category="...", load_skills=["nano-brain"], prompt="... CONTEXT from memory: ...")
+```
+
+### As a subagent:
+
+```
+# If the task involves an area you're unfamiliar with:
+memory_query("{area} implementation patterns")
+
+# If debugging and the fix isn't obvious:
+memory_search("{error message or symptom}")
+```
+
+## Memory vs Native Tools
+
+| Capability | nano-brain | Native (grep/glob/ast-grep) |
+|-----------|----------------|---------------------------|
+| Past session recall | ✅ Searches all past sessions | ❌ session_search is basic text match |
+| Semantic understanding | ✅ "notification workflow" finds related concepts | ❌ Literal pattern matching only |
+| Cross-project knowledge | ✅ Searches across all indexed workspaces | ❌ Scoped to current directory |
+| Exact code patterns | ⚠️ BM25 works, but less precise | ✅ ast-grep, grep are superior |
+| Structural code search | ❌ Not AST-aware | ✅ ast-grep matches code structure |
+| Curated knowledge | ✅ MEMORY.md + daily logs | ❌ No equivalent |
+
+**They are complementary.** Use memory for recall + semantics, native tools for precise code matching.
+
+## First-Time Setup
+
+If memory is not yet indexed for a workspace:
+
+```
+memory_status                              # Check current state
+memory_index_codebase root="/path/to/ws"   # Index codebase files
+memory_update                              # Trigger reindex of sessions + curated
+memory_status                              # Verify completion
+```

package/bin/cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const entry = join(__dirname, '..', 'src', 'index.ts');
+const tsxBin = join(__dirname, '..', 'node_modules', '.bin', 'tsx');
+const args = process.argv.slice(2);
+
+try {
+  execFileSync(tsxBin, [entry, ...args], { stdio: 'inherit' });
+} catch (err) {
+  process.exit(err.status || 1);
+}