openhermes 1.5.6 → 1.13.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/scripts/sync-commands.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = path.resolve(__dirname, "..", "..")
+const COMMANDS_DIR = path.join(REPO_ROOT, "harness", "commands")
+const BOOTSTRAP_FILE = path.join(REPO_ROOT, "bootstrap.mjs")
+const README_FILE = path.join(REPO_ROOT, "README.md")
+
+const COMMANDS_START = "<!-- COMMANDS:START -->"
+const COMMANDS_END = "<!-- COMMANDS:END -->"
+
+const HOOK_ONLY = new Set(["update-me"])
+
+function parseRegistry(src) {
+  const commands = {}
+  const blockMatch = src.match(/config\.command\s*=\s*\{([\s\S]*?)\n\s*\}/)
+  if (!blockMatch) return commands
+
+  let rest = blockMatch[1]
+  const entryRe = /^\s*"([^"]+)"\s*:\s*\{([\s\S]*?)\},?\s*$/gm
+  let m
+  while ((m = entryRe.exec(rest)) !== null) {
+    const name = m[1]
+    const body = m[2]
+    const agent = body.match(/agent:\s*"([^"]+)"/)?.[1] ?? ""
+    const description = body.match(/description:\s*"([^"]+)"/)?.[1] ?? ""
+    const template = body.match(/template:\s*ct\("([^"]+)"\)/) ? m[0].match(/template:\s*(ct\("[^"]+"\)|""|'')/)?.[1] : ""
+    const hasFile = template.includes("ct(")
+    commands[name] = { name, agent, description, hasFile }
+  }
+  return commands
+}
+
+function parseCommandFile(filePath) {
+  const src = fs.readFileSync(filePath, "utf8")
+  const name = path.basename(filePath, ".md")
+  const description = src.match(/^description:\s*(.+)$/m)?.[1] ?? ""
+  const agent = src.match(/^agent:\s*(.+)$/m)?.[1] ?? ""
+  return { name, description, agent }
+}
+
+function scanCommandFiles() {
+  const files = fs.readdirSync(COMMANDS_DIR).filter(f => f.endsWith(".md"))
+  const map = {}
+  for (const f of files) {
+    const parsed = parseCommandFile(path.join(COMMANDS_DIR, f))
+    map[parsed.name] = parsed
+  }
+  return map
+}
+
+function getHookCommands() {
+  return [...HOOK_ONLY].map(name => ({ name, agent: "", description: "Hook-handled (see plugin source)" }))
+}
+
+function printReport(registry, filesOnDisk, hookCommands, cmdNames) {
+  console.log("")
+  console.log("  COMMAND SYNC REPORT")
+  console.log("  " + "=".repeat(50))
+  const registered = new Set(Object.keys(registry))
+  const onDisk = new Set(Object.keys(filesOnDisk))
+  const allHooks = new Set(hookCommands.map(h => h.name))
+  const hookNoReg = [...allHooks].filter(n => !registered.has(n) && !onDisk.has(n))
+
+  console.log(`  Registered in bootstrap.mjs:  ${registered.size}`)
+  console.log(`  Files in harness/commands/:    ${onDisk.size}`)
+  console.log(`  Hook-only (no registry):        ${hookNoReg.length}`)
+  console.log(`  Total real commands:           ${cmdNames.length}`)
+  console.log("")
+
+  const registeredNoFile = [...registered].filter(n => !onDisk.has(n))
+  const fileNotRegistered = [...onDisk].filter(n => !registered.has(n) && !allHooks.has(n))
+
+  if (registeredNoFile.length) {
+    console.log("  ⚠ REGISTERED, NO FILE:")
+    for (const n of registeredNoFile) {
+      const e = registry[n]
+      console.log(`    /${n}  —  ${e.description}`)
+    }
+    console.log("")
+  }
+
+  if (fileNotRegistered.length) {
+    console.log("  ⚠ FILE EXISTS, NOT REGISTERED:")
+    for (const n of fileNotRegistered) {
+      console.log(`    /${n}`)
+    }
+    console.log("")
+  }
+
+  if (hookNoReg.length) {
+    console.log("  ℹ HOOK-ONLY (no registry, no file):")
+    for (const n of hookNoReg) {
+      console.log(`    /${n}`)
+    }
+    console.log("")
+  }
+
+  if (!registeredNoFile.length && !fileNotRegistered.length) {
+    console.log("  ✓ Everything in sync — no gaps.")
+    console.log("")
+  }
+}
+
+function generateMissingFiles(registry, filesOnDisk) {
+  let count = 0
+  for (const [name, entry] of Object.entries(registry)) {
+    if (filesOnDisk[name]) continue
+
+    const templateFile = `${name}.md`
+    const agent = entry.agent || "OpenHermes"
+    const desc = entry.description
+
+    let md = `---
+description: ${desc}
+agent: ${agent}
+subtask: true
+---
+
+# ${name.charAt(0).toUpperCase() + name.slice(1)} Command
+
+`
+
+    if (name === "ohc") {
+      md += `OHC context management — hook-handled.\n\nRun \`/ohc status\` to check context usage, \`/ohc compress [targetTokens] [focus]\` to free space.\n\n$ARGUMENTS\n`
+    } else {
+      md += `${desc}: $ARGUMENTS\n`
+    }
+
+    fs.writeFileSync(path.join(COMMANDS_DIR, templateFile), md, "utf8")
+    console.log(`  ✓ Created harness/commands/${templateFile}`)
+    count++
+  }
+
+  if (count === 0) console.log("  No missing files to generate.")
+  return count
+}
+
+function getCommandNames(registry, hookCommands) {
+  const registered = new Set(Object.keys(registry))
+  const hookOnly = hookCommands.filter(h => !registered.has(h.name)).map(h => h.name)
+  const names = [...registered, ...hookOnly]
+  names.sort()
+  return names
+}
+
+function formatCommandRow(names) {
+  const count = names.length
+  const list = names.map(n => `\`/${n}\``).join(", ")
+  return `| **${count} slash commands** | ${list} |`
+}
+
+function formatBacktickList(names) {
+  return ` ${names.map(n => `\\\`/${n}\\\``).join(", ")}`
+}
+
+function syncBootstrap(registry, hookCommands) {
+  let src = fs.readFileSync(BOOTSTRAP_FILE, "utf8")
+  const cmdNames = getCommandNames(registry, hookCommands)
+  const row = formatCommandRow(cmdNames)
+
+  const startIdx = src.indexOf(COMMANDS_START)
+  const endIdx = src.indexOf(COMMANDS_END)
+
+  if (startIdx === -1 || endIdx === -1) {
+    console.log("  ✗ Markers not found in bootstrap.mjs. Inserting markers.")
+    const plugRowRe = /(\|\s+\*\*Plugins\s*\*\*.*\|)/
+    const match = src.match(plugRowRe)
+    if (!match) {
+      console.log("  ✗ Could not find Plugins row to anchor insertion.")
+      return false
+    }
+    const insertAfter = match.index + match[0].length
+    const newRow = `\n| **Slash commands** | ${COMMANDS_START} ${COMMANDS_END} |`
+    src = src.slice(0, insertAfter) + newRow + src.slice(insertAfter)
+    // Re-find markers for content replacement below
+    const newStart = src.indexOf(COMMANDS_START)
+    const newEnd = src.indexOf(COMMANDS_END)
+    if (newStart !== -1 && newEnd !== -1 && newEnd > newStart) {
+      const content = formatBacktickList(cmdNames)
+      src = src.slice(0, newStart + COMMANDS_START.length) + content + src.slice(newEnd)
+    }
+    fs.writeFileSync(BOOTSTRAP_FILE, src, "utf8")
+    console.log("  ✓ Inserted Slash commands row in bootstrap.mjs")
+    return true
+  }
+
+  if (endIdx <= startIdx) {
+    console.log("  ✗ Markers out of order in bootstrap.mjs")
+    return false
+  }
+
+  const content = formatBacktickList(cmdNames)
+  src = src.slice(0, startIdx + COMMANDS_START.length) + content + src.slice(endIdx)
+  fs.writeFileSync(BOOTSTRAP_FILE, src, "utf8")
+  console.log("  ✓ Updated Slash commands row in bootstrap.mjs")
+  return true
+}
+
+function syncReadme(registry, hookCommands) {
+  let src = fs.readFileSync(README_FILE, "utf8")
+  const cmdNames = getCommandNames(registry, hookCommands)
+  const row = formatCommandRow(cmdNames)
+
+  const tableRowRe = /^\|\s*\*\*(\d+)\s*slash commands\s*\*\*.*\|$/m
+  const match = src.match(tableRowRe)
+  if (!match) {
+    console.log("  ✗ Could not find slash commands row in README.md")
+    return false
+  }
+
+  src = src.replace(tableRowRe, row)
+  fs.writeFileSync(README_FILE, src, "utf8")
+  console.log(`  ✓ Updated README.md: ${cmdNames.length} commands`)
+  return true
+}
+
+// Main
+const args = process.argv.slice(2)
+const doAudit = args.includes("--audit") || args.length === 0
+const doGenerate = args.includes("--generate") || args.length === 0
+const doSyncBootstrap = args.includes("--sync-bootstrap") || args.includes("--sync") || args.length === 0
+const doSyncReadme = args.includes("--sync-readme") || args.includes("--sync") || args.length === 0
+
+console.log("  ▸ syncing command definitions...")
+console.log("")
+
+const bootstrapSrc = fs.readFileSync(BOOTSTRAP_FILE, "utf8")
+const registry = parseRegistry(bootstrapSrc)
+const filesOnDisk = scanCommandFiles()
+const hookCommands = getHookCommands()
+const cmdNames = getCommandNames(registry, hookCommands)
+
+if (doAudit) printReport(registry, filesOnDisk, hookCommands, cmdNames)
+
+if (doGenerate) {
+  console.log("  [generate]")
+  generateMissingFiles(registry, filesOnDisk)
+  console.log("")
+}
+
+if (doSyncBootstrap) {
+  console.log("  [sync-bootstrap]")
+  const ok = syncBootstrap(registry, hookCommands)
+  if (!ok) process.exitCode = 1
+  console.log("")
+}
+
+if (doSyncReadme) {
+  console.log("  [sync-readme]")
+  const ok = syncReadme(registry, hookCommands)
+  if (!ok) process.exitCode = 1
+  console.log("")
+}
+
+console.log("  done.")

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 }