openhermes 1.3.0 → 1.5.0

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
@@ -158,8 +128,6 @@ export const BootstrapPlugin = async ({ client, directory }) => {
   }
 
   return {
-    name: "openhermes-bootstrap",
-
     config: async (config) => {
       config.skills = config.skills || {}
       config.skills.paths = config.skills.paths || []
@@ -167,75 +135,88 @@ export const BootstrapPlugin = async ({ client, directory }) => {
         config.skills.paths.push(SKILLS_DIR)
       }
 
-      config.agent = config.agent || {}
       const PROMPTS_DIR = path.join(HARNESS_DIR, "prompts")
       const p = (name) => `{file:${path.join(PROMPTS_DIR, name)}}`
+      const COMMANDS_DIR = path.join(HARNESS_DIR, "commands")
+      const ct = (file) => `{file:${path.join(COMMANDS_DIR, file)}}\n\n$ARGUMENTS`
+
+      const existingCommands = config.command ?? {}
+      const existingAgents = { ...(config.agent ?? {}) }
 
-      const SUBAGENTS = {
+      if (existingAgents.build && typeof existingAgents.build === "object") {
+        existingAgents.build = { ...existingAgents.build, mode: "subagent", hidden: true }
+      }
+
+      config.command = {
+        ...existingCommands,
+        "build-fix": { agent: "build-error-resolver", description: "Fix build and TypeScript errors", subtask: true, template: ct("build-fix.md") },
+        "code-review": { agent: "code-reviewer", description: "Review code for quality, security, and maintainability", subtask: true, template: ct("code-review.md") },
+        "plan": { agent: "planner", description: "Create a detailed implementation plan", subtask: true, template: ct("plan.md") },
+        "security": { agent: "security-reviewer", description: "Run comprehensive security review", subtask: true, template: ct("security.md") },
+        "doctor": { agent: "OpenHermes", description: "Run OpenCode OpenHermes health diagnostics", subtask: true, template: ct("doctor.md") },
+        "memory-search": { agent: "OpenHermes", description: "Search OpenHermes memory with LLM summarization", subtask: true, template: ct("memory-search.md") },
+        "learn": { agent: "OpenHermes", description: "Create a new skill from recent work patterns", subtask: true, template: ct("learn.md") },
+      }
+
+      config.agent = {
+        ...existingAgents,
+        "OpenHermes": {
+          description: "Fully autonomous primary coding agent (all tools allowed)",
+          mode: "primary",
+          color: "#F59E0B",
+          permission: {
+            bash: { "*": "allow" },
+            edit: "allow",
+            read: "allow",
+            task: { "*": "allow" },
+          },
+        },
         "architect": {
           description: "Software architecture specialist for system design",
           mode: "subagent",
           prompt: p("architect.txt"),
-          permission: { read: "allow", edit: "deny", bash: "deny" }
+          permission: { read: "allow", edit: "deny", bash: "deny" },
         },
         "build-error-resolver": {
           description: "Build and TypeScript error resolution specialist",
           mode: "subagent",
           prompt: p("build-error-resolver.md"),
-          permission: { read: "allow", edit: "allow" }
+          permission: { read: "allow", edit: "allow" },
         },
         "code-reviewer": {
           description: "Expert code review specialist",
           mode: "subagent",
           prompt: p("code-reviewer.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny", task: { explore: "allow", "*": "deny" } }
+          permission: { read: "allow", edit: "deny", bash: "deny", task: { explore: "allow", "*": "deny" } },
         },
         "e2e-runner": {
           description: "End-to-end testing specialist using Playwright",
           mode: "subagent",
           prompt: p("e2e-runner.txt"),
-          permission: { read: "allow", edit: "allow" }
+          permission: { read: "allow", edit: "allow" },
         },
         "explore": {
           description: "Fast read-only codebase exploration agent",
           mode: "subagent",
           prompt: p("explore.md"),
-          permission: { read: "allow", grep: "allow", glob: "allow", list: "allow", edit: "deny", bash: "deny" }
+          permission: { read: "allow", grep: "allow", glob: "allow", list: "allow", edit: "deny", bash: "deny" },
         },
         "planner": {
           description: "Expert planning specialist for complex features and refactoring",
           mode: "subagent",
           color: "#3B82F6",
           prompt: p("planner.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny" }
+          permission: { read: "allow", edit: "deny", bash: "deny" },
         },
         "security-reviewer": {
           description: "Security vulnerability detection and remediation specialist",
           mode: "subagent",
           prompt: p("security-reviewer.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny", task: { "*": "allow" } }
-        }
-      }
-      for (const [name, def] of Object.entries(SUBAGENTS)) {
-        if (!config.agent[name]) config.agent[name] = def
+          permission: { read: "allow", edit: "deny", bash: "deny", task: { "*": "allow" } },
+        },
       }
 
-      config.command = config.command || {}
-      const COMMANDS_DIR = path.join(HARNESS_DIR, "commands")
-      const ct = (file) => `{file:${path.join(COMMANDS_DIR, file)}}\n\n$ARGUMENTS`
-
-      const COMMANDS = {
-        "build-fix": { agent: "build-error-resolver", description: "Fix build and TypeScript errors", subtask: true, template: ct("build-fix.md") },
-        "code-review": { agent: "code-reviewer", description: "Review code for quality, security, and maintainability", subtask: true, template: ct("code-review.md") },
-        "plan": { agent: "planner", description: "Create a detailed implementation plan", subtask: true, template: ct("plan.md") },
-        "security": { agent: "security-reviewer", description: "Run comprehensive security review", subtask: true, template: ct("security.md") },
-        "doctor": { agent: "OpenHermes", description: "Run OpenCode OpenHermes health diagnostics", subtask: true, template: ct("doctor.md") },
-        "memory-search": { agent: "OpenHermes", description: "Search OpenHermes memory with LLM summarization", subtask: true, template: ct("memory-search.md") },
-        "learn": { agent: "OpenHermes", description: "Create a new skill from recent work patterns", subtask: true, template: ct("learn.md") }
-      }
-      for (const [name, def] of Object.entries(COMMANDS)) {
-        if (!config.command[name]) config.command[name] = def
-      }
+      config.default_agent = "OpenHermes"
     },
 
     "experimental.chat.messages.transform": async (_input, output) => {

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/index.mjs

@@ -1,5 +1,33 @@
-export { AutorecallPlugin } from "./autorecall.mjs"
-export { CuratorPlugin } from "./curator.mjs"
-export { SkillBuilderPlugin } from "./skill-builder.mjs"
-export { BootstrapPlugin } from "./bootstrap.mjs"
-export { MemoryToolsPlugin } from "./lib/memory-tools-plugin.mjs"
+import { AutorecallPlugin } from "./autorecall.mjs"
+import { CuratorPlugin } from "./curator.mjs"
+import { SkillBuilderPlugin } from "./skill-builder.mjs"
+import { BootstrapPlugin } from "./bootstrap.mjs"
+import { MemoryToolsPlugin } from "./lib/memory-tools-plugin.mjs"
+
+export default async (input) => {
+  const [bootstrap, autorecall, curator, skillBuilder, memoryTools] = await Promise.all([
+    BootstrapPlugin(input),
+    AutorecallPlugin(input),
+    CuratorPlugin(input),
+    SkillBuilderPlugin(input),
+    MemoryToolsPlugin(input),
+  ])
+
+  const merged = {}
+  if (bootstrap.config) merged.config = bootstrap.config
+  if (memoryTools.tool) merged.tool = memoryTools.tool
+
+  const eventHandlers = [autorecall.event, curator.event, skillBuilder.event].filter(Boolean)
+  if (eventHandlers.length) {
+    merged.event = async (payload) => {
+      await Promise.all(eventHandlers.map(fn => fn(payload)))
+    }
+  }
+
+  for (const hook of ["experimental.chat.messages.transform", "experimental.session.compacting", "tool.execute.after"]) {
+    const handler = bootstrap[hook] || curator[hook] || skillBuilder[hook]
+    if (handler) merged[hook] = handler
+  }
+
+  return merged
+}

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.5.0",
   "description": "OpenHermes plugin suite for OpenCode — autonomous checkpointing, native memory tools, subagent routing, slash commands, and skill-candidate detection.",
   "type": "module",
   "license": "MIT",