openhermes 1.13.1 → 2.5.1

package/harness/rules/self-heal.md

@@ -35,7 +35,7 @@ Self-correction escalates through structured tiers. There is no self-termination
    - Build failure → `build-error-resolver`
    - Logic/scope/other → `diagnose` skill + `code-reviewer`
    - Security → `security-reviewer`
-    - Config/tool → `openhermes-optimizer` + openhermes audit
+    - Config/tool → `harness-optimizer` + openhermes audit
 2. If structural (affects openhermes behavior across projects), generate a backlog item.
 3. Run an openhermes audit to check for broken references, stale constraints, or provenance gaps.
 4. Document findings and updated prevention rules.

package/harness/rules/session-start.md

@@ -8,13 +8,13 @@ Run this at the start of every new session and every resume before substantive w
 2. Load openhermes status from `%USERPROFILE%\.config\opencode\ohc.json` if rule paths or memory locations are needed.
 3. **Read autorecall cache**: If `openhermes\memory\recall\cache.json` exists, load it — it contains active checkpoint, constraints, decisions, and mistakes from the prior session. The autorecall plugin writes this at session start. Use this context before probing MCP tools.
 4. Check only the smallest relevant curated memory slice in `openhermes\memory\`:
-   - latest checkpoint via `latest_memory`
-   - active decisions via `latest_memory` or a narrow `search_memory`
-   - active constraints via `latest_memory` or a narrow `search_memory`
+   - latest checkpoint via `ohc_latest`
+   - active decisions via `ohc_latest` or a narrow `ohc_search`
+   - active constraints via `ohc_latest` or a narrow `ohc_search`
    - recent same-type mistakes only if the task matches a known pattern
    - do not read whole memory indexes unless the task is explicitly about index auditing or repair
 5. If no relevant memory exists, proceed fresh without pretending there is prior state.
-6. If last openhermes audit is missing or older than 7 days, flag `/openhermes-audit` as due.
+6. If last openhermes audit is missing or older than 7 days, flag `/harness-audit` as due.
 7. Before substantial work, choose the smallest correct path:
    - native read/grep/glob for search/gather
    - `explore` subagent for multi-file analysis
@@ -23,7 +23,7 @@ Run this at the start of every new session and every resume before substantive w
 ## User Entry Points
 
 - `/openhermes`: bootstrap openhermes state, summarize current readiness, and surface due actions.
-- `/openhermes-audit`: run an openhermes audit workflow and return findings.
+- `/harness-audit`: run an openhermes audit workflow and return findings.
 
 ## Output Contract
 

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 `search_memory` before creating to avoid duplicates.
+- Check existing skills via `ohc_search` 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 `add_memory` with class `verification_receipt`.
+3. Write a verification receipt via `ohc_save` with class `verification_receipt`.

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 `add_memory` so repeated checks of unchanged artifacts are skipped.
+Successful verifications are stored via `ohc_save` 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 (`fetch_memory` or `list_memory`) for matching receipt.
+1. **Before trusting a claim**: search memory (`ohc_get` or `ohc_list`) 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 `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`.
+Use `ohc_save` 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** — `add_memory` as `constraint` or `backlog` with both claim and contradictory evidence.
+2. **Log** — `ohc_save` 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/index.mjs

@@ -3,6 +3,7 @@ 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 { AmbientMemoryPlugin } from "./lib/ambient-memory.mjs"
 import { OhcPlugin } from "./lib/ohc/pruner.mjs"
 import { UpdaterPlugin } from "./lib/ohc/updater.mjs"
 
@@ -14,15 +15,17 @@ function chain(...fns) {
 }
 
 export default async (input) => {
-  const [bootstrap, autorecall, curator, skillBuilder, memoryTools, ohc, updater] = await Promise.all([
+  const results = await Promise.allSettled([
     BootstrapPlugin(input),
     AutorecallPlugin(input),
     CuratorPlugin(input),
     SkillBuilderPlugin(input),
     MemoryToolsPlugin(input),
+    AmbientMemoryPlugin(input),
     OhcPlugin(input),
     UpdaterPlugin(input),
   ])
+  const [bootstrap, autorecall, curator, skillBuilder, memoryTools, ambient, ohc, updater] = results.map(r => r.status === 'fulfilled' ? r.value : {})
 
   const merged = {}
 
@@ -33,6 +36,7 @@ export default async (input) => {
 
   merged["experimental.chat.system.transform"] = chain(ohc["experimental.chat.system.transform"])
   merged["experimental.chat.messages.transform"] = chain(
+    ambient["experimental.chat.messages.transform"],
     bootstrap["experimental.chat.messages.transform"],
     ohc["experimental.chat.messages.transform"],
   )
@@ -41,7 +45,7 @@ export default async (input) => {
   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)))
+      await Promise.allSettled(eventHandlers.map(fn => fn(payload)))
     }
   }
 

package/lib/ambient-memory.mjs

@@ -0,0 +1,167 @@
+import path from "node:path"
+import fs from "node:fs"
+import { readJson, readJsonl, truncateText } from "./hardening.mjs"
+import { getMemoryRoot, getRecallRoot, getDataRoot } from "./paths.mjs"
+import { scoreRelevance } from "./search.mjs"
+
+const PLURALS = { audit: "audits", checkpoint: "checkpoints", mistake: "mistakes", instinct: "instincts", decision: "decisions", constraint: "constraints", backlog: "backlog", verification_receipt: "verification_receipts" }
+const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
+
+const MEMORY_QUERY_PATTERNS = [
+  /where\s+(did|do)\s+we\s+(leave\s+off|left\s+off)/i,
+  /where\s+were\s+we/i,
+  /what\s+(was|is)\s+(the\s+)?(last|latest|most\s+recent)\s+(checkpoint|decision|constraint|feature|task|change|issue|fix|bug|request|request)/i,
+  /remind\s+me\s+(about|of)/i,
+  /what\s+were\s+we\s+(working\s+on|doing)/i,
+  /what\s+(happened|changed)\s+(last|yesterday|before|previously)/i,
+  /previous\s+session/i,
+  /last\s+time/i,
+  /recap/i,
+  /what\s+is\s+(the\s+)?(status|state)\s+of/i,
+  /did\s+we\s+(decide|agree|finish|resolve|discuss)/i,
+  /where\s+(did|do)\s+i\s+(leave\s+off|left\s+off)/i,
+]
+
+function hasExpired(r) {
+  if (r?.status === "expired" || r?.status === "decayed") return true
+  if (r?.decay_at && Date.parse(r.decay_at) < Date.now()) return true
+  if (r?.expires_at && Date.parse(r.expires_at) < Date.now()) return true
+  return false
+}
+
+function filterActive(entries) { return entries.filter(e => !hasExpired(e)) }
+
+function detectMemoryQuery(text) {
+  return MEMORY_QUERY_PATTERNS.some(p => p.test(text))
+}
+
+function extractSearchTerms(text) {
+  const cleaned = text.replace(/<[^>]+>/g, "").replace(/[^\w\s-]/g, " ").trim()
+  return cleaned.slice(0, 200)
+}
+
+function classDir(cls) { return path.join(getMemoryRoot(), PLURALS[cls]) }
+
+function readAllRecords() {
+  const records = []
+  for (const cls of CLASSES) {
+    if (cls === "mistake") {
+      for (const m of readJsonl(path.join(classDir(cls), "mistakes.jsonl"))) {
+        if (!hasExpired(m)) records.push({ ...m, _cls: cls })
+      }
+    } else {
+      const dir = classDir(cls)
+      const index = readJson(path.join(dir, "index.json"), [])
+      if (!Array.isArray(index)) continue
+      for (const entry of index) {
+        if (!hasExpired(entry)) {
+          records.push({ ...entry, _cls: cls })
+        }
+      }
+    }
+  }
+  return records
+}
+
+function autoSearch(query) {
+  const q = (query || "").trim()
+  if (!q) return []
+
+  const records = readAllRecords()
+  const scored = records
+    .map(r => ({ ...r, _score: scoreRelevance(r, q, "") }))
+    .filter(r => r._score > 0)
+    .sort((a, b) => b._score - a._score)
+    .slice(0, 5)
+
+  return scored
+}
+
+function buildMemoryBlock() {
+  const parts = []
+
+  const ckIndex = readJson(path.join(getMemoryRoot(), "checkpoints", "index.json"), [])
+  if (Array.isArray(ckIndex) && ckIndex.length > 0) {
+    const latest = [...ckIndex].sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at))[0]
+    if (latest) {
+      const cp = readJson(path.join(getMemoryRoot(), "checkpoints", `${latest.id}.json`), null)
+      if (cp) {
+        parts.push(`Checkpoint: ${cp.summary || "N/A"}`)
+        if (cp.mission) parts.push(`Mission: ${truncateText(cp.mission, 200)}`)
+        if (Array.isArray(cp.next_actions) && cp.next_actions.length) parts.push(`Next: ${cp.next_actions.slice(0, 2).join("; ")}`)
+      }
+    }
+  }
+
+  const ctIndex = readJson(path.join(getMemoryRoot(), "constraints", "index.json"), [])
+  if (Array.isArray(ctIndex)) {
+    const active = ctIndex.filter(e => e.status === "active")
+    if (active.length) parts.push(`Constraints (${active.length} active)`)
+  }
+
+  const dcIndex = readJson(path.join(getMemoryRoot(), "decisions", "index.json"), [])
+  if (Array.isArray(dcIndex)) {
+    const recent = filterActive(dcIndex).slice(0, 2)
+    if (recent.length) parts.push(`Recent decisions: ${recent.map(d => truncateText(d.summary || "", 80)).join(" | ")}`)
+  }
+
+  const bkIndex = readJson(path.join(getMemoryRoot(), "backlog", "index.json"), [])
+  if (Array.isArray(bkIndex)) {
+    const open = bkIndex.filter(e => e.status === "open")
+    if (open.length) parts.push(`Backlog: ${open.length} open`)
+  }
+
+  return parts.length ? parts.join("\n") : "No active memory records found."
+}
+
+export const AmbientMemoryPlugin = async () => ({
+  "experimental.chat.messages.transform": async (_input, output) => {
+    if (!output.messages?.length) return
+
+    const firstUser = output.messages.find(m => m.info?.role === "user")
+    if (!firstUser?.parts?.length) return
+
+    const hasMemoryTag = firstUser.parts.some(p => p.type === "text" && p.text.includes("OPENHERMES_MEMORY"))
+
+    if (!hasMemoryTag) {
+      const block = buildMemoryBlock()
+      const tag = `<OPENHERMES_MEMORY>\n${block}\n</OPENHERMES_MEMORY>`
+      const textPart = firstUser.parts.find(p => p.type === "text")
+      if (textPart) {
+        textPart.text = `${tag}\n\n${textPart.text}`
+      }
+    }
+
+    const lastUser = [...output.messages].reverse().find(m => m.info?.role === "user")
+    if (!lastUser) return
+
+    const text = lastUser.parts?.find(p => p.type === "text")?.text || ""
+    if (!text || !detectMemoryQuery(text)) return
+
+    const terms = extractSearchTerms(text)
+    if (!terms) return
+
+    const results = autoSearch(terms)
+    if (!results.length) return
+
+    const contextBlock = [
+      `<memory-context>`,
+      `[System note: auto-retrieved from durable memory — NOT new user input]`,
+      ...results.slice(0, 3).map(r => {
+        const cls = r.class || "?";
+        const label = `${cls}:${r.id}`
+        return `- ${label}: ${truncateText(r.summary || "", 120)}`
+      }),
+      results.length > 3 ? `  ... and ${results.length - 3} more results` : null,
+      `</memory-context>`,
+    ].filter(Boolean).join("\n")
+
+    const idx = output.messages.indexOf(lastUser)
+    if (idx > 0) {
+      output.messages.splice(idx, 0, {
+        parts: [{ type: "text", text: contextBlock }],
+        info: { role: "system" },
+      })
+    }
+  }
+})

package/lib/handoff.mjs

@@ -0,0 +1,176 @@
+// OpenHermes Agent Handoff — lightweight helper library
+// Convention-based, no runtime deps. Agents import and call.
+
+let _idSeq = 0
+const COMPLEXITY_RULES = [
+  { maxFiles: 2, patterns: 0, label: "easy" },
+  { maxFiles: 10, patterns: 0, label: "medium" },
+  { maxFiles: 60, patterns: 0, label: "hard" },
+]
+
+function nextId() {
+  _idSeq++
+  return `ho_${Date.now().toString(36)}_${_idSeq}`
+}
+
+function clamp(v, lo, hi) { return Math.max(lo, Math.min(hi, v)) }
+
+// Estimate task complexity from file count and description.
+export function assessComplexity(fileCount = 1, description = "", patterns = []) {
+  const pScore = Array.isArray(patterns) ? patterns.length : 0
+  const level = fileCount > 50 || pScore > 5 ? "very-large"
+    : fileCount > 10 || pScore > 2 ? "hard"
+    : fileCount > 2 || pScore > 0 ? "medium"
+    : "easy"
+  return {
+    level,
+    fileCount: clamp(fileCount, 0, 9999),
+    patterns: pScore,
+    strategy: level === "easy" ? "direct"
+      : level === "medium" ? "sequential-or-fan-out"
+      : level === "hard" ? "sequential-multi"
+      : "fan-out"
+  }
+}
+
+// Build a structured handoff request string for the `task` tool prompt.
+export function handoffRequest(opts) {
+  const {
+    agent,
+    phase = "execute",
+    context = "",
+    goal = "",
+    expected = "",
+    permissions = "",
+    limits = "",
+    complexity,
+  } = opts || {}
+  const id = nextId()
+  const c = complexity || assessComplexity()
+  const lines = [
+    `## HANDOFF REQUEST`,
+    `Agent: ${agent}`,
+    `Task ID: ${id}`,
+    `Phase: ${phase}`,
+    `Complexity: ${c.level}`,
+    ``,
+    `### Context`,
+    String(context).trim() || "(no context provided)",
+    ``,
+    `### Goal`,
+    String(goal).trim() || "(no goal provided)",
+    ``,
+    `### Expected Output`,
+    String(expected).trim() || "Return structured result with status, summary, details, receipts, next, learning.",
+    ``,
+    `### Permissions`,
+    String(permissions).trim() || "(default permissions apply)",
+    ``,
+    `### Limits`,
+    String(limits).trim() || "(no explicit limits)",
+    ``,
+    `### Handoff Result Format`,
+    `When done, return:`,
+    `## HANDOFF RESULT`,
+    `Status: success | failure | partial`,
+    `Task ID: ${id}`,
+    `### Summary`,
+    `### Details`,
+    `### Receipts`,
+    `### Next`,
+    `### Learning`,
+  ].join("\n")
+  return { id, prompt: lines }
+}
+
+// Validate a subagent's result string has required sections.
+export function parseHandoffResult(text) {
+  if (!text || typeof text !== "string") return { status: "invalid", error: "no result text" }
+  const statusMatch = text.match(/Status:\s*(success|failure|partial)/i)
+  const hasSummary = /### Summary/i.test(text)
+  const hasDetails = /### Details/i.test(text)
+  const hasReceipts = /### Receipts/i.test(text)
+  const summaryMatch = text.match(/### Summary\s*\n\s*(.+)/i)
+  return {
+    status: statusMatch ? statusMatch[1].toLowerCase() : "unknown",
+    summary: summaryMatch ? summaryMatch[1].trim() : "",
+    hasSummary,
+    hasDetails,
+    hasReceipts,
+    valid: !!(statusMatch && hasSummary),
+  }
+}
+
+// Agent capability/role definitions for reference.
+export const AGENT_ROLES = {
+  OpenHermes:       { tier: 3, edit: true,  exec: true,  desc: "Primary agent — all tools, all permissions" },
+  architect:        { tier: 1, edit: false, exec: false, desc: "System architecture design" },
+  planner:          { tier: 1, edit: false, exec: false, desc: "Feature/refactor planning" },
+  "code-reviewer":  { tier: 1, edit: false, exec: false, desc: "Code quality review" },
+  "security-reviewer": { tier: 1, edit: false, exec: false, desc: "Security audit (report only, no patches)" },
+  explore:          { tier: 1, edit: false, exec: false, desc: "Read-only codebase exploration" },
+  "build-error-resolver": { tier: 2, edit: true, exec: true, desc: "Build/type error fixes" },
+  "doc-updater":    { tier: 2, edit: true, exec: true, desc: "Doc/codemap updates" },
+  "refactor-cleaner": { tier: 2, edit: true, exec: true, desc: "Dead code cleanup" },
+  "tdd-guide":      { tier: 2, edit: true, exec: true, desc: "TDD red-green-refactor" },
+  "loop-operator":  { tier: 3, edit: true, exec: true, desc: "Managed autonomous loops" },
+  "e2e-runner":     { tier: 3, edit: true, exec: true, desc: "Playwright E2E tests" },
+  "docs-lookup":    { tier: 1, edit: false, exec: true, desc: "MCP doc lookup" },
+  "harness-optimizer": { tier: 1, edit: false, exec: true, desc: "Harness config audit" },
+  "review-database":   { tier: 1, edit: false, exec: true, desc: "PostgreSQL review" },
+  "review-go":      { tier: 1, edit: false, exec: true, desc: "Go code review" },
+  "build-go":       { tier: 2, edit: true, exec: true, desc: "Go build fix" },
+  "review-java":    { tier: 1, edit: false, exec: true, desc: "Java review" },
+  "build-java":     { tier: 2, edit: true, exec: true, desc: "Java build fix" },
+  "review-kotlin":  { tier: 1, edit: false, exec: true, desc: "Kotlin review" },
+  "build-kotlin":   { tier: 2, edit: true, exec: true, desc: "Kotlin build fix" },
+  "review-cpp":     { tier: 1, edit: false, exec: true, desc: "C++ review" },
+  "build-cpp":      { tier: 2, edit: true, exec: true, desc: "C++ build fix" },
+  "review-rust":    { tier: 1, edit: false, exec: true, desc: "Rust review" },
+  "build-rust":     { tier: 2, edit: true, exec: true, desc: "Rust build fix" },
+  "review-python":  { tier: 1, edit: false, exec: true, desc: "Python review" },
+  "general":        { tier: 2, edit: true, exec: true, desc: "General purpose" },
+}
+
+// Suggest best agent for a task type.
+export function suggestAgent(taskType) {
+  const map = {
+    architecture: "architect",
+    plan: "planner",
+    "code-review": "code-reviewer",
+    security: "security-reviewer",
+    explore: "explore",
+    "build-fix": "build-error-resolver",
+    docs: "doc-updater",
+    "dead-code": "refactor-cleaner",
+    tdd: "tdd-guide",
+    e2e: "e2e-runner",
+    "doc-lookup": "docs-lookup",
+    "db-review": "review-database",
+    "go-review": "review-go",
+    "go-build": "build-go",
+    "java-review": "review-java",
+    "java-build": "build-java",
+    "kotlin-review": "review-kotlin",
+    "kotlin-build": "build-kotlin",
+    "cpp-review": "review-cpp",
+    "cpp-build": "build-cpp",
+    "rust-review": "review-rust",
+    "rust-build": "build-rust",
+    "python-review": "review-python",
+    loop: "loop-operator",
+    "harness-audit": "harness-optimizer",
+  }
+  return map[taskType] || null
+}
+
+// Quick permission check: can agent X do action Y?
+export function canAgent(agentName, action) {
+  const role = AGENT_ROLES[agentName]
+  if (!role) return false
+  if (action === "edit") return role.edit
+  if (action === "exec" || action === "bash") return role.exec
+  if (action === "read") return true
+  if (action === "delegate") return role.tier >= 1
+  return false
+}

package/lib/hardening.mjs

@@ -96,13 +96,8 @@ function atomicWriteJson(filePath, data) {
   try {
     fs.renameSync(tmpPath, filePath)
   } catch (err) {
-    try { if (fs.existsSync(filePath)) fs.rmSync(filePath, { force: true }) } catch {}
-    try {
-      fs.renameSync(tmpPath, filePath)
-    } catch (retryErr) {
-      try { fs.rmSync(tmpPath, { force: true }) } catch {}
-      throw retryErr
-    }
+    fs.copyFileSync(tmpPath, filePath)
+    fs.rmSync(tmpPath, { force: true })
   }
 }
 
@@ -120,4 +115,14 @@ function readJsonl(fp) {
   } catch { return [] }
 }
 
-export { atomicWriteJson, fingerprintEnvironment, fingerprintFile, isTruthy, readJson, readJsonl, redactSensitiveText, sanitizeRecord, truncateText }
+function buildEnvironmentFingerprint(root, directory, project) {
+  return fingerprintEnvironment({
+    cwd: directory,
+    harnessRoot: root,
+    projectRoot: directory,
+    project: project?.name || path.basename(directory),
+    sessionId: project?.session_id || null,
+  })
+}
+
+export { atomicWriteJson, buildEnvironmentFingerprint, fingerprintEnvironment, fingerprintFile, isPlainObject, isTruthy, readJson, readJsonl, redactSensitiveText, sanitizeRecord, truncateText }