openhermes 1.5.2 → 1.12.1

package/harness/rules/skills-management.md

@@ -130,7 +130,7 @@ The agent can create, update, and delete skills during sessions. This is the ski
 
 - Never create a skill from a single data point.
 - Minimum: 3 verified successes or 3 same-type mistakes in 7 days.
-- Check existing skills via `hm_search` before creating to avoid duplicates.
+- Check existing skills via `search_memory` before creating to avoid duplicates.
 
 ### Skill Quality Gates
 
@@ -162,4 +162,4 @@ Skills live in three locations (discovered by OpenCode):
 After creating or updating a skill:
 1. Run the workflow defined in the SKILL.md.
 2. Verify it produces the expected outcome.
-3. Write a verification receipt via `hm_put` with class `verification_receipt`.
+3. Write a verification receipt via `add_memory` with class `verification_receipt`.

package/harness/rules/state-drift.md

@@ -15,7 +15,7 @@ This creates "phantom" compressed data that references stale environments.
 {
   "fingerprint": {
     "cwd": "C:/path/to/project",
-    "harness_root": "C:/Users/nathan/.config/opencode/openhermes",
+    "harness_root": "C:/Users/nathan/.config/opencode",
     "project_root": "C:/path/to/project",
     "project": "my-project",
     "session_id": "session-123",

package/harness/rules/verification.md

@@ -14,7 +14,7 @@ Verification receipts prove that an artifact was observed in a particular state.
 
 ## Verification Cache (Memory-Backed)
 
-Successful verifications are stored via `hm_put` so repeated checks of unchanged artifacts are skipped.
+Successful verifications are stored via `add_memory` so repeated checks of unchanged artifacts are skipped.
 
 ### Cache Key
 
@@ -24,14 +24,14 @@ Each verification receipt is keyed by:
 
 ### Cache Lifecycle
 
-1. **Before trusting a claim**: search memory (`hm_get` or `hm_list`) for matching receipt.
+1. **Before trusting a claim**: search memory (`fetch_memory` or `list_memory`) for matching receipt.
 2. **Receipt found + fingerprint matches**: artifact unchanged. Trust cached result. Skip re-verify.
 3. **Receipt found + fingerprint differs**: artifact changed. Re-verify. Stale receipt is invalid.
 4. **No receipt found**: verify fresh. Store receipt on success.
 
 ### Receipt Storage
 
-Use `hm_put` with class `verification_receipt` — a dedicated memory class (schema: `schemas\verification_receipt.schema.json`). Receipts are stored as file-per-object in `memory\verification_receipts\<id>.json`.
+Use `add_memory` with class `verification_receipt` — a dedicated memory class (schema: `schemas\verification_receipt.schema.json`). Receipts are stored as file-per-object in `memory\verification_receipts\<id>.json`.
 
 Required fields:
 - **artifact**: path or logical identity of the verified artifact
@@ -69,7 +69,7 @@ Receipts stored under `decision` with `v:` prefix are deprecated. Migrate to `ve
 When verification reveals evidence contradicts a document or user claim:
 
 1. **Pause** — do not proceed on either source.
-2. **Log** — `hm_put` as `constraint` or `backlog` with both claim and contradictory evidence.
+2. **Log** — `add_memory` as `constraint` or `backlog` with both claim and contradictory evidence.
 3. **Flag** — ask user about the discrepancy. Present both sides.
 4. **Resolve** — let user decide which source is authoritative. Update document if needed.
 

package/harness/skills/coding-standards/SKILL.md

@@ -34,7 +34,7 @@ Activate this skill for:
 Do not use this skill as the primary source for:
 - React composition, hooks, or rendering patterns
 - backend architecture, API design, or database layering
-- domain-specific framework guidance when a narrower ECC skill already exists
+- domain-specific framework guidance when a narrower OpenHermes skill already exists
 
 ## Code Quality Principles
 

package/index.mjs

@@ -3,19 +3,40 @@ import { CuratorPlugin } from "./curator.mjs"
 import { SkillBuilderPlugin } from "./skill-builder.mjs"
 import { BootstrapPlugin } from "./bootstrap.mjs"
 import { MemoryToolsPlugin } from "./lib/memory-tools-plugin.mjs"
+import { OhcPlugin } from "./lib/ohc/pruner.mjs"
+import { UpdaterPlugin } from "./lib/ohc/updater.mjs"
+
+function chain(...fns) {
+  const h = fns.filter(Boolean)
+  if (!h.length) return undefined
+  if (h.length === 1) return h[0]
+  return async (i, o) => { for (const fn of h) await fn(i, o) }
+}
 
 export default async (input) => {
-  const [bootstrap, autorecall, curator, skillBuilder, memoryTools] = await Promise.all([
+  const [bootstrap, autorecall, curator, skillBuilder, memoryTools, ohc, updater] = await Promise.all([
     BootstrapPlugin(input),
     AutorecallPlugin(input),
     CuratorPlugin(input),
     SkillBuilderPlugin(input),
     MemoryToolsPlugin(input),
+    OhcPlugin(input),
+    UpdaterPlugin(input),
   ])
 
   const merged = {}
+
   if (bootstrap.config) merged.config = bootstrap.config
-  if (memoryTools.tool) merged.tool = memoryTools.tool
+
+  const toolHandlers = { ...memoryTools.tool, ...ohc.tool }
+  if (Object.keys(toolHandlers).length) merged.tool = toolHandlers
+
+  merged["experimental.chat.system.transform"] = chain(ohc["experimental.chat.system.transform"])
+  merged["experimental.chat.messages.transform"] = chain(
+    bootstrap["experimental.chat.messages.transform"],
+    ohc["experimental.chat.messages.transform"],
+  )
+  merged["command.execute.before"] = chain(updater["command.execute.before"], ohc["command.execute.before"])
 
   const eventHandlers = [autorecall.event, curator.event, skillBuilder.event].filter(Boolean)
   if (eventHandlers.length) {
@@ -24,8 +45,8 @@ export default async (input) => {
     }
   }
 
-  for (const hook of ["experimental.chat.messages.transform", "experimental.session.compacting", "tool.execute.after"]) {
-    const handler = bootstrap[hook] || curator[hook] || skillBuilder[hook]
+  for (const hook of ["experimental.session.compacting", "tool.execute.after"]) {
+    const handler = chain(curator[hook], skillBuilder[hook])
     if (handler) merged[hook] = handler
   }
 

package/lib/hardening.mjs

@@ -110,4 +110,14 @@ function isTruthy(value) {
   return /^(1|true|yes|on)$/i.test(String(value || ""))
 }
 
-export { atomicWriteJson, fingerprintEnvironment, fingerprintFile, isTruthy, redactSensitiveText, sanitizeRecord, truncateText }
+function readJson(fp, fallback) {
+  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
+}
+
+function readJsonl(fp) {
+  try {
+    return fs.readFileSync(fp, "utf8").trim().split("\n").filter(Boolean).map(l => JSON.parse(l))
+  } catch { return [] }
+}
+
+export { atomicWriteJson, fingerprintEnvironment, fingerprintFile, isTruthy, readJson, readJsonl, redactSensitiveText, sanitizeRecord, truncateText }

package/lib/memory-tools-plugin.mjs

@@ -1,12 +1,12 @@
 import { tool } from "@opencode-ai/plugin"
-import { fileURLToPath } from "url"
-import path from "path"
-import fs from "fs"
-import os from "os"
+import { fileURLToPath } from "node:url"
+import path from "node:path"
+import fs from "node:fs"
+import os from "node:os"
 
-import { atomicWriteJson, fingerprintEnvironment, sanitizeRecord, truncateText } from "./hardening.mjs"
+import { atomicWriteJson, fingerprintEnvironment, readJson, readJsonl, sanitizeRecord, truncateText } from "./hardening.mjs"
 import { findUnsupportedSchemaKeywords, validateSchema } from "./schema-validator.mjs"
-import { getMemoryRoot, getRuntimeRoot } from "../lib/paths.mjs"
+import { getMemoryRoot, getRuntimeRoot } from "./paths.mjs"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const SCHEMAS_DIR = path.resolve(__dirname, "..", "schemas")
@@ -44,16 +44,6 @@ function hasExpired(r) {
   return false
 }
 
-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 sortRecent(entries) {
   function ts(e) { return e?.updated_at ?? e?.created_at ?? "" }
   return [...entries].sort((a, b) => {
@@ -71,7 +61,7 @@ function writeObject(cls, record) {
   const fp = path.join(dir, `${record.id}.json`)
   atomicWriteJson(fp, record)
   const indexPath = path.join(dir, "index.json")
-  let index = readJSON(indexPath, [])
+  let index = readJson(indexPath, [])
   if (!Array.isArray(index)) index = []
   const idx = index.findIndex(e => e?.id === record.id)
   const entry = buildEntry(cls, record)
@@ -83,7 +73,7 @@ function upsertMistake(record) {
   const dir = classDir("mistake")
   fs.mkdirSync(dir, { recursive: true })
   const fp = path.join(dir, "mistakes.jsonl")
-  let entries = readJSONL(fp)
+  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")
@@ -92,18 +82,18 @@ function upsertMistake(record) {
 
 function queryList(cls, limit = 10) {
   if (cls === "mistake") {
-    return sortRecent(filterActive(readJSONL(path.join(classDir(cls), "mistakes.jsonl")))).slice(0, limit)
+    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))
+  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)
+  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) {
@@ -132,49 +122,67 @@ 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 handlePut(cls, id, dataStr) {
+function setToolTitle(context, title) {
+  if (!context || typeof context.metadata !== "function") return
+  context.metadata({ title })
+}
+
+function handleAdd(cls, id, dataStr) {
   let parsed
-  try { parsed = JSON.parse(dataStr) } catch (e) { return `data must be valid JSON: ${e.message}` }
+  try { parsed = JSON.parse(dataStr) } catch (e) { return `invalid 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 existing = queryGet(cls, id.trim())
+  const record = { ...parsed, id, class: cls, source: parsed.source ?? "agent", status: parsed.status ?? "active", created_at: parsed.created_at ?? (existing?.created_at ?? now), updated_at: now }
 
-  const schema = readJSON(path.join(SCHEMAS_DIR, `${cls}.schema.json`), null)
+  const schema = readJson(path.join(SCHEMAS_DIR, `${cls}.schema.json`), null)
   if (schema) {
+    const required = Array.isArray(schema.required) ? schema.required : []
+    if (required.includes("provenance")) {
+      if (!record.provenance) record.provenance = { session_id: `auto-${now}` }
+      else if (!record.provenance.session_id) record.provenance.session_id = `auto-${now}`
+    }
+    if (required.includes("trigger") && !record.trigger) record.trigger = "manual"
+    if (required.includes("success_count") && record.success_count == null) record.success_count = 0
+    if (required.includes("failure_count") && record.failure_count == null) record.failure_count = 0
+    if (required.includes("promotion_state") && !record.promotion_state) record.promotion_state = "project"
+
     const unsupported = findUnsupportedSchemaKeywords(schema)
-    if (unsupported.length) return `Unsupported schema keywords: ${unsupported.join(", ")}`
+    if (unsupported.length) return `unsupported schema: ${unsupported.join(", ")}`
     const errs = validateSchema(schema, record, "$")
     if (cls === "audit" && !enforceAuditEvidence(record)) errs.push("$.provenance must include at least one non-empty evidence ref")
-    if (errs.length) return `Validation errors: ${errs.join("; ")}`
+    if (errs.length) return `validation: ${errs.join("; ")}`
   }
 
   if (cls === "mistake") upsertMistake(record)
   else writeObject(cls, record)
 
-  return stableStringify({ ok: true, id })
+  const action = existing ? "updated" : "saved"
+  return `${action}: ${id.trim()}`
 }
 
-function handleGet(cls, id) {
+function handleFetch(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 })
+  if (!record) return `not found: ${id}`
+  return stableStringify(record)
 }
 
 function handleList(cls, limit = 10) {
   const entries = queryList(cls, Math.min(limit, 100))
-  return stableStringify({ ok: true, count: entries.length, entries })
+  const lines = entries.map(e => `  ${e.id}: ${truncateText(e.summary || "", 80)}`)
+  return `${entries.length} ${cls} record${entries.length === 1 ? "" : "s"}\n` + lines.join("\n")
 }
 
 function handleLatest(cls) {
   const list = queryList(cls, 100)
   const active = filterActive(list)
-  if (!active[0]?.id) return stableStringify({ ok: false, found: false })
+  if (!active[0]?.id) return "no active records"
   const record = queryGet(cls, active[0].id)
-  if (!record) return stableStringify({ ok: false, found: false })
-  return stableStringify({ ok: true, record })
+  if (!record) return "no active records"
+  return stableStringify(record)
 }
 
 function handleSearch(query, scope, classes, project, limit) {
@@ -185,7 +193,7 @@ function handleSearch(query, scope, classes, project, limit) {
   let records = []
   for (const cls of clsList) {
     if (cls === "mistake") {
-      for (const m of readJSONL(path.join(classDir(cls), "mistakes.jsonl"))) {
+      for (const m of readJsonl(path.join(classDir(cls), "mistakes.jsonl"))) {
         if (!hasExpired(m)) records.push(m)
       }
     } else {
@@ -193,7 +201,7 @@ function handleSearch(query, scope, classes, project, limit) {
       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)
+        const r = readJson(path.join(dir, f), null)
         if (r && !hasExpired(r)) records.push(r)
       }
     }
@@ -204,7 +212,19 @@ function handleSearch(query, scope, classes, project, limit) {
     .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 })
+  const lines = scored.map(e => `  ${e.id} (${e.score}pt): ${truncateText(e.summary || "", 80)}`)
+  return `${scored.length} result${scored.length === 1 ? "" : "s"} for '${q}'\n` + lines.join("\n")
+}
+
+function handleArchive(cls, id) {
+  if (!id?.trim()) return "non-blank id is required"
+  const record = queryGet(cls, id.trim())
+  if (!record) return `not found: ${id}`
+  record.status = "expired"
+  record.updated_at = new Date().toISOString()
+  if (cls === "mistake") upsertMistake(record)
+  else writeObject(cls, record)
+  return `archived: ${id.trim()}`
 }
 
 export const MemoryToolsPlugin = async () => {
@@ -213,44 +233,56 @@ export const MemoryToolsPlugin = async () => {
 
   return {
     tool: {
-      hm_put: tool({
-        description: "Create or update an OpenHermes memory record",
+      add_memory: tool({
+        description: "Save a new memory record or update an existing one by class and id",
         args: {
           class: tool.schema.enum(CLASSES),
           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, `save ${args.class}: ${args.id}`)
+          return handleAdd(args.class, args.id, args.data)
+        },
       }),
 
-      hm_get: tool({
-        description: "Get a specific OpenHermes memory record by ID",
+      fetch_memory: tool({
+        description: "Get a specific memory record by class and id",
         args: {
           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, `fetch ${args.class}: ${args.id}`)
+          return handleFetch(args.class, args.id)
+        },
       }),
 
-      hm_list: tool({
-        description: "List OpenHermes memory records by class, sorted by recency",
+      list_memory: tool({
+        description: "List recent memory records by class, sorted by recency",
         args: {
           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}`)
+          return handleList(args.class, args.limit)
+        },
       }),
 
-      hm_latest: tool({
-        description: "Get the latest active OpenHermes memory record by class",
+      latest_memory: tool({
+        description: "Get the latest active memory record by class",
         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}`)
+          return handleLatest(args.class)
+        },
       }),
 
-      hm_search: tool({
-        description: "Search OpenHermes memory records with keyword matching and relevance ranking",
+      search_memory: tool({
+        description: "Search memory records with keyword matching and relevance ranking across all classes",
         args: {
           query: tool.schema.string().describe("Search query string"),
           scope: tool.schema.enum(["global", "local", "auto"]).optional().default("auto").describe("Search scope"),
@@ -258,7 +290,22 @@ 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: ${truncateText(args.query, 48)}`)
+          return handleSearch(args.query, args.scope, args.classes, args.project, args.limit)
+        },
+      }),
+
+      archive_memory: tool({
+        description: "Soft-delete a memory record by setting its status to expired",
+        args: {
+          class: tool.schema.enum(CLASSES),
+          id: tool.schema.string(),
+        },
+        async execute(args, context) {
+          setToolTitle(context, `archive ${args.class}: ${args.id}`)
+          return handleArchive(args.class, args.id)
+        },
       }),
     },
   }

package/lib/ohc/config.mjs

@@ -0,0 +1,30 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "ohc.json")
+
+const DEFAULTS = { enabled: true, max: 200000, min: 50000 }
+
+function writeDefaults() {
+  try {
+    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true })
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2) + "\n", "utf8")
+  } catch {}
+}
+
+export function loadConfig() {
+  let raw = {}
+  try {
+    raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"))
+  } catch {
+    writeDefaults()
+    return { ...DEFAULTS }
+  }
+
+  return {
+    enabled: raw.enabled !== false,
+    max: typeof raw.max === "number" && raw.max > 0 ? raw.max : DEFAULTS.max,
+    min: typeof raw.min === "number" ? Math.max(10000, raw.min) : DEFAULTS.min,
+  }
+}