openhermes 1.5.1 → 1.5.6

package/README.md

@@ -12,7 +12,7 @@
 
 ---
 
-**Your OpenCode agent, leveled up.** Add it to your plugins — your agent gains a personality, a memory, a conscience, 7 specialist subagents, 7 slash commands, 5 native memory tools, 10 procedural skills, and the discipline to self-improve.
+**Your OpenCode agent, leveled up.** Add it to your plugins and your agent gains a personality, a memory, a conscience, 7 specialist subagents, 7 slash commands, 5 native memory tools, 10 procedural skills, autonomous checkpointing, and the discipline to self-improve.
 
 ```bash
 npm i openhermes
@@ -29,21 +29,25 @@ npm i openhermes
 ## What OpenHermes Does For Your Agent
 
 <table>
-<tr><td width="160"><b>&#129302; Personality Layer</b></td><td>A 11-principle constitution (soul.md) injected into every session — pragmatic, concise, subagent-first, verify-don't-claim. Your agent stops rambling and starts delivering.</td></tr>
+<tr><td width="160"><b>&#129302; Personality Layer</b></td><td>An 11-principle constitution (<code>soul.md</code>) injected into every session — pragmatic, concise, subagent-first, verify-don't-claim. Your agent stops rambling and starts delivering.</td></tr>
 <tr><td><b>&#128204; Delegation Discipline</b></td><td>Mandated routing table — every non-trivial task goes to the right specialist subagent. Main context stays clean, coordination-only. No more bloated chat logs.</td></tr>
-<tr><td><b>&#128190; 9-Class Durable Memory</b></td><td>Checkpoints, decisions, constraints, instincts, mistakes, backlog items, audit reports, verification receipts, and session recall — all schema-validated, fingerprint-verified, persisted to disk.</td></tr>
+<tr><td><b>&#128190; 9-Class Durable Memory</b></td><td>Checkpoints, decisions, constraints, instincts, mistakes, backlog items, audit reports, verification receipts, and session recall — all schema-validated, fingerprint-aware, persisted to disk.</td></tr>
 <tr><td><b>&#129520; Precision-First Retrieval</b></td><td>Gated retrieval with anti-spam controls. <code>hm_latest</code> → <code>hm_search</code> → <code>hm_get</code> → <code>hm_list</code>. No full-index reads unless explicitly scoped. Memory stays lean.</td></tr>
-<tr><td><b>&#128293; Autonomous Checkpointing</b></td><td>Pre-compaction snapshots capture mission, current state, next actions, active decisions, blockers, and risk notes — so compaction never loses the plot.</td></tr>
+<tr><td><b>&#128293; Autonomous Checkpointing</b></td><td>Pre-compaction snapshots capture mission, current state, next actions, blockers, and risk notes so compaction never loses the plot.</td></tr>
 <tr><td><b>&#128260; Closed Learning Loop</b></td><td>Mistakes are logged with root cause + prevention rule. Complex sessions auto-generate skill-candidate backlogs. Strike tracking escalates repeat failures. The agent gets better — you don't have to teach it twice.</td></tr>
-<tr><td><b>&#128736; 10 Bundled Procedural Skills</b></td><td>Pre-built skills for API design, backend patterns, coding standards, E2E testing, frontend patterns, security reviews, strategic compaction, TDD workflow, verification loops, and presentation building. Discovered automatically — use <code>skill</code> tool to list and load.</td></tr>
-<tr><td><b>&#129513; Zero Infrastructure</b></td><td>No Python. No uv. No Docker. No PostgreSQL. No gateway. No cron daemon. Just Node.js — which OpenCode's Bun runtime already bundles. Everything runs inside your existing OpenCode session.</td></tr>
+<tr><td><b>&#128736; 10 Bundled Procedural Skills</b></td><td>Pre-built skills for API design, backend patterns, coding standards, E2E testing, frontend patterns, frontend slides, security reviews, strategic compaction, TDD workflow, and verification loops. Discovered automatically — use <code>skill</code> to list and load.</td></tr>
+<tr><td><b>&#129513; Zero Infrastructure</b></td><td>No Python. No uv. No Docker. No PostgreSQL. No gateway. No cron daemon. Just Node.js and your existing OpenCode runtime.</td></tr>
 </table>
 
 ---
 
 ## Setup
 
-Add one line to your `opencode.json`:
+Add one line to your `opencode.json`. Two good options:
+
+### Published Release
+
+Use npm when you want a stable release boundary.
 
 ```json
 {
@@ -51,7 +55,17 @@ Add one line to your `opencode.json`:
 }
 ```
 
-That's it. **No other config needed.** The plugin auto-registers:
+### Git-Backed
+
+Use GitHub when you want the latest pushed changes immediately.
+
+```json
+{
+  "plugin": ["openhermes@git+https://github.com/nathwn12/openhermes.git"]
+}
+```
+
+Either way, **no other config needed.** The plugin auto-registers:
 
 | What | Details |
 |------|---------|
@@ -67,17 +81,17 @@ You only need to define primary agents (like `build` or `OpenHermes`) in `openco
 <summary><b>What happens on your next session</b></summary>
 
 1. **Config hook** — BootstrapPlugin registers auto-config: 7 subagents, 7 commands, 10 skill dirs.
-2. **Chat transform hook** — ~12KB of context injected into the first user message:
-   - &#9733; **Constitution** (soul.md) — 11 immutable principles
-   - &#9733; **Runtime** (RUNTIME.md) — gather → delegate → verify → compress
-   - &#9733; **Router** (AGENTS.md) — delegation table, memory policy, escalation, with absolute paths to every rule
-3. **Session created** — AutorecallPlugin builds recall cache from prior session memory
-4. **Tools execute** — SkillBuilderPlugin watches tool calls and subagent spawns; MemoryToolsPlugin provides 5 native tools immediately
-5. **Session idle** — CuratorPlugin snapshots checkpoint + verification receipt
-6. **Session error** — CuratorPlugin logs mistake with root cause + prevention rule
-7. **Compaction** — CuratorPlugin force-writes pre-compaction checkpoint, injects state into buffer
-
-The LLM reads rules on demand via the injected paths. Memory directories auto-create. Everything Just Works™.
+2. **Chat transform hook** — bootstrap content is injected into the first user message:
+   - &#9733; **Constitution** (`soul.md`) — 11 immutable principles
+   - &#9733; **Runtime** (`RUNTIME.md`) — gather → delegate → verify → compress
+   - &#9733; **Router** (`AGENTS.md`) — delegation table, memory policy, escalation, and rule paths
+3. **Session created** — AutorecallPlugin builds recall cache from prior session memory.
+4. **Tools execute** — SkillBuilderPlugin watches tool calls and subagent spawns; MemoryToolsPlugin provides 5 native tools immediately.
+5. **Session idle** — CuratorPlugin snapshots checkpoint + verification receipt.
+6. **Session error** — CuratorPlugin logs mistake with root cause + prevention rule.
+7. **Compaction** — CuratorPlugin force-writes a pre-compaction checkpoint and injects state into the compaction buffer.
+
+The LLM reads rules on demand via the injected paths. Memory directories auto-create. Everything Just Works.
 
 </details>
 
@@ -91,13 +105,13 @@ The LLM reads rules on demand via the injected paths. Memory directories auto-cr
 | **MemoryToolsPlugin** | — | Registers 5 native tools: `hm_put`, `hm_get`, `hm_list`, `hm_latest`, `hm_search`. Runs in-process — no MCP server needed. |
 | **CuratorPlugin** | `session.idle`, `.compacted`, `.error`, `.compacting`, `permission.replied` | Writes checkpoints, logs mistakes, records audits, injects state into compaction. |
 | **AutorecallPlugin** | `session.created` | Loads memory from disk, builds session recall cache. |
-| **SkillBuilderPlugin** | `session.idle`, `.created`, `tool.execute.after` | Detects complex sessions (8+ tool calls or 2+ subagent spawns) → creates skill-candidate backlogs. |
+| **SkillBuilderPlugin** | `session.idle`, `.created`, `tool.execute.after` | Detects complex sessions (8+ tool calls or 2+ subagent spawns) and creates skill-candidate backlogs. |
 
 ---
 
 ## Memory Architecture
 
-Nine memory classes, all schema-validated before persistence, stored at `~/.local/share/opencode/openhermes/memory/`:
+Nine memory classes, all schema-validated before persistence, stored under the standard OpenCode storage roots:
 
 | Class | Format | Purpose |
 |-------|--------|---------|
@@ -107,11 +121,11 @@ Nine memory classes, all schema-validated before persistence, stored at `~/.loca
 | `instinct` | JSON | Reusable trigger→action patterns with success/failure tracking |
 | `backlog` | JSON | Evidence-backed self-improvement items with acceptance criteria |
 | `mistake` | JSONL | Failure registry: type, root cause, fix, prevention rule, strike count |
-| `audit` | JSON | Structured quality/integrity evaluations with health scores |
+| `audit` | JSON | Structured quality and integrity evaluations with health scores |
 | `verification_receipt` | JSON | Cached verification results keyed by artifact fingerprint |
 | `recall` | JSON | Session-start cache aggregating active state for compaction injection |
 
-OpenHermes follows the same storage contract as OpenCode itself — see [OpenCode docs on storage](https://opencode.ai/docs/troubleshooting/#storage):
+OpenHermes follows the same storage contract as OpenCode itself:
 
 | What | Where |
 |---|---|
@@ -119,7 +133,7 @@ OpenHermes follows the same storage contract as OpenCode itself — see [OpenCod
 | Durable memory + runtime state | `~/.local/share/opencode/openhermes/` |
 | Derived recall cache | `~/.cache/opencode/openhermes/recall/` |
 
-**Runtime hardening**: All records pass through `sanitizeRecord()` (strips `__proto__`, `constructor`, `prototype`), `redactSensitiveText()` (strips bearer tokens, API keys, passwords), and `truncateText()` before persistence. Schema validation gate runs before every write.
+**Runtime hardening**: records pass through `sanitizeRecord()` (strips `__proto__`, `constructor`, `prototype`), `redactSensitiveText()` (strips bearer tokens, API keys, passwords), and `truncateText()` before persistence. Schema validation runs before every write.
 
 ---
 
@@ -159,50 +173,36 @@ permission.replied
 
 ---
 
+## Verification Discipline
+
+OpenHermes pushes the agent toward one core habit: **verify before claiming success**.
+
+- read before editing
+- run commands before announcing success
+- cache verification receipts by artifact fingerprint
+- re-verify when files change
+- flag contradictions instead of smoothing over them
+
+That is why verification receipts are a first-class memory type rather than an afterthought.
+
+---
+
 ## Bundled Harness
 
-The full OpenHermes framework ships inside the package — 60 files across 6 directories:
+The full OpenHermes framework ships inside the package — prompts, rules, commands, constitution, and procedural skills included:
 
 ```
 harness/
 ├── constitution/soul.md        # 11 immutable personality principles
-├── instructions/RUNTIME.md      # Session workflow: gather → delegate → verify
-├── rules/ (16 files)
-│   ├── delegation.md            # Mandatory subagent routing
-│   ├── retrieval.md             # Gated precision-first memory retrieval
-│   ├── session-start.md         # Session-start checklist and memory hydration
-│   ├── credential-exposure.md   # Secret redaction and credential exposure guard
-│   ├── self-heal.md             # T0→T3 escalation tiers
-│   ├── verification.md          # Skeptical evidence protocol
-│   ├── memory-management.md     # Dual-target memory + anti-spam
-│   ├── precedence.md            # 9-level conflict resolution
-│   ├── checkpointing.md         # Compaction snapshot discipline
-│   ├── audit.md                 # Structured health checks
-│   ├── skills-management.md     # Progressive disclosure loading
-│   ├── context-loading.md       # Priority chain + size limits
-│   ├── promotion.md             # High-signal-only promotion
-│   ├── ranking.md               # Metadata-first retrieval
-│   ├── runtime-guards.md        # Stale assumption prevention
-│   └── state-drift.md           # Hash-based fingerprinting
-├── skills/ (10 directories)
-│   ├── api-design/SKILL.md          # REST API patterns (523 lines)
-│   ├── backend-patterns/SKILL.md    # Backend architecture (598 lines)
-│   ├── coding-standards/SKILL.md    # Baseline conventions (549 lines)
-│   ├── e2e-testing/SKILL.md         # Playwright E2E patterns (326 lines)
-│   ├── frontend-patterns/SKILL.md   # React/Next.js patterns (642 lines)
-│   ├── frontend-slides/SKILL.md     # HTML presentation builder (184 lines)
-│   ├── security-review/SKILL.md     # OWASP Top 10 checklist (495 lines)
-│   ├── strategic-compact/SKILL.md   # Context compaction strategy (131 lines)
-│   ├── tdd-workflow/SKILL.md        # Red-green-refactor discipline (463 lines)
-│   └── verification-loop/SKILL.md   # Pre-PR quality gates (126 lines)
-├── prompts/ (7 files)
-│   # Subagent prompt templates: architect, build-error-resolver,
-│   # code-reviewer, e2e-runner, explore, planner, security-reviewer
-└── commands/ (7 files)
-    # Slash command templates: build-fix, code-review, doctor,
-    # learn, memory-search, plan, security
+├── instructions/RUNTIME.md     # Session workflow: gather → delegate → verify
+├── rules/                      # retrieval, verification, checkpointing, audit, self-heal, etc.
+├── skills/                     # 10 bundled procedural skills
+├── prompts/                    # subagent prompt templates
+└── commands/                   # slash command templates
 ```
 
+This matters because OpenHermes is not just a runtime shim. The operational doctrine ships with it.
+
 ---
 
 ## Self-Healing Escalation
@@ -233,17 +233,17 @@ No self-termination. No grandstanding. Narrow, log, recover, improve.
 
 ```
 openhermes/
-├── index.mjs                 # Re-exports all 5 plugins
-├── bootstrap.mjs             # Config hook (agents/commands/skills) + chat.transform
-├── autorecall.mjs            # Recall cache builder
-├── curator.mjs               # Lifecycle hooks engine (~470 lines)
-├── skill-builder.mjs         # Complexity detection engine
+├── index.mjs                    # Re-exports all 5 plugins
+├── bootstrap.mjs                # Config hook (agents/commands/skills) + chat.transform
+├── autorecall.mjs               # Recall cache builder
+├── curator.mjs                  # Lifecycle hooks engine
+├── skill-builder.mjs            # Complexity detection engine
 ├── lib/
 │   ├── memory-tools-plugin.mjs  # 5 native memory tools (hm_put/get/list/latest/search)
 │   ├── hardening.mjs            # atomicWriteJson, fingerprint, sanitize, redact
 │   └── schema-validator.mjs     # Draft-07 subset validator
-├── schemas/                  # 9 JSON schemas for memory validation
-├── harness/                  # Full framework (44 files)
+├── schemas/                     # Memory schemas for validation
+├── harness/                     # Full framework bundle
 └── package.json
 ```
 
@@ -251,13 +251,6 @@ openhermes/
 
 ---
 
-## Dependencies
-
-- **Node.js >= 18** — `node:path`, `node:fs`, `node:os`, `node:url`, `node:crypto`
-- **OpenCode** — provides the Bun runtime, plugin loader, hook dispatcher, and `skill` tool
-
----
-
 ## Why OpenHermes ≠ Hermes Agent
 
 | | Hermes Agent | OpenHermes |

package/autorecall.mjs

@@ -80,16 +80,16 @@ async function loadMemoryAndWriteCache(projectKey, directory) {
   const SENTINEL = path.join(getDataRoot(), ".migrated-from-v1")
   if (!fs.existsSync(SENTINEL)) {
     const oldMemory = path.join(OLD_BASE, "memory")
+    const oldCache = path.join(oldMemory, "recall")
     if (fs.existsSync(oldMemory)) {
       fs.cpSync(oldMemory, getMemoryRoot(), { recursive: true })
+      if (fs.existsSync(oldCache)) {
+        fs.mkdirSync(getRecallRoot(), { recursive: true })
+        const files = fs.readdirSync(oldCache).filter(f => f.endsWith(".json"))
+        for (const f of files) fs.cpSync(path.join(oldCache, f), path.join(getRecallRoot(), f))
+      }
       fs.rmSync(oldMemory, { recursive: true, force: true })
     }
-    const oldCache = path.join(OLD_BASE, "memory", "recall")
-    if (fs.existsSync(oldCache)) {
-      fs.mkdirSync(getRecallRoot(), { recursive: true })
-      const files = fs.readdirSync(oldCache).filter(f => f.endsWith(".json"))
-      for (const f of files) fs.cpSync(path.join(oldCache, f), path.join(getRecallRoot(), f))
-    }
     const oldRuntime = path.join(OLD_BASE, "runtime")
     if (fs.existsSync(oldRuntime)) {
       fs.cpSync(oldRuntime, getRuntimeRoot(), { recursive: true })
@@ -99,6 +99,7 @@ async function loadMemoryAndWriteCache(projectKey, directory) {
     if (fs.existsSync(oldArchive)) {
       fs.rmSync(oldArchive, { recursive: true, force: true })
     }
+    fs.mkdirSync(path.dirname(SENTINEL), { recursive: true })
     fs.writeFileSync(SENTINEL, new Date().toISOString(), "utf8")
   }
 

package/curator.mjs

@@ -393,33 +393,44 @@ async function handlePermissionReplied(directory, project, event) {
   }
 }
 
-export const CuratorPlugin = async ({ project, directory }) => {
-  return {
-    event: async ({ event }) => {
-      const OLD_BASE = path.join(os.homedir(), ".config", "opencode", "openhermes")
-      const SENTINEL = path.join(getDataRoot(), ".migrated-from-v1")
-      if (!fs.existsSync(SENTINEL)) {
-        const oldMemory = path.join(OLD_BASE, "memory")
-        if (fs.existsSync(oldMemory)) {
-          fs.cpSync(oldMemory, getMemoryRoot(), { recursive: true })
-          fs.rmSync(oldMemory, { recursive: true, force: true })
-        }
-        const oldRuntime = path.join(OLD_BASE, "runtime")
-        if (fs.existsSync(oldRuntime)) {
-          fs.cpSync(oldRuntime, getRuntimeRoot(), { recursive: true })
+export const CuratorPlugin = async ({ project, directory }) => {
+  return {
+    event: async ({ event }) => {
+      const OLD_BASE = path.join(os.homedir(), ".config", "opencode", "openhermes")
+      const SENTINEL = path.join(getDataRoot(), ".migrated-from-v1")
+      if (!fs.existsSync(SENTINEL)) {
+        const oldMemory = path.join(OLD_BASE, "memory")
+        const oldCache = path.join(oldMemory, "recall")
+        if (fs.existsSync(oldMemory)) {
+          fs.cpSync(oldMemory, getMemoryRoot(), { recursive: true })
+          if (fs.existsSync(oldCache)) {
+            fs.mkdirSync(getRecallRoot(), { recursive: true })
+            const files = fs.readdirSync(oldCache).filter(f => f.endsWith(".json"))
+            for (const f of files) fs.cpSync(path.join(oldCache, f), path.join(getRecallRoot(), f))
+          }
+          fs.rmSync(oldMemory, { recursive: true, force: true })
+        }
+        const oldRuntime = path.join(OLD_BASE, "runtime")
+        if (fs.existsSync(oldRuntime)) {
+          fs.cpSync(oldRuntime, getRuntimeRoot(), { recursive: true })
           fs.rmSync(oldRuntime, { recursive: true, force: true })
         }
         const oldArchive = path.join(OLD_BASE, "archive")
-        if (fs.existsSync(oldArchive)) {
-          fs.rmSync(oldArchive, { recursive: true, force: true })
-        }
-        fs.writeFileSync(SENTINEL, new Date().toISOString(), "utf8")
-      }
-      if (event.type === "session.idle") {
-        await handleSessionIdle(directory, project)
-      } else if (event.type === "session.compacted") {
-        await handleSessionCompacted(directory, project)
-      } else if (event.type === "session.error") {
+        if (fs.existsSync(oldArchive)) {
+          fs.rmSync(oldArchive, { recursive: true, force: true })
+        }
+        fs.mkdirSync(path.dirname(SENTINEL), { recursive: true })
+        fs.writeFileSync(SENTINEL, new Date().toISOString(), "utf8")
+      }
+      if (event.type === "session.created") {
+        lastCheckpoint.ts = 0
+        writtenThisSession.length = 0
+      }
+      if (event.type === "session.idle") {
+        await handleSessionIdle(directory, project)
+      } else if (event.type === "session.compacted") {
+        await handleSessionCompacted(directory, project)
+      } else if (event.type === "session.error") {
         await handleSessionError(directory, project, event)
       } else if (event.type === "permission.replied") {
         await handlePermissionReplied(directory, project, event)

package/lib/memory-tools-plugin.mjs

@@ -132,6 +132,18 @@ function enforceAuditEvidence(record) {
   return ["db_refs", "file_refs", "log_refs"].some(k => Array.isArray(prov[k]) && prov[k].some(i => typeof i === "string" && i.trim()))
 }
 
+function setToolTitle(context, title, metadata = {}) {
+  if (!context || typeof context.metadata !== "function") return
+  context.metadata({ title, metadata })
+}
+
+function classifyPutTitle(cls, id) {
+  const label = String(id || "").trim() || "unnamed"
+  if (cls === "checkpoint") return `Save checkpoint: ${label}`
+  if (cls === "verification_receipt") return `Save verification receipt: ${label}`
+  return `Save ${cls}: ${label}`
+}
+
 function handlePut(cls, id, dataStr) {
   let parsed
   try { parsed = JSON.parse(dataStr) } catch (e) { return `data must be valid JSON: ${e.message}` }
@@ -220,7 +232,10 @@ export const MemoryToolsPlugin = async () => {
           id: tool.schema.string(),
           data: tool.schema.string(),
         },
-        async execute(args) { return handlePut(args.class, args.id, args.data) },
+        async execute(args, context) {
+          setToolTitle(context, classifyPutTitle(args.class, args.id), { action: "put", class: args.class, id: args.id })
+          return handlePut(args.class, args.id, args.data)
+        },
       }),
 
       hm_get: tool({
@@ -229,7 +244,10 @@ export const MemoryToolsPlugin = async () => {
           class: tool.schema.enum(CLASSES).describe("Memory class"),
           id: tool.schema.string().describe("Record ID"),
         },
-        async execute(args) { return handleGet(args.class, args.id) },
+        async execute(args, context) {
+          setToolTitle(context, `Open ${args.class}: ${args.id}`, { action: "get", class: args.class, id: args.id })
+          return handleGet(args.class, args.id)
+        },
       }),
 
       hm_list: tool({
@@ -238,7 +256,10 @@ export const MemoryToolsPlugin = async () => {
           class: tool.schema.enum(CLASSES).describe("Memory class"),
           limit: tool.schema.number().optional().default(10).describe("Max results (max 100)"),
         },
-        async execute(args) { return handleList(args.class, args.limit) },
+        async execute(args, context) {
+          setToolTitle(context, `List ${args.class} records`, { action: "list", class: args.class, limit: args.limit })
+          return handleList(args.class, args.limit)
+        },
       }),
 
       hm_latest: tool({
@@ -246,7 +267,10 @@ export const MemoryToolsPlugin = async () => {
         args: {
           class: tool.schema.enum(CLASSES).describe("Memory class"),
         },
-        async execute(args) { return handleLatest(args.class) },
+        async execute(args, context) {
+          setToolTitle(context, `Latest ${args.class}`, { action: "latest", class: args.class })
+          return handleLatest(args.class)
+        },
       }),
 
       hm_search: tool({
@@ -258,8 +282,18 @@ export const MemoryToolsPlugin = async () => {
           project: tool.schema.string().optional().describe("Project filter"),
           limit: tool.schema.number().optional().default(10).describe("Max results (max 50)"),
         },
-        async execute(args) { return handleSearch(args.query, args.scope, args.classes, args.project, args.limit) },
+        async execute(args, context) {
+          setToolTitle(context, `Search memory: ${truncateText(args.query, 48)}`, {
+            action: "search",
+            scope: args.scope,
+            classes: args.classes?.length ? args.classes : CLASSES,
+            project: args.project ?? null,
+            limit: args.limit,
+          })
+          return handleSearch(args.query, args.scope, args.classes, args.project, args.limit)
+        },
       }),
+
     },
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openhermes",
-  "version": "1.5.1",
+  "version": "1.5.6",
   "description": "OpenHermes plugin suite for OpenCode — autonomous checkpointing, native memory tools, subagent routing, slash commands, and skill-candidate detection.",
   "type": "module",
   "license": "MIT",

package/lib/tools/_memory.mjs

@@ -1,230 +0,0 @@
-import fs from "fs"
-import path from "path"
-import os from "os"
-import { getMemoryRoot, getDataRoot } from "../../lib/paths.mjs"
-
-const MEMORY_DIR = getMemoryRoot()
-
-const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
-const PLURALS = {
-  audit: "audits", checkpoint: "checkpoints", mistake: "mistakes",
-  instinct: "instincts", decision: "decisions", constraint: "constraints",
-  backlog: "backlog", verification_receipt: "verification_receipts",
-}
-
-function isPlainObject(v) { return !!v && typeof v === "object" && !Array.isArray(v) }
-
-function stableStringify(v, space = 0) {
-  function sort(o) {
-    if (Array.isArray(o)) return o.map(sort)
-    if (!isPlainObject(o)) return o
-    const r = {}
-    for (const k of Object.keys(o).sort()) r[k] = sort(o[k])
-    return r
-  }
-  return JSON.stringify(sort(v), null, space)
-}
-
-function classDir(cls) { return path.join(MEMORY_DIR, PLURALS[cls]) }
-
-function atomicWriteJson(fp, data) {
-  const tmp = fp + ".tmp"
-  fs.writeFileSync(tmp, stableStringify(data, 2), "utf8")
-  fs.renameSync(tmp, fp)
-}
-
-function readJSON(fp, fallback) {
-  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
-}
-
-function readJSONL(fp) {
-  try {
-    return fs.readFileSync(fp, "utf8").split(/\r?\n/).map(l => l.trim()).filter(Boolean).map(l => JSON.parse(l))
-  } catch { return [] }
-}
-
-function buildEntry(cls, r) {
-  const e = {
-    id: r.id, summary: r.summary, status: r.status,
-    updated_at: r.updated_at ?? r.created_at,
-    path: path.join("openhermes", "memory", PLURALS[cls], `${r.id}.json`),
-    scope: r.scope ?? null, project: r.project ?? null,
-  }
-  if (cls === "audit") { e.target = r.target; e.overall_score = r.overall_score }
-  if (cls === "backlog") { e.priority = r.priority; e.trigger = r.trigger }
-  return e
-}
-
-function hasExpired(r) {
-  if (r?.status === "expired" || r?.status === "decayed") return true
-  if (r?.decay_at && Date.parse(r.decay_at) < Date.now()) return true
-  if (r?.expires_at && Date.parse(r.expires_at) < Date.now()) return true
-  return false
-}
-
-function sortRecent(entries) {
-  function ts(e) { return e?.updated_at ?? e?.created_at ?? "" }
-  return [...entries].sort((a, b) => {
-    const at = Date.parse(ts(a)), bt = Date.parse(ts(b))
-    if (!Number.isNaN(at) && !Number.isNaN(bt) && at !== bt) return bt - at
-    return String(ts(b)).localeCompare(String(ts(a)))
-  })
-}
-
-function filterActive(entries) { return entries.filter(e => !hasExpired(e)) }
-
-function validateSchemaSimple(record) {
-  const required = {
-    audit: ["id", "class", "summary", "target", "overall_score", "checks"],
-    checkpoint: ["id", "class", "summary", "mission", "current_state", "provenance"],
-    mistake: ["id", "class", "summary", "failure", "root_cause", "type", "strike"],
-    instinct: ["id", "class", "summary", "claim", "provenance"],
-    decision: ["id", "class", "summary", "decision", "rationale", "provenance"],
-    constraint: ["id", "class", "summary", "constraint", "provenance"],
-    backlog: ["id", "class", "summary", "priority"],
-    verification_receipt: ["id", "class", "summary", "fingerprint", "method", "result"],
-  }
-  const cls = record.class
-  const reqs = required[cls]
-  if (!reqs) return { ok: true }
-  const missing = reqs.filter(r => !record[r] && record[r] !== null && record[r] !== undefined)
-  if (missing.length) return { ok: false, errors: missing.map(m => `$.${m} is required`) }
-  return { ok: true }
-}
-
-function queryList(cls, limit = 10) {
-  if (cls === "mistake") {
-    return sortRecent(filterActive(readJSONL(path.join(classDir(cls), "mistakes.jsonl")))).slice(0, limit)
-  }
-  const dir = classDir(cls)
-  let files = []
-  try { files = fs.readdirSync(dir).filter(f => f.endsWith(".json") && f !== "index.json").map(f => path.join(dir, f)) } catch { return [] }
-  const entries = files.map(f => readJSON(f, null)).filter(Boolean).map(r => buildEntry(cls, r))
-  return sortRecent(filterActive(entries)).slice(0, limit)
-}
-
-function queryGet(cls, id) {
-  if (cls === "mistake") return readJSONL(path.join(classDir(cls), "mistakes.jsonl")).find(e => e?.id === id) ?? null
-  return readJSON(path.join(classDir(cls), `${id}.json`), null)
-}
-
-function scoreRelevance(r, query, project) {
-  const q = query.toLowerCase()
-  let score = 0
-  const fields = [r.summary, r.id, r.description, r.mission, r.current_state, r.failure, r.root_cause, r.fix, r.prevention, r.command, r.project, r.scope, ...(Array.isArray(r.tags) ? r.tags : []), ...(Array.isArray(r.next_actions) ? r.next_actions : []), ...(Array.isArray(r.refs) ? r.refs : [])].filter(Boolean)
-  for (const f of fields) {
-    const str = String(f).toLowerCase()
-    let idx = 0; let count = 0
-    while ((idx = str.indexOf(q, idx)) !== -1) { count++; idx += q.length }
-    score += count * 10
-    if (str.startsWith(q)) score += 5
-    if (str.includes(q)) score += 2
-  }
-  if (r.project && r.project.toLowerCase() === (project || "").toLowerCase()) score += 20
-  if (r.project && project && r.project.toLowerCase().includes(project.toLowerCase())) score += 10
-  const age = Date.now() - Date.parse(r.updated_at || r.created_at || 0)
-  if (!Number.isNaN(age)) score += Math.max(0, 10 - age / 604800000)
-  if (r.status === "active") score += 3
-  if (r.status === "closed") score -= 2
-  return score
-}
-
-function writeObject(cls, record) {
-  const dir = classDir(cls)
-  fs.mkdirSync(dir, { recursive: true })
-  const fp = path.join(dir, `${record.id}.json`)
-  atomicWriteJson(fp, record)
-  const indexPath = path.join(dir, "index.json")
-  let index = readJSON(indexPath, [])
-  if (!Array.isArray(index)) index = []
-  const idx = index.findIndex(e => e?.id === record.id)
-  const entry = buildEntry(cls, record)
-  if (idx >= 0) index[idx] = entry; else index.push(entry)
-  atomicWriteJson(indexPath, index)
-}
-
-function upsertMistake(record) {
-  const dir = classDir("mistake")
-  fs.mkdirSync(dir, { recursive: true })
-  const fp = path.join(dir, "mistakes.jsonl")
-  let entries = readJSONL(fp)
-  const idx = entries.findIndex(e => e?.id === record.id)
-  if (idx >= 0) entries[idx] = record; else entries.push(record)
-  const text = entries.map(e => stableStringify(e)).join("\n")
-  fs.writeFileSync(fp, text ? `${text}\n` : "", "utf8")
-}
-
-export function handlePut(cls, id, dataStr) {
-  let parsed
-  try { parsed = JSON.parse(dataStr) } catch (e) { return `data must be valid JSON: ${e.message}` }
-  if (!isPlainObject(parsed)) return "data must be a JSON object"
-  if (!id?.trim()) return "non-blank id is required"
-
-  const now = new Date().toISOString()
-  const record = {
-    ...parsed, id, class: cls,
-    source: parsed.source ?? "agent",
-    status: parsed.status ?? "active",
-    created_at: parsed.created_at ?? now,
-    updated_at: now,
-  }
-
-  const validation = validateSchemaSimple(record)
-  if (!validation.ok) return `Validation errors: ${validation.errors.join("; ")}`
-
-  if (cls === "mistake") upsertMistake(record)
-  else writeObject(cls, record)
-
-  return stableStringify({ ok: true, id })
-}
-
-export function handleGet(cls, id) {
-  if (!id?.trim()) return "non-blank id is required"
-  const record = queryGet(cls, id.trim())
-  if (!record) return stableStringify({ ok: false, found: false })
-  return stableStringify({ ok: true, record })
-}
-
-export function handleList(cls, limit = 10) {
-  const entries = queryList(cls, Math.min(limit, 100))
-  return stableStringify({ ok: true, count: entries.length, entries })
-}
-
-export function handleLatest(cls) {
-  const list = queryList(cls, 100)
-  const active = filterActive(list)
-  if (!active[0]?.id) return stableStringify({ ok: false, found: false })
-  const record = queryGet(cls, active[0].id)
-  if (!record) return stableStringify({ ok: false, found: false })
-  return stableStringify({ ok: true, record })
-}
-
-export function handleSearch(query, scope, classes, project, limit) {
-  const q = (query || "").trim()
-  if (!q) return "non-blank query is required"
-  const clsList = Array.isArray(classes) && classes.length ? classes : CLASSES
-  const lim = Math.min(limit ?? 10, 50)
-  let records = []
-  for (const cls of clsList) {
-    if (cls === "mistake") {
-      for (const m of readJSONL(path.join(classDir(cls), "mistakes.jsonl"))) {
-        if (!hasExpired(m)) records.push(m)
-      }
-    } else {
-      const dir = classDir(cls)
-      let files = []
-      try { files = fs.readdirSync(dir).filter(f => f.endsWith(".json") && f !== "index.json") } catch { continue }
-      for (const f of files) {
-        const r = readJSON(path.join(dir, f), null)
-        if (r && !hasExpired(r)) records.push(r)
-      }
-    }
-  }
-  if (scope === "global") records = records.filter(r => r.scope === "global" || !r.scope)
-  else if (scope === "local") records = records.filter(r => r.scope === "project" || r.scope === "session")
-  const scored = records.map(r => ({ ...buildEntry(r.class || "verification_receipt", r), score: scoreRelevance(r, q, project || "") }))
-    .filter(e => e.score > 0)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, lim)
-  return stableStringify({ ok: true, count: scored.length, query: q, results: scored })
-}

package/lib/tools/hm_get.mjs

@@ -1,13 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { handleGet } from "./_memory.mjs"
-
-export default tool({
-  description: "Get a specific OpenHermes memory record by class and ID",
-  args: {
-    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class"),
-    id: tool.schema.string().describe("Record ID to retrieve"),
-  },
-  async execute(args) {
-    return handleGet(args.class, args.id)
-  },
-})

package/lib/tools/hm_latest.mjs

@@ -1,12 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { handleLatest } from "./_memory.mjs"
-
-export default tool({
-  description: "Get the latest active OpenHermes memory record by class (returns the full record, not just metadata)",
-  args: {
-    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to get the latest from"),
-  },
-  async execute(args) {
-    return handleLatest(args.class)
-  },
-})

package/lib/tools/hm_list.mjs

@@ -1,13 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { handleList } from "./_memory.mjs"
-
-export default tool({
-  description: "List OpenHermes memory records by class, sorted by recency (newest first)",
-  args: {
-    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to list"),
-    limit: tool.schema.number().optional().default(10).describe("Max results (max 100)"),
-  },
-  async execute(args) {
-    return handleList(args.class, args.limit)
-  },
-})

package/lib/tools/hm_put.mjs

@@ -1,14 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { handlePut } from "./_memory.mjs"
-
-export default tool({
-  description: "Create or update an OpenHermes memory record (checkpoints, mistakes, decisions, constraints, instincts, audits, backlog items, verification receipts)",
-  args: {
-    class: tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]).describe("Memory class to write to"),
-    id: tool.schema.string().describe("Unique record ID (e.g. 'chk_2026-01-01T00-00-00-000Z')"),
-    data: tool.schema.string().describe("JSON string of the record fields (summary, scope, provenance, etc.)"),
-  },
-  async execute(args) {
-    return handlePut(args.class, args.id, args.data)
-  },
-})

package/lib/tools/hm_search.mjs

@@ -1,16 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { handleSearch } from "./_memory.mjs"
-
-export default tool({
-  description: "Search OpenHermes memory records with keyword matching and relevance ranking. Searches across all classes by default.",
-  args: {
-    query: tool.schema.string().describe("Search query string (matches against summary, id, description, tags, etc.)"),
-    scope: tool.schema.enum(["global", "local", "auto"]).optional().default("auto").describe("Search scope: global (only global-scope records), local (only project/session-scope), auto (all)"),
-    classes: tool.schema.array(tool.schema.enum(["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"])).optional().describe("Memory classes to search (default: all)"),
-    project: tool.schema.string().optional().describe("Project name filter for boosted relevance scoring"),
-    limit: tool.schema.number().optional().default(10).describe("Max results (max 50)"),
-  },
-  async execute(args) {
-    return handleSearch(args.query, args.scope, args.classes, args.project, args.limit)
-  },
-})