openhermes 1.2.2 → 1.4.1

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,9 @@ 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"
+import { getDataRoot, getCacheRoot, getMemoryRoot, getRecallRoot, getRuntimeRoot } from "./lib/paths.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")
-}
+const OLD_BASE = path.join(os.homedir(), ".config", "opencode", "openhermes")
 
 function readJson(fp, fallback) {
   try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
@@ -88,31 +76,56 @@ 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 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 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 })
+      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")
+  }
+
   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 +143,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 +171,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

@@ -1,6 +1,5 @@
 import path from "node:path"
 import fs from "node:fs"
-import os from "node:os"
 import { fileURLToPath } from "node:url"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -9,8 +8,7 @@ const RULES_DIR = path.join(HARNESS_DIR, "rules")
 const SKILLS_DIR = path.join(HARNESS_DIR, "skills")
 const CONSTITUTION_FILE = path.join(HARNESS_DIR, "constitution", "soul.md")
 const RUNTIME_FILE = path.join(HARNESS_DIR, "instructions", "RUNTIME.md")
-const TOOLS_SOURCE_DIR = path.resolve(__dirname, "lib", "tools")
-const USER_TOOLS_DIR = path.join(os.homedir(), ".config", "opencode", "tools")
+
 
 let _bootstrapCache = undefined
 
@@ -35,7 +33,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) |
@@ -116,35 +114,7 @@ function getOwnVersion() {
   } catch { return "1.0.0" }
 }
 
-function installToolFiles() {
-  try {
-    if (!fs.existsSync(TOOLS_SOURCE_DIR)) return
-    const files = fs.readdirSync(TOOLS_SOURCE_DIR).filter(f => f.endsWith(".mjs") && f !== "_memory.mjs")
-    if (!files.length) return
-    fs.mkdirSync(USER_TOOLS_DIR, { recursive: true })
-    const pkgVersion = getOwnVersion()
-    const markerPath = path.join(USER_TOOLS_DIR, ".openhermes-version")
-    let installedVersion = ""
-    try { installedVersion = fs.readFileSync(markerPath, "utf8").trim() } catch {}
-    if (installedVersion === pkgVersion) {
-      const existing = fs.readdirSync(USER_TOOLS_DIR).filter(f => f.endsWith(".mjs"))
-      const needed = [...files, "_memory.mjs"]
-      if (needed.every(f => existing.includes(f))) return
-    }
-    for (const f of ["_memory.mjs", ...files]) {
-      const src = path.join(TOOLS_SOURCE_DIR, f)
-      const dst = path.join(USER_TOOLS_DIR, f)
-      if (fs.existsSync(src)) fs.copyFileSync(src, dst)
-    }
-    fs.writeFileSync(markerPath, pkgVersion, "utf8")
-    process.stderr.write(`[openhermes-bootstrap] installed ${files.length + 1} tool files (v${pkgVersion})\n`)
-  } catch (err) {
-    process.stderr.write(`[openhermes-bootstrap] tool install error: ${err.message}\n`)
-  }
-}
-
 export const BootstrapPlugin = async ({ client, directory }) => {
-  installToolFiles()
 
   const getContent = () => {
     if (_bootstrapCache !== undefined) return _bootstrapCache
@@ -220,6 +190,23 @@ export const BootstrapPlugin = async ({ client, directory }) => {
         if (!config.agent[name]) config.agent[name] = def
       }
 
+      if (!config.agent["OpenHermes"]) {
+        config.agent["OpenHermes"] = {
+          description: "Fully autonomous primary coding agent (all tools allowed)",
+          mode: "primary",
+          color: "#F59E0B",
+          permission: {
+            bash: { "*": "allow" },
+            edit: "allow",
+            read: "allow",
+            task: { "*": "allow" }
+          }
+        }
+      }
+      if (!config.default_agent) {
+        config.default_agent = "OpenHermes"
+      }
+
       config.command = config.command || {}
       const COMMANDS_DIR = path.join(HARNESS_DIR, "commands")
       const ct = (file) => `{file:${path.join(COMMANDS_DIR, file)}}\n\n$ARGUMENTS`

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 { getDataRoot, getMemoryRoot, getRuntimeRoot, getArchiveRoot } 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,11 +78,8 @@ 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`)
-  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 }
+  const fp = path.join(__dirname, "schemas", `${classId}.schema.json`)
+  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return null }
 }
 
 function validateRecordAgainstSchema(record) {
@@ -242,11 +225,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 +286,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 +298,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 +314,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 +335,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 +375,14 @@ async function handlePermissionReplied(directory, project, event) {
       environment_fingerprint: environmentFingerprint,
     }
     const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
-    if (!validateRecordAgainstSchema(safeRecord)) return
+    const auditSchema = loadSchema("audit")
+    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 +396,25 @@ 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 })
+          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") {
@@ -415,7 +429,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, 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 SCHEMAS_DIR = path.resolve(__dirname, "..", "schemas")
+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(SCHEMAS_DIR, `${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,53 @@
+import path from "node:path"
+import os from "node:os"
+import fs from "node:fs"
+import { fileURLToPath } from "node:url"
+
+const HOME = process.env.USERPROFILE || os.homedir()
+const DATA_ROOT = path.join(HOME, ".local", "share", "opencode", "openhermes")
+const CACHE_ROOT = path.join(HOME, ".cache", "opencode", "openhermes")
+const PKG_DIR = path.dirname(fileURLToPath(import.meta.url))
+
+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 null // legacy — no longer used
+}
+
+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(getDataRoot(), "archive")
+}
+
+export function getSchemaRoot() {
+  return path.resolve(PKG_DIR, "..", "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.4.1",
   "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")