@miriad-systems/nuum 0.1.10 → 0.1.12

package/README.md

@@ -1,82 +1,234 @@
 # Nuum
 
-An AI coding agent with continuous memory — infinite context across sessions.
+An AI coding agent with **"infinite memory"** — continuous context across sessions.
 
 *Nuum* — from "continuum" — maintains persistent memory across conversations, learning your codebase, preferences, and decisions over time.
 
-## Design Philosophy
+## Quick Start
 
-Nuum is **optimized for embedding**. While it can run standalone, it's designed to be integrated into host applications, IDEs, and orchestration platforms via a simple **NDJSON-over-stdio** protocol.
+```bash
+export ANTHROPIC_API_KEY=your-key-here
 
-- **Stateless process, stateful memory** — The process can restart anytime; all state lives in SQLite
-- **Simple wire protocol** — JSON messages over stdin/stdout, easy to integrate from any language
-- **Mid-turn injection** — Send corrections while the agent is working; they're injected into the conversation
-- **Persistent identity** — One database = one agent with continuous memory forever
+# Install and run interactively
+bunx @miriad-systems/nuum --repl
 
-See [docs/protocol.md](docs/protocol.md) for the full wire protocol specification.
+# Or with npx
+npx @miriad-systems/nuum --repl
+```
 
-## Installation
+That's it. Start chatting. Your agent remembers everything.
 
-```bash
-# Using bunx (recommended - runs in Bun, fast)
-bunx @miriad-systems/nuum
+### REPL Commands
 
-# Using npx (runs in Node.js)
-npx @miriad-systems/nuum
 ```
+/help     Show available commands
+/inspect  Show memory statistics
+/dump     Show full system prompt
+/quit     Exit
+```
+
+### Other Modes
+
+```bash
+nuum -p "What files are in src/"     # Single prompt
+nuum --inspect                        # View memory stats
+nuum --db ./project.db --repl         # Custom database
+```
+
+---
+
+## ⚠️ Experimental Software
+
+Nuum currently runs in **full autonomy mode** — no permission prompts, no confirmations. It was created for [Miriad](https://miriad.systems) as an embedded agent engine, typically running in containerized environments where the host platform manages security.
+
+**Why we built this:** We were frustrated with how traditional coding agents seem to suffer some kind of contextual collapse after prolonged use — getting mixed up, repeating mistakes, losing track of decisions. Nuum explores how to keep agents effective indefinitely through recursive memory compression and persistent knowledge.
 
-## Usage
+---
 
-### Embedded Mode (for host applications)
+## MCP Servers
+
+Nuum supports [Model Context Protocol](https://modelcontextprotocol.io/) servers for extended capabilities. Configure via environment variable:
 
 ```bash
-nuum --stdio              # NDJSON protocol over stdin/stdout
-nuum --stdio --db ./my.db # With custom database
+export NUUM_MCP_SERVERS='{
+  "filesystem": {
+    "command": "npx",
+    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
+  },
+  "github": {
+    "command": "npx", 
+    "args": ["-y", "@modelcontextprotocol/server-github"],
+    "env": { "GITHUB_TOKEN": "your-token" }
+  }
+}'
 ```
 
-Send JSON messages to stdin, receive responses on stdout:
+Or pass via protocol when embedding:
 
 ```json
-→ {"type":"user","message":{"role":"user","content":"Hello"}}
-← {"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Hello! How can I help?"}]},"session_id":"nuum_01JD..."}
-← {"type":"result","subtype":"success","duration_ms":800,"session_id":"nuum_01JD..."}
+{"type":"user","message":{...},"mcp_servers":{"name":{"command":"...","args":[...]}}}
 ```
 
-### Interactive Mode
+MCP tools appear alongside built-in tools. The agent discovers and uses them automatically.
+
+---
+
+## Embedding in Applications
+
+Nuum is designed to be **embedded**. While it runs standalone, its primary use case is integration into host applications, IDEs, and orchestration platforms.
 
 ```bash
-nuum                      # Start interactive session
-nuum --db ./my-project.db # With specific database
+nuum --stdio              # NDJSON protocol over stdin/stdout
+nuum --stdio --db ./my.db # With custom database
 ```
 
-### Batch Mode
+**Key properties:**
+- **Stateless process, stateful memory** — Process can restart anytime; all state lives in SQLite
+- **Simple wire protocol** — JSON messages over stdin/stdout, easy to integrate from any language
+- **Mid-turn injection** — Send corrections while the agent is working
+- **Persistent identity** — One database = one agent with continuous memory
+
+See **[docs/protocol.md](docs/protocol.md)** for the full wire protocol specification.
 
-```bash
-nuum -p "What is 2+2?"
-nuum -p "Read src/index.ts and explain what it does"
-nuum -p "Refactor the auth module" --verbose
+---
+
+## Memory Architecture
+
+Nuum has a three-tier memory system that mirrors human cognition.
+
+**Key insight:** Agents perform best when context is **30-50% full** — informed but not overwhelmed. Nuum's memory system maintains this sweet spot automatically.
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              WORKING MEMORY                                  │
+│                         (Temporal Message Store)                             │
+│                                                                              │
+│  Recent messages live here in full detail. As context grows, older          │
+│  content is recursively distilled — compressed while retaining what         │
+│  matters for effective action.                                              │
+│                                                                              │
+│  ┌─────────────────────────────────────────────────────────────────────┐    │
+│  │ msg msg msg msg msg msg msg msg msg msg msg msg msg msg msg msg ... │    │
+│  │  │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │      │    │
+│  │  └───┴───┴───┴───┘   └───┴───┴───┘   └───┴───┴───┘   │   │   │      │    │
+│  │         │                   │               │         │   │   │      │    │
+│  │    [distill-1]         [distill-2]    [distill-3]    │   │   │      │    │
+│  │         │                   │               │         │   │   │      │    │
+│  │         └───────────────────┴───────────────┘         │   │   │      │    │
+│  │                             │                         │   │   │      │    │
+│  │                      [distill-4]                      │   │   │      │    │
+│  │                             │                         │   │   │      │    │
+│  │                             └─────────────────────────┘   │   │      │    │
+│  │                                         │                 │   │      │    │
+│  │                                   [distill-5]        [recent msgs]   │    │
+│  │                                                                      │    │
+│  │  Older ◄──────────────────────────────────────────────────► Newer   │    │
+│  └─────────────────────────────────────────────────────────────────────┘    │
+│                                                                              │
+│  The agent sees: [distill-5] + [recent messages]                            │
+│  55x compression ratio achieved (1.3M tokens → 25k effective)               │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              PRESENT STATE                                   │
+│                                                                              │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────────────┐      │
+│  │   Mission   │  │   Status    │  │            Tasks                │      │
+│  │             │  │             │  │  ☑ Setup repository             │      │
+│  │  "Build     │  │ "reviewing  │  │  ☑ Implement auth               │      │
+│  │   auth      │  │  PR #42"    │  │  ☐ Write tests                  │      │
+│  │   system"   │  │             │  │  ☐ Deploy to staging            │      │
+│  └─────────────┘  └─────────────┘  └─────────────────────────────────┘      │
+│                                                                              │
+│  Agent-managed working state. Updated as work progresses.                   │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                            LONG-TERM MEMORY                                  │
+│                          (Knowledge Base Tree)                               │
+│                                                                              │
+│  /identity ─────────────── "Who I am, my nature and relationships"          │
+│  /behavior ─────────────── "How I should operate, user preferences"         │
+│  /miriad-code                                                                │
+│    ├── /cast-integration ─ "CAST/Miriad integration notes"                  │
+│    ├── /memory                                                               │
+│    │     └── /background-reports-system                                      │
+│    ├── /anthropic-prompt-caching                                             │
+│    └── /distillation-improvements-jan2026                                    │
+│  /mcp                                                                        │
+│    ├── /mcp-implementation                                                   │
+│    └── /mcp-config-resolution                                                │
+│                                                                              │
+│  Hierarchical knowledge that persists forever. Background workers           │
+│  extract important information from conversations and organize it here.     │
+└─────────────────────────────────────────────────────────────────────────────┘
 ```
 
-### CLI Reference
+### Recursive Distillation
+
+**No pause for compaction.** Unlike most coding agents that stop mid-conversation to "compact memory," Nuum's distillation runs concurrently while you work. You never wait for memory management — it happens invisibly in the background.
+
+The distillation system is **not summarization** — it's operational intelligence extraction:
+
+**RETAIN** (actionable intelligence):
+- File paths and what they contain
+- Decisions made and WHY (rationale matters)
+- User preferences and corrections
+- Specific values: URLs, configs, commands
+- Errors and how they were resolved
+
+**EXCISE** (noise):
+- Back-and-forth debugging that led nowhere
+- Missteps and corrections (keep only final approach)
+- Verbose tool outputs
+- Narrative filler ("Let me check...")
+- Casual chatter and acknowledgments
+
+Distillations are recursive — older distillations get distilled again, creating a fractal compression where ancient history becomes highly compressed while recent work stays detailed.
+
+### Long-Term Memory Curation
+
+A background worker (the **LTM Curator**) runs continuously in the background:
+
+1. **CAPTURES** important information into knowledge entries
+2. **STRENGTHENS** entries by researching and adding context  
+3. **CURATES** the knowledge tree structure
+
+The curator has access to web search, file reading, and the full knowledge base. It works autonomously — you never see it running, but the agent's knowledge grows over time. Reports are filed silently and surfaced to the main agent on the next interaction.
+
+### Reflection
+
+When the agent needs to recall something specific — a file path, a decision, a value from weeks ago — it uses the **reflect** tool:
 
 ```
-nuum                          Start interactive session
-nuum --stdio                  Embedded mode (NDJSON protocol)
-nuum -p "prompt"              Batch mode
-nuum --help                   Show help
-
-Options:
-  -p, --prompt <text>   Run with a prompt (batch mode)
-  -v, --verbose         Show memory state and debug output
-      --stdio           NDJSON protocol mode for embedding
-      --db <path>       SQLite database path (default: ./agent.db)
-      --format <type>   Output format: text or json (default: text)
-  -h, --help            Show help message
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              REFLECTION                                      │
+│                                                                              │
+│   Main Agent                         Reflection Sub-Agent                    │
+│       │                                      │                               │
+│       │  "What was the auth bug fix?"        │                               │
+│       │ ────────────────────────────────────►│                               │
+│       │                                      │                               │
+│       │                          ┌───────────┴───────────┐                   │
+│       │                          │  Search FTS index     │                   │
+│       │                          │  Search LTM entries   │                   │
+│       │                          │  Read relevant docs   │                   │
+│       │                          │  Synthesize answer    │                   │
+│       │                          └───────────┬───────────┘                   │
+│       │                                      │                               │
+│       │  "The auth bug was in session.ts,    │                               │
+│       │   line 42. Fixed by adding null      │                               │
+│       │   check. Committed in abc123."       │                               │
+│       │ ◄────────────────────────────────────│                               │
+│       │                                      │                               │
+└─────────────────────────────────────────────────────────────────────────────┘
 ```
 
-## Configuration
+Reflection searches the full conversation history (via FTS5 full-text search) and the knowledge base, then synthesizes an answer. It's like the agent asking its own memory system a question.
 
-Only `ANTHROPIC_API_KEY` is required:
+---
+
+## Configuration
 
 ```bash
 # Required
@@ -89,16 +241,7 @@ AGENT_MODEL_FAST=claude-haiku-4-5-20251001
 AGENT_DB=./agent.db
 ```
 
-## How Memory Works
-
-### Temporal Memory (Working Memory)
-Every message is logged chronologically. As the conversation grows, older content is **distilled** — compressed to retain actionable intelligence: file paths, decisions and rationale, user preferences, specific values.
-
-### Present State
-Tracks the current mission, status, and task list. Updated by the agent as work progresses. Always visible in context.
-
-### Long-Term Memory (LTM)
-A hierarchical knowledge base that persists across sessions. Contains identity, behavioral guidelines, and accumulated knowledge. Background workers consolidate important information from conversations into LTM.
+---
 
 ## Development
 
@@ -110,6 +253,8 @@ bun test             # Run tests
 bun run build        # Build for distribution
 ```
 
+---
+
 ## Acknowledgments
 
 ### Letta (formerly MemGPT)
@@ -126,6 +271,14 @@ Infrastructure adapted from [OpenCode](https://github.com/anthropics/opencode):
 - Permission system
 - Process management
 
+---
+
 ## License
 
 MIT
+
+---
+
+<p align="center">
+  Nuum is part of <a href="https://miriad.systems">Miriad</a>, experimental software from <a href="https://sanity.io">Sanity.io</a>
+</p>

package/dist/index.js

@@ -16933,7 +16933,7 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
-// node_modules/cross-spawn/node_modules/which/node_modules/isexe/windows.js
+// node_modules/cross-spawn/node_modules/isexe/windows.js
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
@@ -16971,7 +16971,7 @@ var require_windows = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/cross-spawn/node_modules/which/node_modules/isexe/mode.js
+// node_modules/cross-spawn/node_modules/isexe/mode.js
 var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
@@ -17002,7 +17002,7 @@ var require_mode = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/cross-spawn/node_modules/which/node_modules/isexe/index.js
+// node_modules/cross-spawn/node_modules/isexe/index.js
 var require_isexe = __commonJS((exports, module) => {
   var fs7 = __require("fs");
   var core2;
@@ -32053,6 +32053,18 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/context/environment.ts
+var currentEnvironment = {};
+function setEnvironment(env) {
+  currentEnvironment = env;
+}
+function getSpawnEnvironment() {
+  return {
+    ...process.env,
+    ...currentEnvironment
+  };
+}
+
 // src/tool/bash.ts
 var MAX_OUTPUT_LENGTH = 50000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
@@ -32094,7 +32106,7 @@ Use this tool for:
     const proc = spawn2(params.command, {
       shell,
       cwd,
-      env: { ...process.env },
+      env: getSpawnEnvironment(),
       stdio: ["ignore", "pipe", "pipe"],
       detached: process.platform !== "win32"
     });
@@ -33791,7 +33803,8 @@ var Ripgrep;
     }
     const proc = spawn3(rgPath, args, {
       cwd: input.cwd,
-      stdio: ["ignore", "pipe", "ignore"]
+      stdio: ["ignore", "pipe", "ignore"],
+      env: getSpawnEnvironment()
     });
     let buffer = "";
     for await (const chunk of proc.stdout) {
@@ -33941,7 +33954,8 @@ Respects .gitignore patterns.`,
     }
     args.push(searchPath);
     const proc = spawn4(rgPath, args, {
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      env: getSpawnEnvironment()
     });
     let output = "";
     let errorOutput = "";
@@ -34455,6 +34469,10 @@ Use reflect when:
 - You need a specific value or path from earlier work
 - The user asks "remember when..." or "what did we decide about..."
 - You want to verify your memory before acting
+
+## Message Prefixes
+
+Messages in your history have automatic prefixes like \`[2026-01-26 15:30 id:msg_xxx]\` showing timestamp and ID. These are added by the system for internal tracking - you don't need to reference or echo them. Just read the message content normally.
 `;
   const systemPromptOverlay = await storage.session.getSystemPromptOverlay();
   if (systemPromptOverlay) {
@@ -34545,14 +34563,29 @@ Retained facts:
   }
   return turns;
 }
-function formatWithId(id, content) {
-  return `[id:${id}] ${content}`;
+function formatTimestamp(isoTimestamp) {
+  const date2 = new Date(isoTimestamp);
+  const year = date2.getFullYear();
+  const month = String(date2.getMonth() + 1).padStart(2, "0");
+  const day = String(date2.getDate()).padStart(2, "0");
+  const hours = String(date2.getHours()).padStart(2, "0");
+  const minutes = String(date2.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+function formatWithId(id, timestamp, content) {
+  return `[${formatTimestamp(timestamp)} id:${id}] ${content}`;
+}
+function formatIdRange(firstId, lastId, timestamp) {
+  if (firstId === lastId) {
+    return `[${formatTimestamp(timestamp)} id:${firstId}]`;
+  }
+  return `[${formatTimestamp(timestamp)} id:${firstId}...${lastId}]`;
 }
 function processMessageForTurn(message, allMessages, currentIdx) {
   const turns = [];
   switch (message.type) {
     case "user":
-      turns.push({ role: "user", content: formatWithId(message.id, message.content) });
+      turns.push({ role: "user", content: formatWithId(message.id, message.createdAt, message.content) });
       return { turns, nextIdx: currentIdx + 1 };
     case "assistant": {
       const toolCalls = [];
@@ -34594,7 +34627,7 @@ function processMessageForTurn(message, allMessages, currentIdx) {
       }
       if (toolCalls.length > 0) {
         const assistantContent = [];
-        const idPrefix = message.id === lastMessageId ? `[id:${message.id}]` : `[id:${message.id}...${lastMessageId}]`;
+        const idPrefix = formatIdRange(message.id, lastMessageId, message.createdAt);
         if (message.content) {
           assistantContent.push({ type: "text", text: `${idPrefix} ${message.content}` });
         } else {
@@ -34614,7 +34647,7 @@ function processMessageForTurn(message, allMessages, currentIdx) {
           turns.push(toolMsg);
         }
       } else {
-        turns.push({ role: "assistant", content: formatWithId(message.id, message.content) });
+        turns.push({ role: "assistant", content: formatWithId(message.id, message.createdAt, message.content) });
       }
       return { turns, nextIdx };
     }
@@ -34658,7 +34691,7 @@ function processMessageForTurn(message, allMessages, currentIdx) {
         nextIdx++;
       }
       if (toolCalls.length > 0) {
-        const idPrefix = firstMessageId === lastMessageId ? `[id:${firstMessageId}]` : `[id:${firstMessageId}...${lastMessageId}]`;
+        const idPrefix = formatIdRange(firstMessageId, lastMessageId, message.createdAt);
         const assistantContent = [
           { type: "text", text: idPrefix },
           ...toolCalls
@@ -34686,7 +34719,7 @@ function processMessageForTurn(message, allMessages, currentIdx) {
     case "system":
       turns.push({
         role: "assistant",
-        content: `[system ${formatWithId(message.id, message.content)}]`
+        content: `[system ${formatWithId(message.id, message.createdAt, message.content)}]`
       });
       return { turns, nextIdx: currentIdx + 1 };
     default:
@@ -35039,11 +35072,13 @@ Your working memory (conversation history) needs to be optimized for effective a
 ${underTarget ? "**Status:** Already at/under target. You may clean up noise if you see any, or call finish_distillation." : `**To distill:** ~${(currentTokens - targetTokens).toLocaleString()} tokens`}
 **Recency buffer:** ${recencyBuffer} most recent messages are protected
 
-The conversation above contains IDs you can reference:
-- Messages have \`[id:xxx]\` prefixes
+The conversation above contains timestamps and IDs you can reference:
+- Messages have \`[YYYY-MM-DD HH:MM id:xxx]\` prefixes (timestamp + ID)
 - Distillations show \`[distilled from:xxx to:yyy]\` ranges
 - The most recent ${recencyBuffer} messages cannot be distilled (preserve immediate context)
 
+Note: These prefixes are for YOUR reference when creating distillations. Do not echo them in responses.
+
 ## Your Task: Distill, Don't Summarize
 
 The goal is NOT narrative summarization ("we discussed X and decided Y").
@@ -45552,7 +45587,7 @@ async function runAgent(prompt, options) {
 
 // src/cli/verbose.ts
 var SEPARATOR = "\u2500".repeat(70);
-function formatTimestamp() {
+function formatTimestamp2() {
   return new Date().toISOString().slice(11, 23);
 }
 
@@ -45632,7 +45667,7 @@ LTM:`);
     this.events = [];
   }
   event(event) {
-    const ts = event.timestamp ?? formatTimestamp();
+    const ts = event.timestamp ?? formatTimestamp2();
     const arrow = event.type === "user" || event.type === "tool_result" ? "\u2192" : "\u2190";
     const typeLabel = event.type.replace("_", " ");
     const content = event.content.length > 100 ? event.content.slice(0, 100) + "..." : event.content;
@@ -46155,7 +46190,8 @@ var UserMessageSchema = exports_external.object({
   }),
   session_id: exports_external.string().optional(),
   system_prompt: exports_external.string().optional(),
-  mcp_servers: exports_external.record(exports_external.unknown()).optional()
+  mcp_servers: exports_external.record(exports_external.unknown()).optional(),
+  environment: exports_external.record(exports_external.string()).optional()
 });
 var ControlRequestSchema = exports_external.object({
   type: exports_external.literal("control"),
@@ -46351,6 +46387,14 @@ class Server {
     if (userMessage.mcp_servers !== undefined) {
       await this.reinitializeMcpWithOverride(userMessage.mcp_servers);
     }
+    if (userMessage.environment !== undefined) {
+      setEnvironment(userMessage.environment);
+      log11.info("applied environment from message", {
+        count: Object.keys(userMessage.environment).length
+      });
+    } else {
+      setEnvironment({});
+    }
     this.currentTurn = {
       sessionId,
       abortController,
@@ -46582,12 +46626,6 @@ Goodbye!`);
         console.log("Goodbye!");
         process.exit(0);
         break;
-      case "clear":
-        this.storage = createStorage(this.options.dbPath);
-        await initializeDefaultEntries(this.storage);
-        console.log("Conversation cleared. Starting fresh session.");
-        this.rl?.prompt();
-        break;
       case "inspect":
         try {
           await runInspect(this.options.dbPath);
@@ -46621,7 +46659,6 @@ Goodbye!`);
     console.log("Commands:");
     console.log("  /help, /h, /?    Show this help");
     console.log("  /quit, /exit, /q Exit the REPL");
-    console.log("  /clear           Clear conversation history (fresh session)");
     console.log("  /inspect         Show memory statistics");
     console.log("  /dump            Show full system prompt");
     console.log();
@@ -46767,288 +46804,9 @@ async function runRepl(options) {
   await session.start();
 }
 
-// src/cli/repl-protocol.ts
-import * as readline3 from "readline";
-import * as fs9 from "fs";
-import * as path10 from "path";
-import * as os4 from "os";
-import { spawn as spawn6 } from "child_process";
-var PROMPT2 = "protocol> ";
-var HISTORY_FILE2 = path10.join(os4.homedir(), ".miriad-code-protocol-history");
-var MAX_HISTORY2 = 1000;
-
-class ProtocolReplSession {
-  options;
-  rl = null;
-  serverProcess = null;
-  history = [];
-  isRunning = false;
-  sessionId = `session_${Date.now()}`;
-  lineBuffer = "";
-  constructor(options) {
-    this.options = options;
-  }
-  async start() {
-    this.loadHistory();
-    this.startServer();
-    this.rl = readline3.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: PROMPT2,
-      historySize: MAX_HISTORY2,
-      terminal: true
-    });
-    for (const line of this.history) {
-      this.rl.history?.unshift(line);
-    }
-    this.rl.on("SIGINT", () => {
-      if (this.isRunning) {
-        this.sendControl("interrupt");
-        process.stdout.write(`
-^C - Interrupt sent
-`);
-      } else {
-        process.stdout.write(`
-(Use /quit or Ctrl+D to exit)
-`);
-        this.rl?.prompt();
-      }
-    });
-    this.rl.on("close", () => {
-      this.shutdown();
-    });
-    this.rl.on("line", (line) => {
-      this.handleLine(line).catch((error2) => {
-        console.error(`Error: ${error2 instanceof Error ? error2.message : String(error2)}`);
-        this.rl?.prompt();
-      });
-    });
-    this.printWelcome();
-    this.rl.prompt();
-  }
-  startServer() {
-    const args = ["run", "src/cli/index.ts", "--stdio", "--db", this.options.dbPath];
-    this.serverProcess = spawn6("bun", args, {
-      stdio: ["pipe", "pipe", "inherit"],
-      cwd: process.cwd()
-    });
-    this.serverProcess.stdout?.on("data", (data) => {
-      this.lineBuffer += data.toString();
-      const lines = this.lineBuffer.split(`
-`);
-      this.lineBuffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.trim()) {
-          this.handleServerMessage(line.trim());
-        }
-      }
-    });
-    this.serverProcess.on("exit", (code) => {
-      console.log(`
-Server exited with code ${code}`);
-      process.exit(code ?? 0);
-    });
-    this.serverProcess.on("error", (error2) => {
-      console.error(`Server error: ${error2.message}`);
-      process.exit(1);
-    });
-  }
-  handleServerMessage(line) {
-    try {
-      const msg = JSON.parse(line);
-      this.displayMessage(msg);
-    } catch (error2) {}
-  }
-  displayMessage(msg) {
-    process.stdout.write("\r\x1B[K");
-    switch (msg.type) {
-      case "assistant":
-        const text3 = msg.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-        if (text3) {
-          console.log(`\x1B[36m${text3}\x1B[0m`);
-        }
-        break;
-      case "result":
-        this.isRunning = false;
-        const status = msg.subtype === "success" ? "\x1B[32m\u2713\x1B[0m" : msg.subtype === "cancelled" ? "\x1B[33m\u2298\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
-        console.log(`
-${status} ${msg.subtype} (${msg.duration_ms}ms, ${msg.num_turns} turns)`);
-        if (msg.usage) {
-          console.log(`  tokens: ${msg.usage.input_tokens} in / ${msg.usage.output_tokens} out`);
-        }
-        this.rl?.prompt();
-        break;
-      case "system":
-        switch (msg.subtype) {
-          case "queued":
-            console.log(`\x1B[90m[Queued: position ${msg.position}]\x1B[0m`);
-            break;
-          case "injected":
-            console.log(`\x1B[90m[Injected: ${msg.message_count} message(s)]\x1B[0m`);
-            break;
-          case "interrupted":
-            console.log(`\x1B[33m[Interrupted]\x1B[0m`);
-            break;
-          case "status":
-            console.log(`\x1B[90m[Status: running=${msg.running}, queued=${msg.queued_messages}]\x1B[0m`);
-            this.rl?.prompt();
-            break;
-          case "tool_result":
-            break;
-          case "error":
-            console.log(`\x1B[31m[Error: ${msg.message}]\x1B[0m`);
-            break;
-          default:
-            console.log(`\x1B[90m[${msg.subtype}]\x1B[0m`);
-        }
-        break;
-    }
-  }
-  printWelcome() {
-    console.log();
-    console.log("miriad-code protocol REPL");
-    console.log("Type messages to send to the agent via protocol");
-    console.log("Messages sent while agent is working will be injected mid-turn");
-    console.log("Type /help for commands");
-    console.log();
-  }
-  async handleLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      this.rl?.prompt();
-      return;
-    }
-    this.addToHistory(trimmed);
-    if (trimmed.startsWith("/")) {
-      await this.handleCommand(trimmed);
-      return;
-    }
-    this.sendUserMessage(trimmed);
-  }
-  async handleCommand(input) {
-    const parts = input.slice(1).split(/\s+/);
-    const command = parts[0].toLowerCase();
-    switch (command) {
-      case "quit":
-      case "exit":
-      case "q":
-        this.shutdown();
-        break;
-      case "status":
-        this.sendControl("status");
-        break;
-      case "interrupt":
-      case "cancel":
-        this.sendControl("interrupt");
-        break;
-      case "help":
-      case "h":
-      case "?":
-        this.printHelp();
-        this.rl?.prompt();
-        break;
-      default:
-        console.log(`Unknown command: /${command}`);
-        console.log("Type /help for available commands.");
-        this.rl?.prompt();
-    }
-  }
-  printHelp() {
-    console.log();
-    console.log("Commands:");
-    console.log("  /help, /h, /?     Show this help");
-    console.log("  /quit, /exit, /q  Exit the REPL");
-    console.log("  /status           Get server status");
-    console.log("  /interrupt        Cancel current turn");
-    console.log();
-    console.log("Shortcuts:");
-    console.log("  Ctrl+C            Send interrupt");
-    console.log("  Ctrl+D            Exit");
-    console.log();
-    console.log("Mid-turn messaging:");
-    console.log("  Type while the agent is working to inject messages");
-    console.log("  Messages are queued and injected before the next model call");
-    console.log();
-  }
-  sendUserMessage(content) {
-    const msg = {
-      type: "user",
-      message: { role: "user", content },
-      session_id: this.sessionId
-    };
-    this.serverProcess?.stdin?.write(JSON.stringify(msg) + `
-`);
-    this.isRunning = true;
-  }
-  sendControl(action) {
-    const msg = { type: "control", action };
-    this.serverProcess?.stdin?.write(JSON.stringify(msg) + `
-`);
-  }
-  shutdown() {
-    this.saveHistory();
-    console.log(`
-Goodbye!`);
-    this.serverProcess?.kill();
-    process.exit(0);
-  }
-  loadHistory() {
-    try {
-      if (fs9.existsSync(HISTORY_FILE2)) {
-        const content = fs9.readFileSync(HISTORY_FILE2, "utf-8");
-        this.history = content.split(`
-`).filter((line) => line.trim()).slice(-MAX_HISTORY2);
-      }
-    } catch {}
-  }
-  saveHistory() {
-    try {
-      const rlHistory = this.rl?.history || [];
-      const allHistory = [...new Set([...rlHistory.reverse(), ...this.history])];
-      const trimmed = allHistory.slice(-MAX_HISTORY2);
-      fs9.writeFileSync(HISTORY_FILE2, trimmed.join(`
-`) + `
-`);
-    } catch {}
-  }
-  addToHistory(line) {
-    if (line.startsWith("/"))
-      return;
-    this.history.push(line);
-  }
-}
-async function runProtocolRepl(options) {
-  const session = new ProtocolReplSession(options);
-  await session.start();
-}
-
 // src/version.ts
-import { execSync } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join9, dirname as dirname5 } from "path";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const __dirname2 = dirname5(fileURLToPath(import.meta.url));
-    const pkgPath = join9(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-function getGitHash() {
-  try {
-    return execSync("git rev-parse --short HEAD", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-var VERSION = getPackageVersion();
-var GIT_HASH = getGitHash();
+var VERSION = "0.1.12";
+var GIT_HASH = "712107d";
 var VERSION_STRING = `miriad-code v${VERSION} (${GIT_HASH})`;
 
 // src/cli/index.ts
@@ -47065,8 +46823,7 @@ function parseCliArgs() {
       dump: { type: "boolean", default: false },
       compact: { type: "boolean", default: false },
       stdio: { type: "boolean", default: false },
-      repl: { type: "boolean", default: false },
-      "repl-protocol": { type: "boolean", default: false }
+      repl: { type: "boolean", default: false }
     },
     allowPositionals: false
   });
@@ -47081,8 +46838,7 @@ function parseCliArgs() {
     dump: values.dump ?? false,
     compact: values.compact ?? false,
     stdio: values.stdio ?? false,
-    repl: values.repl ?? false,
-    replProtocol: values["repl-protocol"] ?? false
+    repl: values.repl ?? false
   };
 }
 function printHelp() {
@@ -47095,7 +46851,6 @@ Usage:
   miriad-code -p "prompt"           Run agent with a prompt
   miriad-code -p "prompt" --verbose Show debug output
   miriad-code --repl                Start interactive REPL mode
-  miriad-code --repl-protocol       Start REPL using protocol server (for testing)
   miriad-code --stdio               Start protocol server over stdin/stdout
   miriad-code --inspect             Show memory stats (no LLM call)
   miriad-code --dump                Show raw system prompt (no LLM call)
@@ -47106,7 +46861,6 @@ Options:
   -p, --prompt <text>   The prompt to send to the agent
   -v, --verbose         Show memory state, token usage, and execution trace
       --repl            Start interactive REPL with readline support
-      --repl-protocol   Start REPL that uses protocol server (test mid-turn messages)
       --stdio           Start Claude Code SDK protocol server on stdin/stdout
       --inspect         Show memory statistics: temporal, present, LTM
       --dump            Dump the full system prompt that would be sent to LLM
@@ -47171,19 +46925,6 @@ async function main() {
     }
     return;
   }
-  if (options.replProtocol) {
-    try {
-      await runProtocolRepl({ dbPath: options.db });
-    } catch (error2) {
-      if (error2 instanceof Error) {
-        console.error(`Error: ${error2.message}`);
-      } else {
-        console.error("Unknown error:", error2);
-      }
-      process.exit(1);
-    }
-    return;
-  }
   if (options.stdio) {
     try {
       await runServer({ dbPath: options.db });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miriad-systems/nuum",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "AI coding agent with continuous memory - infinite context across sessions",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "src/storage/migrations"
   ],
   "scripts": {
-    "build": "bun build ./src/cli/index.ts --outdir ./dist --target bun && node -e \"const fs=require('fs');const f='./dist/index.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env node','#!/usr/bin/env bun'))\"",
+    "build": "bun build ./src/cli/index.ts --outdir ./dist --target bun --define \"BUILD_VERSION='$(node -p \"require('./package.json').version\")'\" --define \"BUILD_GIT_HASH='$(git rev-parse --short HEAD 2>/dev/null || echo unknown)'\" && node -e \"const fs=require('fs');const f='./dist/index.js';fs.writeFileSync(f,fs.readFileSync(f,'utf8').replace('#!/usr/bin/env node','#!/usr/bin/env bun'))\"",
     "dev": "bun run ./src/cli/index.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun test",
@@ -31,7 +31,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/simen/miriad-code.git"
+    "url": "https://github.com/sanity-labs/nuum.git"
   },
   "engines": {
     "node": ">=18.0.0"