openhermes 1.2.2 → 1.3.0

package/README.md

@@ -97,7 +97,7 @@ The LLM reads rules on demand via the injected paths. Memory directories auto-cr
 
 ## Memory Architecture
 
-Nine memory classes, all schema-validated before persistence, stored at `~/.config/opencode/openhermes/memory/`:
+Nine memory classes, all schema-validated before persistence, stored at `~/.local/share/opencode/openhermes/memory/`:
 
 | Class | Format | Purpose |
 |-------|--------|---------|
@@ -111,6 +111,14 @@ Nine memory classes, all schema-validated before persistence, stored at `~/.conf
 | `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):
+
+| What | Where |
+|---|---|
+| Config (schemas, archive) | `~/.config/opencode/openhermes/` |
+| 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.
 
 ---
@@ -153,7 +161,7 @@ permission.replied
 
 ## Bundled Harness
 
-The full OpenHermes framework ships inside the package — 45 files across 6 directories:
+The full OpenHermes framework ships inside the package — 60 files across 6 directories:
 
 ```
 harness/
@@ -190,7 +198,7 @@ harness/
 ├── prompts/ (7 files)
 │   # Subagent prompt templates: architect, build-error-resolver,
 │   # code-reviewer, e2e-runner, explore, planner, security-reviewer
-└── commands/ (8 files)
+└── commands/ (7 files)
     # Slash command templates: build-fix, code-review, doctor,
     # learn, memory-search, plan, security
 ```

package/autorecall.mjs

@@ -2,21 +2,7 @@ import path from "node:path"
 import os from "node:os"
 import fs from "node:fs"
 import { atomicWriteJson, fingerprintEnvironment, isTruthy, sanitizeRecord, truncateText } from "./lib/hardening.mjs"
-
-function getHarnessRoot(directory) {
-  const home = process.env.USERPROFILE || os.homedir()
-  const configRoot = path.join(home, ".config", "opencode")
-  const projectHarness = path.join(directory, ".opencode", "openhermes")
-  const projectMemory = path.join(projectHarness, "memory")
-  if (isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) {
-    try {
-      fs.accessSync(projectMemory)
-      return projectHarness
-    } catch {
-    }
-  }
-  return path.join(configRoot, "openhermes")
-}
+import { getDataRoot, getCacheRoot, getMemoryRoot, getRecallRoot, getRuntimeRoot } from "./lib/paths.mjs"
 
 function readJson(fp, fallback) {
   try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
@@ -88,31 +74,52 @@ function formatMemoryWriteGap(memory) {
   return `## Memory Write Gap\nThese memory classes are empty: ${gaps.join(", ")}. Write at least one ${gaps[0]} this session.`
 }
 
-async function loadMemoryAndWriteCache(harnessRoot, projectKey, directory) {
+async function loadMemoryAndWriteCache(projectKey, directory) {
+  const OLD_MEMORY = path.join(os.homedir(), ".config", "opencode", "openhermes", "memory")
+  const OLD_CACHE = path.join(os.homedir(), ".config", "opencode", "openhermes", "memory", "recall")
+  const SENTINEL = path.join(getDataRoot(), ".migrated-from-v1")
+  if (!fs.existsSync(SENTINEL)) {
+    if (fs.existsSync(OLD_MEMORY)) {
+      fs.cpSync(OLD_MEMORY, getMemoryRoot(), { recursive: true })
+      fs.rmSync(OLD_MEMORY, { recursive: true, force: true })
+    }
+    if (fs.existsSync(OLD_CACHE)) {
+      fs.mkdirSync(getRecallRoot(), { recursive: true })
+      const files = fs.readdirSync(OLD_CACHE).filter(f => f.endsWith(".json"))
+      for (const f of files) fs.cpSync(path.join(OLD_CACHE, f), path.join(getRecallRoot(), f))
+    }
+    const oldRuntime = path.join(os.homedir(), ".config", "opencode", "openhermes", "runtime")
+    if (fs.existsSync(oldRuntime)) {
+      fs.cpSync(oldRuntime, getRuntimeRoot(), { recursive: true })
+      fs.rmSync(oldRuntime, { recursive: true, force: true })
+    }
+    fs.writeFileSync(SENTINEL, new Date().toISOString(), "utf8")
+  }
+
   const memory = { constraints: [], decisions: [], mistakes: [], checkpoint: null, pendingSkillCandidates: [] }
-  const fingerprint = buildEnvironmentFingerprint(harnessRoot, directory, projectKey)
+  const fingerprint = buildEnvironmentFingerprint(getDataRoot(), directory, projectKey)
 
-  const constraintsIndex = readJson(path.join(harnessRoot, "memory", "constraints", "index.json"), [])
+  const constraintsIndex = readJson(path.join(getMemoryRoot(), "constraints", "index.json"), [])
   if (Array.isArray(constraintsIndex)) memory.constraints = constraintsIndex.filter(e => e.status === "active")
 
-  const decisionsIndex = readJson(path.join(harnessRoot, "memory", "decisions", "index.json"), [])
+  const decisionsIndex = readJson(path.join(getMemoryRoot(), "decisions", "index.json"), [])
   if (Array.isArray(decisionsIndex)) {
     memory.decisions = decisionsIndex
       .filter(e => e.status === "active")
-      .map(entry => loadMemoryRecord(harnessRoot, "decisions", entry))
+      .map(entry => loadMemoryRecord(getDataRoot(), "decisions", entry))
       .filter(validateMemoryRecord)
   }
 
-  const allMistakes = readJsonl(path.join(harnessRoot, "memory", "mistakes", "mistakes.jsonl"))
+  const allMistakes = readJsonl(path.join(getMemoryRoot(), "mistakes", "mistakes.jsonl"))
   if (allMistakes.length) memory.mistakes = allMistakes.filter(e => e.status === "active").slice(0, 5)
 
-  const checkpointIndex = readJson(path.join(harnessRoot, "memory", "checkpoints", "index.json"), [])
+  const checkpointIndex = readJson(path.join(getMemoryRoot(), "checkpoints", "index.json"), [])
   if (Array.isArray(checkpointIndex) && checkpointIndex.length > 0) {
     const latest = checkpointIndex.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at))[0]
-    memory.checkpoint = readJson(path.join(harnessRoot, "memory", "checkpoints", `${latest.id}.json`), null)
+    memory.checkpoint = readJson(path.join(getMemoryRoot(), "checkpoints", `${latest.id}.json`), null)
   }
 
-  const backlogIndex = readJson(path.join(harnessRoot, "memory", "backlog", "index.json"), [])
+  const backlogIndex = readJson(path.join(getMemoryRoot(), "backlog", "index.json"), [])
   if (Array.isArray(backlogIndex)) {
     memory.pendingSkillCandidates = backlogIndex.filter(e =>
       e.status === "open" && (e.summary || "").includes("skill-candidate")
@@ -130,13 +137,13 @@ async function loadMemoryAndWriteCache(harnessRoot, projectKey, directory) {
   const context = contextParts.join("\n\n")
   const boundedContext = context ? truncateText(context, 12000) : null
 
-  const cacheDir = path.join(harnessRoot, "memory", "recall")
+  const cacheDir = getRecallRoot()
   fs.mkdirSync(cacheDir, { recursive: true })
   atomicWriteJson(path.join(cacheDir, "cache.json"), sanitizeRecord({
     context: boundedContext,
     project: projectKey,
     trust_mode: isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS) ? "project" : "global",
-    harness_root: harnessRoot,
+    harness_root: getDataRoot(),
     project_root: directory,
     updated_at: new Date().toISOString(),
     fingerprint,
@@ -158,9 +165,8 @@ export const AutorecallPlugin = async ({ project, directory }) => {
   return {
     event: async ({ event }) => {
       if (event.type === "session.created") {
-        const harnessRoot = getHarnessRoot(directory)
         const projectKey = project?.name || path.basename(directory)
-        await loadMemoryAndWriteCache(harnessRoot, projectKey, directory)
+        await loadMemoryAndWriteCache(projectKey, directory)
       }
     },
   }

package/bootstrap.mjs

@@ -35,7 +35,7 @@ Snapshot before mutation. Never delete unrelated files. Never assume \`%USERPROF
 | Category | Items |
 |----------|-------|
 | **Native tools** | \`read\`, \`write\`, \`edit\`, \`glob\`, \`grep\`, \`bash\`, \`task\`, \`webfetch\`, \`skill\`, \`todowrite\`, \`todoread\` |
-| **MCP: openhermes-memory** | \`hm_put\`, \`hm_get\`, \`hm_list\`, \`hm_latest\`, \`hm_search\` |
+| **In-process tools** | \`hm_put\`, \`hm_get\`, \`hm_list\`, \`hm_latest\`, \`hm_search\` |
 | **Memory recall cache** | \`openhermes/memory/recall/cache.json\` — read on session start, no MCP round-trip |
 | **Subagents** | \`explore\` (read-only), \`general\` (multi-step), \`architect\`, \`planner\`, \`build-error-resolver\`, \`code-reviewer\`, \`security-reviewer\`, \`e2e-runner\` |
 | **Plugins** | \`curator\` (checkpoints, mistakes, audit, compaction), \`autorecall\` (recall cache on \`session.created\`), \`skill-builder\` (complex session detection) |

package/curator.mjs

@@ -5,6 +5,7 @@ import { findUnsupportedSchemaKeywords, validateSchema } from "./lib/schema-vali
 import { atomicWriteJson, fingerprintEnvironment, fingerprintFile, isTruthy, redactSensitiveText, sanitizeRecord, truncateText } from "./lib/hardening.mjs"
 import { fileURLToPath } from "node:url"
 import { dirname } from "node:path"
+import { getConfigRoot, getDataRoot, getMemoryRoot, getRuntimeRoot, getArchiveRoot, getSchemaRoot } from "./lib/paths.mjs"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
@@ -19,21 +20,6 @@ function curatorLog(message) {
   process.stderr.write(`${message}\n`)
 }
 
-function getHarnessRoot(directory) {
-  const home = process.env.USERPROFILE || os.homedir()
-  const configRoot = path.join(home, ".config", "opencode")
-  const projectHarness = path.join(directory, ".opencode", "openhermes")
-  const projectMemory = path.join(projectHarness, "memory")
-  if (isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) {
-    try {
-      fs.accessSync(projectMemory)
-      return projectHarness
-    } catch {
-    }
-  }
-  return path.join(configRoot, "openhermes")
-}
-
 function readJson(fp, fallback) {
   try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
 }
@@ -92,8 +78,7 @@ function updateLoopState(root, patch) {
 }
 
 function loadSchema(classId) {
-  const home = process.env.USERPROFILE || os.homedir()
-  const fp = path.join(home, ".config", "opencode", "openhermes", "schemas", `${classId}.schema.json`)
+  const fp = path.join(getSchemaRoot(), `${classId}.schema.json`)
   try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch {}
   const bundled = path.join(__dirname, "schemas", `${classId}.schema.json`)
   try { return JSON.parse(fs.readFileSync(bundled, "utf8")) } catch { return null }
@@ -242,11 +227,16 @@ function writeMistakeRecord(root, project, directory, error) {
     project: project?.name || path.basename(directory),
     environment_fingerprint: environmentFingerprint,
   }
-  const dir = path.join(root, "memory", "mistakes")
+  const dir = path.join(getMemoryRoot(), "mistakes")
   fs.mkdirSync(dir, { recursive: true })
   const fp = path.join(dir, "mistakes.jsonl")
-  const line = JSON.stringify(sanitizeRecord(record, { maxStringLength: 4000 }))
-  try { fs.appendFileSync(fp, line + "\n") } catch { fs.writeFileSync(fp, line + "\n") }
+  const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
+  let entries = []
+  try { entries = fs.readFileSync(fp, "utf8").trim().split("\n").filter(Boolean).map(l => JSON.parse(l)) } catch {}
+  const idx = entries.findIndex(e => e.id === safeRecord.id)
+  if (idx >= 0) entries[idx] = safeRecord; else entries.push(safeRecord)
+  const text = entries.map(e => JSON.stringify(e)).join("\n")
+  fs.writeFileSync(fp, text ? text + "\n" : "", "utf8")
   curatorLog(`[curator] mistake logged: ${id} - ${safeLogMessage(errorMsg, 80)}`)
   return id
 }
@@ -298,7 +288,7 @@ function writeVerificationReceipt(root, project, directory, checkpointId) {
 
 async function handleSessionIdle(directory, project) {
   try {
-    const root = getHarnessRoot(directory)
+    const root = getDataRoot()
     const checkpointId = await writeCheckpoint(root, project, directory, "session.idle", null)
     if (checkpointId) {
       writeVerificationReceipt(root, project, directory, checkpointId)
@@ -310,7 +300,7 @@ async function handleSessionIdle(directory, project) {
 
 async function handleSessionCompacted(directory, project) {
   try {
-    const root = getHarnessRoot(directory)
+    const root = getDataRoot()
     const ts = new Date().toISOString()
     updateLoopState(root, {
       status: "compacted",
@@ -326,7 +316,7 @@ async function handleSessionCompacted(directory, project) {
 
 async function handleSessionError(directory, project, event) {
   try {
-    const root = getHarnessRoot(directory)
+    const root = getDataRoot()
     const ts = new Date().toISOString()
     const errorMsg = typeof event?.error === "object" && event.error !== null
       ? (event.error.message || JSON.stringify(event.error).slice(0, 200))
@@ -347,7 +337,7 @@ async function handleSessionError(directory, project, event) {
 
 async function handlePermissionReplied(directory, project, event) {
   try {
-    const root = getHarnessRoot(directory)
+    const root = getDataRoot()
     const ts = new Date().toISOString()
     const id = `audit_perm_${ts.replace(/[:.]/g, "-")}`
     const environmentFingerprint = buildEnvironmentFingerprint(root, directory, project)
@@ -387,7 +377,14 @@ async function handlePermissionReplied(directory, project, event) {
       environment_fingerprint: environmentFingerprint,
     }
     const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
-    if (!validateRecordAgainstSchema(safeRecord)) return
+    const auditSchema = loadSchema("audit") || readJson(path.join(__dirname, "schemas", "audit.schema.json"), null)
+    if (auditSchema) {
+      const unsupported = findUnsupportedSchemaKeywords(auditSchema)
+      if (!unsupported.length) {
+        const errors = validateSchema(auditSchema, safeRecord, "$")
+        if (errors.length) return
+      }
+    }
     const dir = path.join(root, "memory", "audits")
     fs.mkdirSync(dir, { recursive: true })
     atomicWriteJson(path.join(dir, `${id}.json`), safeRecord)
@@ -401,6 +398,20 @@ async function handlePermissionReplied(directory, project, event) {
 export const CuratorPlugin = async ({ project, directory }) => {
   return {
     event: async ({ event }) => {
+      const OLD_DATA = path.join(os.homedir(), ".config", "opencode", "openhermes", "memory")
+      const SENTINEL = path.join(getDataRoot(), ".migrated-from-v1")
+      if (!fs.existsSync(SENTINEL)) {
+        if (fs.existsSync(OLD_DATA)) {
+          fs.cpSync(OLD_DATA, getMemoryRoot(), { recursive: true })
+          fs.rmSync(OLD_DATA, { recursive: true, force: true })
+        }
+        const oldRuntime = path.join(os.homedir(), ".config", "opencode", "openhermes", "runtime")
+        if (fs.existsSync(oldRuntime)) {
+          fs.cpSync(oldRuntime, getRuntimeRoot(), { recursive: true })
+          fs.rmSync(oldRuntime, { 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") {
@@ -415,7 +426,7 @@ export const CuratorPlugin = async ({ project, directory }) => {
   },
   "experimental.session.compacting": async (input, output) => {
     try {
-      const root = getHarnessRoot(directory)
+      const root = getDataRoot()
       const projectKey = project?.name || path.basename(directory)
       const checkpointIndex = readJson(path.join(root, "memory", "checkpoints", "index.json"), [])
       const constraintsIndex = readJson(path.join(root, "memory", "constraints", "index.json"), [])

package/lib/memory-tools-plugin.mjs

@@ -6,11 +6,11 @@ import os from "os"
 
 import { atomicWriteJson, fingerprintEnvironment, sanitizeRecord, truncateText } from "./hardening.mjs"
 import { findUnsupportedSchemaKeywords, validateSchema } from "./schema-validator.mjs"
+import { getMemoryRoot, getConfigRoot, getDataRoot, getSchemaRoot, getRuntimeRoot } from "../lib/paths.mjs"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const PACKAGE_SCHEMAS = path.resolve(__dirname, "..", "schemas")
-const ROOT = path.join(os.homedir(), ".config", "opencode", "openhermes")
-const MEMORY_DIR = path.join(ROOT, "memory")
+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" }
@@ -141,7 +141,7 @@ function handlePut(cls, id, dataStr) {
   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 schema = readJSON(path.join(PACKAGE_SCHEMAS, `${cls}.schema.json`), null)
+  const schema = readJSON(path.join(getSchemaRoot(), `${cls}.schema.json`), null) || readJSON(path.join(PACKAGE_SCHEMAS, `${cls}.schema.json`), null)
   if (schema) {
     const unsupported = findUnsupportedSchemaKeywords(schema)
     if (unsupported.length) return `Unsupported schema keywords: ${unsupported.join(", ")}`
@@ -209,7 +209,7 @@ function handleSearch(query, scope, classes, project, limit) {
 
 export const MemoryToolsPlugin = async () => {
   fs.mkdirSync(MEMORY_DIR, { recursive: true })
-  fs.mkdirSync(path.join(ROOT, "runtime"), { recursive: true })
+  fs.mkdirSync(getRuntimeRoot(), { recursive: true })
 
   return {
     tool: {

package/lib/paths.mjs

@@ -0,0 +1,52 @@
+import path from "node:path"
+import os from "node:os"
+import fs from "node:fs"
+
+const HOME = process.env.USERPROFILE || os.homedir()
+const CONFIG_ROOT = path.join(HOME, ".config", "opencode", "openhermes")
+const DATA_ROOT = path.join(HOME, ".local", "share", "opencode", "openhermes")
+const CACHE_ROOT = path.join(HOME, ".cache", "opencode", "openhermes")
+
+function resolveRoot(envVar, fallback) {
+  if (!isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) return fallback
+  const cwd = process.cwd()
+  const project = path.join(cwd, ".opencode", "openhermes")
+  try { fs.accessSync(path.join(project, "memory")); return project } catch {}
+  return fallback
+}
+
+export function getConfigRoot() {
+  return resolveRoot("OPENCODE_ALLOW_PROJECT_HARNESS", CONFIG_ROOT)
+}
+
+export function getDataRoot() {
+  return resolveRoot("OPENCODE_ALLOW_PROJECT_HARNESS", DATA_ROOT)
+}
+
+export function getCacheRoot() {
+  return CACHE_ROOT
+}
+
+export function getMemoryRoot() {
+  return path.join(getDataRoot(), "memory")
+}
+
+export function getRuntimeRoot() {
+  return path.join(getDataRoot(), "runtime")
+}
+
+export function getRecallRoot() {
+  return path.join(getCacheRoot(), "recall")
+}
+
+export function getArchiveRoot() {
+  return path.join(getConfigRoot(), "archive")
+}
+
+export function getSchemaRoot() {
+  return path.join(getConfigRoot(), "schemas")
+}
+
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(String(value || ""))
+}

package/lib/tools/_memory.mjs

@@ -1,9 +1,9 @@
 import fs from "fs"
 import path from "path"
 import os from "os"
+import { getMemoryRoot, getDataRoot } from "../../lib/paths.mjs"
 
-const ROOT = path.join(os.homedir(), ".config", "opencode", "openhermes")
-const MEMORY_DIR = path.join(ROOT, "memory")
+const MEMORY_DIR = getMemoryRoot()
 
 const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
 const PLURALS = {

package/package.json

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

package/skill-builder.mjs

@@ -2,17 +2,7 @@ import path from "node:path"
 import fs from "node:fs"
 import os from "node:os"
 import { atomicWriteJson, fingerprintEnvironment, isTruthy, sanitizeRecord } from "./lib/hardening.mjs"
-
-function getHarnessRoot(directory) {
-  const home = process.env.USERPROFILE || os.homedir()
-  const configRoot = path.join(home, ".config", "opencode")
-  const projectHarness = path.join(directory, ".opencode", "openhermes")
-  const projectMemory = path.join(projectHarness, "memory")
-  if (isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) {
-    try { fs.accessSync(projectMemory); return projectHarness } catch {}
-  }
-  return path.join(configRoot, "openhermes")
-}
+import { getConfigRoot, getDataRoot, getMemoryRoot } from "./lib/paths.mjs"
 
 function readJson(fp, fallback) {
   try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
@@ -50,7 +40,7 @@ export const SkillBuilderPlugin = async ({ project, directory }) => {
 
         if (isComplex) {
           try {
-            const root = getHarnessRoot(directory)
+            const root = getDataRoot()
             const ts = new Date().toISOString()
             const id = `bl_skill_candidate_${ts.replace(/[:.]/g, "-")}`
             const backlogIndexPath = path.join(root, "memory", "backlog", "index.json")