@sesamespace/hivemind 0.5.12 → 0.5.13

package/.pnpmrc.json

@@ -0,0 +1 @@
+{"onlyBuiltDependencies":["better-sqlite3"]}

package/DASHBOARD-PLAN.md

@@ -0,0 +1,206 @@
+# Hivemind Dashboard — Implementation Plan
+
+**Goal:** Local web dashboard for debugging memory, context routing, and LLM request formation.
+**Access:** `http://localhost:9485` on the Mac mini (local access only for now).
+**Priority:** LLM Request Inspector first, then Memory Browser, then Context Overview.
+
+---
+
+## Phase 1: LLM Request Logger + Inspector UI
+
+### Backend: Request Logging
+
+**Where:** Instrument `buildMessages()` in `prompt.ts` and `processMessage()` in `agent.ts`.
+
+Each logged request captures:
+```typescript
+interface RequestLog {
+  id: string;                    // uuid
+  timestamp: string;             // ISO-8601
+  // Routing
+  context: string;               // which context was used
+  contextSwitched: boolean;      // explicit switch?
+  routingReason: string;         // "pattern_match:X" | "inferred:X" | "active:X"
+  // Sender
+  channelId: string;
+  channelKind: "dm" | "group";
+  senderHandle: string;
+  rawMessage: string;            // as received (with prefix)
+  // Prompt components (broken out for UI)
+  systemPrompt: {
+    identity: string;            // workspace files section
+    l3Knowledge: string[];       // individual L3 entries
+    l2Episodes: Array<{
+      id: string;
+      content: string;
+      score: number;
+      timestamp: string;
+      context_name: string;
+      role: string;
+    }>;
+    contextInfo: string;         // active context section
+    fullText: string;            // complete system prompt as sent
+  };
+  conversationHistory: Array<{ role: string; content: string }>;  // L1 turns included
+  userMessage: string;           // final user message
+  // Response
+  response: {
+    content: string;
+    model: string;
+    latencyMs: number;
+    skipped: boolean;            // was it __SKIP__?
+  };
+  // Config snapshot
+  config: {
+    topK: number;
+    model: string;
+    maxTokens: number;
+    temperature: number;
+  };
+  // Approximate token counts (char-based estimate: chars/4)
+  tokenEstimates: {
+    systemPrompt: number;
+    conversationHistory: number;
+    userMessage: number;
+    total: number;
+  };
+}
+```
+
+**Storage:** SQLite database at `data/dashboard.db`. 
+- Single `request_logs` table with JSON columns for complex fields.
+- Auto-prune: keep last 7 days or 10,000 entries (whichever is smaller).
+- Why SQLite over ring buffer: survives restarts, queryable, minimal overhead.
+
+**Token estimation:** Use chars/4 approximation. Good enough for relative sizing. Avoid tokenizer dependency.
+
+**Logging approach:** Eager logging. Serialize at request time. The overhead is minimal (~1ms for JSON.stringify) compared to LLM latency (~1-10s). Capturing the exact state at request time is more valuable than lazy reconstruction.
+
+### Backend: Dashboard HTTP Server
+
+**Where:** New file `packages/runtime/src/dashboard.ts`.
+
+Extend the existing health server (or create a sibling on port 9485):
+- `GET /` — serve the SPA (single HTML file)
+- `GET /api/requests` — list recent requests (paginated, filterable)
+- `GET /api/requests/:id` — single request detail
+- `GET /api/contexts` — proxy to memory daemon's context list
+- `GET /api/contexts/:name/episodes` — proxy L2 episodes
+- `GET /api/contexts/:name/l3` — proxy L3 knowledge
+- `GET /api/stats` — memory stats (episode counts, last promotion, etc.)
+- `DELETE /api/l3/:id` — delete a bad L3 entry (write op from day 1)
+- `POST /api/l3/:id/edit` — edit L3 entry content
+
+Bind to `127.0.0.1:9485` only.
+
+### Frontend: Single-File SPA
+
+**Why single file:** No build step, no React, no dependencies. Ship as one HTML file with embedded CSS/JS. Can always upgrade later.
+
+**Layout:**
+- Left sidebar: navigation (Requests, Memory, Contexts)
+- Main area: content
+
+**Request Inspector view:**
+- Reverse-chronological list of requests
+- Each row: timestamp, sender, context, model, latency, token estimate
+- Click to expand → shows all sections:
+  - **Identity files** (collapsible, usually not interesting)
+  - **L3 Knowledge** (list of entries with metadata)
+  - **L2 Episodes** (with similarity scores, timestamps, source context)
+  - **L1 History** (conversation turns)
+  - **User Message** (raw with prefix)
+  - **Response** (with model, latency)
+  - **Config** (top_k, model, temperature)
+  - **Token breakdown** (bar chart showing proportion per section)
+- Filters: by context, by sender, by time range
+- Search: full-text search across messages
+
+**Memory Browser view (Phase 2):**
+- L2: searchable episode list, filterable by context/role/time
+- L3: per-context knowledge entries with edit/delete buttons
+- Promotion log (if we add logging for it)
+
+**Context Overview (Phase 2):**
+- List of contexts with episode counts, last active
+- Active context highlighted
+- Click to drill into episodes/L3
+
+---
+
+## Phase 2: Memory Browser + Context Overview
+
+After Phase 1 is working and useful, add:
+- Full L2 browsing with semantic search UI
+- L3 management (view, edit, delete)
+- Context explorer with stats
+- Promotion history logging
+
+---
+
+## Implementation Steps (Phase 1)
+
+### Step 1: Request logging infrastructure
+- [ ] Create `packages/runtime/src/request-logger.ts`
+  - SQLite setup (using better-sqlite3)
+  - `logRequest()` method
+  - `getRequests()` with pagination/filters
+  - `getRequest(id)` for detail view
+  - Auto-pruning on startup
+- [ ] Add better-sqlite3 dependency
+
+### Step 2: Instrument the pipeline
+- [ ] Modify `agent.ts` `processMessage()` to capture routing decision + timing
+- [ ] Modify `prompt.ts` `buildSystemPrompt()` to return structured components (not just string)
+- [ ] Log each request after LLM response arrives
+- [ ] Capture config snapshot with each log entry
+
+### Step 3: Dashboard HTTP server
+- [ ] Create `packages/runtime/src/dashboard.ts`
+  - Express-free: use Node's built-in `http` module (like health server)
+  - Serve SPA at `/`
+  - JSON APIs for request logs and memory proxy
+- [ ] Wire into `pipeline.ts` startup
+
+### Step 4: Frontend SPA
+- [ ] Single HTML file at `packages/runtime/src/dashboard.html`
+  - Vanilla JS, no framework
+  - CSS grid layout
+  - Fetch-based API calls
+  - Expandable request cards
+  - Token breakdown visualization
+  - Basic filtering
+
+### Step 5: Memory proxy + write ops
+- [ ] Proxy endpoints to memory daemon for L2/L3 browsing
+- [ ] DELETE/PATCH endpoints for L3 management
+
+---
+
+## Design Decisions
+
+| Question | Decision | Rationale |
+|----------|----------|-----------|
+| Storage | SQLite | Survives restarts, queryable, lightweight |
+| Token counting | chars/4 estimate | Good enough, no tokenizer dep |
+| Logging | Eager | Captures exact state, overhead negligible vs LLM latency |
+| Bind address | 127.0.0.1 only | Local access, no auth needed |
+| Framework | None (vanilla) | Single HTML file, no build step |
+| Read-only or read-write? | Read-write from start | Ryan will want to delete bad L3 entries immediately |
+| Persist request logs? | Yes, 7 days | Need to compare across memory config changes |
+| Multi-agent? | Single agent for now | Don't over-engineer, but use agent name in logs |
+| Port | 9485 | Next to health port (9484), easy to remember |
+
+---
+
+## Sesame Command Fix (Bonus)
+
+While we're in the code, fix the sender prefix issue:
+- In `pipeline.ts` `startSesameLoop()`, before calling `agent.processMessage()`, strip the sender prefix for command parsing
+- Or better: in `agent.ts` `handleSpecialCommand()`, strip known prefix patterns before regex matching
+- This unblocks context switching, task commands, and cross-context search over Sesame
+
+---
+
+*Created: 2026-02-28*
+*Status: Ready to implement*

package/dist/chunk-7D4SUZUM.js

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-7D4SUZUM.js.map

package/dist/chunk-7D4SUZUM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-UJDDOQEE.js → chunk-IO5UVDAO.js}

@@ -6,7 +6,7 @@ import {
   PRIMARY_ROUTES,
   SesameClient,
   WORKER_ROUTES
-} from "./chunk-LB6MG36X.js";
+} from "./chunk-MKE2NVOC.js";
 
 // packages/runtime/src/watchdog.ts
 import { execSync } from "child_process";
@@ -1048,4 +1048,4 @@ export {
   WorkerMemorySync,
   PrimaryMemorySync
 };
-//# sourceMappingURL=chunk-UJDDOQEE.js.map
+//# sourceMappingURL=chunk-IO5UVDAO.js.map

package/dist/{chunk-7HIU4UF2.js → chunk-IUFYZ4AJ.js}

@@ -1,6 +1,6 @@
 import {
   startPipeline
-} from "./chunk-LB6MG36X.js";
+} from "./chunk-MKE2NVOC.js";
 
 // packages/cli/src/commands/start.ts
 import { resolve } from "path";
@@ -66,4 +66,4 @@ Options:
 export {
   runStartCommand
 };
-//# sourceMappingURL=chunk-7HIU4UF2.js.map
+//# sourceMappingURL=chunk-IUFYZ4AJ.js.map