openhermes 1.3.0 → 1.4.1

package/autorecall.mjs

@@ -4,6 +4,8 @@ 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"
 
+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 }
 }
@@ -75,24 +77,28 @@ function formatMemoryWriteGap(memory) {
 }
 
 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 })
+    const oldMemory = path.join(OLD_BASE, "memory")
+    if (fs.existsSync(oldMemory)) {
+      fs.cpSync(oldMemory, getMemoryRoot(), { recursive: true })
+      fs.rmSync(oldMemory, { recursive: true, force: true })
     }
-    if (fs.existsSync(OLD_CACHE)) {
+    const oldCache = path.join(OLD_BASE, "memory", "recall")
+    if (fs.existsSync(oldCache)) {
       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 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(os.homedir(), ".config", "opencode", "openhermes", "runtime")
+    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")
   }
 

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
 
@@ -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,7 +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"
+import { getDataRoot, getMemoryRoot, getRuntimeRoot, getArchiveRoot } from "./lib/paths.mjs"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
@@ -78,10 +78,8 @@ function updateLoopState(root, patch) {
 }
 
 function loadSchema(classId) {
-  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 }
+  const fp = path.join(__dirname, "schemas", `${classId}.schema.json`)
+  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return null }
 }
 
 function validateRecordAgainstSchema(record) {
@@ -377,7 +375,7 @@ async function handlePermissionReplied(directory, project, event) {
       environment_fingerprint: environmentFingerprint,
     }
     const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
-    const auditSchema = loadSchema("audit") || readJson(path.join(__dirname, "schemas", "audit.schema.json"), null)
+    const auditSchema = loadSchema("audit")
     if (auditSchema) {
       const unsupported = findUnsupportedSchemaKeywords(auditSchema)
       if (!unsupported.length) {
@@ -398,18 +396,23 @@ 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 OLD_BASE = path.join(os.homedir(), ".config", "opencode", "openhermes")
       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 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(os.homedir(), ".config", "opencode", "openhermes", "runtime")
+        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") {

package/lib/memory-tools-plugin.mjs

@@ -6,10 +6,10 @@ 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"
+import { getMemoryRoot, getRuntimeRoot } from "../lib/paths.mjs"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const PACKAGE_SCHEMAS = path.resolve(__dirname, "..", "schemas")
+const SCHEMAS_DIR = path.resolve(__dirname, "..", "schemas")
 const MEMORY_DIR = getMemoryRoot()
 
 const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
@@ -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(getSchemaRoot(), `${cls}.schema.json`), null) || 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(", ")}`

package/lib/paths.mjs

@@ -1,11 +1,12 @@
 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 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")
+const PKG_DIR = path.dirname(fileURLToPath(import.meta.url))
 
 function resolveRoot(envVar, fallback) {
   if (!isTruthy(process.env.OPENCODE_ALLOW_PROJECT_HARNESS)) return fallback
@@ -16,7 +17,7 @@ function resolveRoot(envVar, fallback) {
 }
 
 export function getConfigRoot() {
-  return resolveRoot("OPENCODE_ALLOW_PROJECT_HARNESS", CONFIG_ROOT)
+  return null // legacy — no longer used
 }
 
 export function getDataRoot() {
@@ -40,11 +41,11 @@ export function getRecallRoot() {
 }
 
 export function getArchiveRoot() {
-  return path.join(getConfigRoot(), "archive")
+  return path.join(getDataRoot(), "archive")
 }
 
 export function getSchemaRoot() {
-  return path.join(getConfigRoot(), "schemas")
+  return path.resolve(PKG_DIR, "..", "schemas")
 }
 
 function isTruthy(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openhermes",
-  "version": "1.3.0",
+  "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",