openhermes 2.6.0 → 2.8.0

package/README.md

@@ -36,7 +36,7 @@ No Python. No Docker. No cron. No database. Just Node.js and your existing OpenC
 
 ---
 
-## Agent Handoff Protocol — New in v2.5
+## Agent Handoff Protocol
 
 The reason most agent sessions descend into chaos: every agent thinks it can do everything. OpenHermes fixes that with a **structured handoff system** baked into every subagent prompt.
 
@@ -259,17 +259,6 @@ openhermes/
 
 ---
 
-## Environment Variables
-
-Two knobs. That's it.
-
-| Variable | Default | Effect |
-|----------|---------|--------|
-| `OPENCODE_ALLOW_PROJECT_HARNESS` | `false` | Enable project-local harness at `.opencode/openhermes/` |
-| `OPENCODE_CURATOR_LOGS` | `false` | Pipe curator diagnostics to stderr for debugging |
-
----
-
 ## Why OpenHermes ≠ Hermes Agent
 
 Same messenger emoji. Entirely different mediums.

package/autorecall.mjs

@@ -186,7 +186,7 @@ async function loadMemoryAndWriteCache(projectKey, directory) {
   const backlogIndex = readJson(path.join(getMemoryRoot(), "backlog", "index.json"), [])
   if (Array.isArray(backlogIndex)) {
     memory.pendingSkillCandidates = backlogIndex.filter(e =>
-      e.status === "open" && (e.summary || "").includes("skill-candidate")
+      e.status === "open" && Array.isArray(e.tags) && e.tags.includes("skill-candidate")
     )
   }
 

package/bootstrap.mjs

@@ -67,11 +67,16 @@ export function resolveHarnessRoot({
   return path.resolve(currentDir, "harness")
 }
 
-const HARNESS_DIR = resolveHarnessRoot()
-const RULES_DIR = path.join(HARNESS_DIR, "rules")
-const SKILLS_DIR = path.join(HARNESS_DIR, "skills")
-const CONSTITUTION_FILE = path.join(HARNESS_DIR, "codex", "CONSTITUTION.md")
-const RUNTIME_FILE = path.join(HARNESS_DIR, "instructions", "RUNTIME.md")
+let _harnessDir
+export function setHarnessRootForTest(dir) { _harnessDir = dir }
+export function getHarnessDir() {
+  if (!_harnessDir) _harnessDir = resolveHarnessRoot()
+  return _harnessDir
+}
+function getRulesDir() { return path.join(getHarnessDir(), "rules") }
+function getSkillsDir() { return path.join(getHarnessDir(), "skills") }
+function getConstitutionFile() { return path.join(getHarnessDir(), "codex", "CONSTITUTION.md") }
+function getRuntimeFile() { return path.join(getHarnessDir(), "instructions", "RUNTIME.md") }
 
 
 function scanDirNames(dir) {
@@ -127,17 +132,17 @@ export function loadLocalSoulOverride(overridePath) {
 }
 
 function buildBootstrapContent() {
-  let constitution = fs.readFileSync(CONSTITUTION_FILE, "utf8")
+  let constitution = fs.readFileSync(getConstitutionFile(), "utf8")
   const localOverride = loadLocalSoulOverride()
   if (localOverride) {
     constitution += `\n\n## Local Overrides (survives reinstalls)\n\n${localOverride}`
   }
-  const runtime = fs.readFileSync(RUNTIME_FILE, "utf8")
-  const capMap = buildCapabilityMap(HARNESS_DIR)
+  const runtime = fs.readFileSync(getRuntimeFile(), "utf8")
+  const capMap = buildCapabilityMap(getHarnessDir())
 
   const router = `## AGENTS.md
 
-OpenHermes thin constitutional router. Full harness → \`${HARNESS_DIR}\\\`.
+OpenHermes thin constitutional router. Full harness → \`openhermes/harness/\`.
 
 ## Constitution
 
@@ -145,7 +150,7 @@ Pragmatic. Concise. Task-oriented. Subagent-first. Inspect, then act. Scope to t
 
 ## Safety
 
-Snapshot before mutation. Never delete unrelated files. Never assume \`%USERPROFILE%\\\\.config\\\\opencode\` is a git repo. Verify or roll back. **NEVER delete \`auth.json\`** (\`%USERPROFILE%\\\\.local\\\\share\\\\opencode\\\\auth.json\`).
+Snapshot before mutation. Never delete unrelated files. Never assume \`%USERPROFILE%\\.config\\opencode\` is a git repo. Verify or roll back. **NEVER delete \`auth.json\`** (\`%USERPROFILE%\\.local\\share\\opencode\\auth.json\`).
 
 ${capMap}
 
@@ -179,11 +184,11 @@ Main context = coordination + verification only. Substantive work → subagent.
 | Rust build fix | \`build-rust\` |
 | Any non-trivial multi-step | appropriate specialist |
 
-Never delegate trivial single-step ops. Subagent returns diff + summary + verification; inspect return only. Full ref: \`${RULES_DIR}\\\delegation.md\`.
+Never delegate trivial single-step ops. Subagent returns diff + summary + verification; inspect return only. Full ref: \`openhermes/harness/rules/delegation.md\`.
 
 ## Handoff Protocol
 
-Every agent knows its role, permissions, and when to delegate. Before delegating, assess task complexity (easy → direct, medium → single subagent, hard → sequential multi-agent, very-large → fan-out). Use structured handoff format documented in \`${RULES_DIR}\\\handoff.md\`.
+Every agent knows its role, permissions, and when to delegate. Before delegating, assess task complexity (easy → direct, medium → single subagent, hard → sequential multi-agent, very-large → fan-out). Use structured handoff format documented in \`openhermes/harness/rules/handoff.md\`.
 
 - **Act**: Task matches your role and permissions → do it directly
 - **Delegate**: Task outside your role → pass to correct agent via \`task\` tool
@@ -198,7 +203,7 @@ Every agent knows its role, permissions, and when to delegate. Before delegating
 - **Before close**: Query same-type mistakes (7 days). Match → \`code-reviewer\` or \`security-reviewer\`.
 - **On failure**: \`ohc_search\` for similar incidents. Search memory before asking user.
 - **Precision ladder**: \`ohc_latest\` → \`ohc_search\` → \`ohc_get\` → \`ohc_list\` (last resort). Full index reads only for explicit audit/repair tasks.
-- **Anti-spam**: No obvious facts, no one-off prefs, no temp state, no low-risk mistakes. Supersede, don't duplicate. Full rules: \`${RULES_DIR}\\\\retrieval.md\`, \`${RULES_DIR}\\\\memory-management.md\`.
+- **Anti-spam**: No obvious facts, no one-off prefs, no temp state, no low-risk mistakes. Supersede, don't duplicate. Full rules: \`openhermes/harness/rules/retrieval.md\`, \`openhermes/harness/rules/memory-management.md\`.
 
 ## Self-Edit Authority
 
@@ -206,44 +211,44 @@ Every agent knows its role, permissions, and when to delegate. Before delegating
 |------|-------------|----------------|
 | Memory entries, mistakes, checkpoints, receipts | openhermes docs/schemas/templates/non-core rules patches | AGENTS.md core, model routing, permissions, config, protected settings |
 
-Full tiers: \`${RULES_DIR}\\\\self-heal.md\`.
+Full tiers: \`openhermes/harness/rules/self-heal.md\`.
 
 ## Precedence
 
-1. User instruction. 2. Safety/legal/destructive guard. 3. Constitution (\`${HARNESS_DIR}\\\\codex\\\`). 4. Project constraints. 5. Project decisions. 6. Verified guards. 7. Checkpoints. 8. Instincts. 9. Freeform notes. Full: \`${RULES_DIR}\\\\precedence.md\`.
+1. User instruction. 2. Safety/legal/destructive guard. 3. Constitution (\`openhermes/harness/codex/\`). 4. Project constraints. 5. Project decisions. 6. Verified guards. 7. Checkpoints. 8. Instincts. 9. Freeform notes. Full: \`openhermes/harness/rules/precedence.md\`.
 
 ## Hygiene
 
 - Checkpoint on meaningful boundaries. Compress closed segments immediately.
 - After subagent return: verify → compress that block.
 - Compress proactively.
-- Skill candidates → \`/learn\` only if repeated pattern + \`ohc_search\` confirms no dup. See \`${RULES_DIR}\\\\skills-management.md\`.
-- Audit triggers: openhermes/config change, repeated failures, session start when last audit >7 days. See \`${RULES_DIR}\\\\audit.md\`.
+- Skill candidates → \`/learn\` only if repeated pattern + \`ohc_search\` confirms no dup. See \`openhermes/harness/rules/skills-management.md\`.
+- Audit triggers: openhermes/config change, repeated failures, session start when last audit >7 days. See \`openhermes/harness/rules/audit.md\`.
 
 ## Escalation
 
-T0: observe → log mistake → smallest fix. T1: add prevention rule → verify. T2: diagnosis/specialist → backlog. T3: constrained safe mode. Full: \`${RULES_DIR}\\\\self-heal.md\`.
+T0: observe → log mistake → smallest fix. T1: add prevention rule → verify. T2: diagnosis/specialist → backlog. T3: constrained safe mode. Full: \`openhermes/harness/rules/self-heal.md\`.
 
 ## State
 
-- **Config root**: \`%USERPROFILE%\\\\.config\\\\opencode\`
-- **Auth**: \`%USERPROFILE%\\\\.local\\\\share\\\\opencode\\\\auth.json\` (NEVER delete)
-- **Forensic ledger**: \`%USERPROFILE%\\\\.local\\\\share\\\\opencode\\\\opencode.db\``
+- **Config root**: \`%USERPROFILE%\\.config\\opencode\`
+- **Auth**: \`%USERPROFILE%\\.local\\share\\opencode\\auth.json\` (NEVER delete)
+- **Forensic ledger**: \`%USERPROFILE%\\.local\\share\\opencode\\opencode.db\``
 
   return [
-    `<OPENHERMES_BOOTSTRAP>\nOpenHermes v${getOwnVersion()} active. Harness: \`${HARNESS_DIR}\\\`. Memory at \`~/.local/share/opencode/openhermes/memory/\`. Rules at \`${RULES_DIR}\\\`. Skills discoverable via \`skill\` tool — use \`skill\` tool to list/load them.`,
+    `<OPENHERMES_BOOTSTRAP>\nOpenHermes v${getOwnVersion()} active. Harness: \`openhermes/harness/\`. Memory at \`~/.local/share/opencode/openhermes/memory/\`. Rules at \`openhermes/harness/rules/\`. Skills discoverable via \`skill\` tool — use \`skill\` tool to list/load them.`,
     `<OPENHERMES_CONSTITUTION>\n${constitution}\n</OPENHERMES_CONSTITUTION>`,
     `<OPENHERMES_RUNTIME>\n${runtime}\n</OPENHERMES_RUNTIME>`,
     `<OPENHERMES_ROUTER>\n${router}\n</OPENHERMES_ROUTER>`
   ].join("\n\n")
 }
 
-function getOwnVersion() {
+const OWN_VERSION = (() => {
   try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))
-    return pkg.version || "1.0.0"
+    return JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8")).version || "1.0.0"
   } catch { return "1.0.0" }
-}
+})()
+function getOwnVersion() { return OWN_VERSION }
 
 export const BootstrapPlugin = async ({ client, directory }) => {
   let _bootstrapCache
@@ -263,14 +268,22 @@ export const BootstrapPlugin = async ({ client, directory }) => {
     config: async (config) => {
       config.skills = config.skills || {}
       config.skills.paths = config.skills.paths || []
-      if (!config.skills.paths.includes(SKILLS_DIR)) {
-        config.skills.paths.push(SKILLS_DIR)
+      if (!config.skills.paths.includes(getSkillsDir())) {
+        config.skills.paths.push(getSkillsDir())
       }
 
-      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 PROMPTS_DIR = path.join(getHarnessDir(), "prompts")
+      const COMMANDS_DIR = path.join(getHarnessDir(), "commands")
+      const ct = (file) => {
+        const fp = path.join(COMMANDS_DIR, file)
+        try { return fs.readFileSync(fp, "utf8").trimEnd() + "\n\n$ARGUMENTS" }
+        catch { return "$ARGUMENTS" }
+      }
+      const p = (name) => {
+        const fp = path.join(PROMPTS_DIR, name)
+        try { return fs.readFileSync(fp, "utf8").trimEnd() }
+        catch { return "" }
+      }
 
       const existingCommands = config.command ?? {}
       const existingAgents = { ...(config.agent ?? {}) }

package/curator.mjs

@@ -14,6 +14,28 @@ const lastCheckpoint = { ts: 0 }
 const writtenThisSession = []
 const CURATOR_LOGS = /^(1|true|yes)$/i.test(process.env.OPENCODE_CURATOR_LOGS || "")
 
+const MEMORY_CLASSES = ["checkpoints", "mistakes", "audits", "verification_receipts", "constraints", "decisions", "instincts", "backlog"]
+
+function ensureConsistency(root) {
+  const memoryRoot = path.join(root, "memory")
+  const runtimeRoot = path.join(root, "runtime")
+
+  for (const cls of MEMORY_CLASSES) {
+    const dir = path.join(memoryRoot, cls)
+    fs.mkdirSync(dir, { recursive: true })
+    const indexPath = path.join(dir, "index.json")
+    if (!fs.existsSync(indexPath)) {
+      atomicWriteJson(indexPath, [])
+    }
+  }
+
+  fs.mkdirSync(runtimeRoot, { recursive: true })
+  const loopStatePath = path.join(runtimeRoot, "loop-state.json")
+  if (!fs.existsSync(loopStatePath)) {
+    atomicWriteJson(loopStatePath, { status: "idle", phase: "session.created" })
+  }
+}
+
 function curatorLog(message) {
   if (!CURATOR_LOGS) return
   process.stderr.write(`${message}\n`)
@@ -70,7 +92,7 @@ function loadSchema(classId) {
 function validateRecordAgainstSchema(record) {
   const schema = loadSchema(record.class)
   if (!schema) {
-    curatorLog(`[curator] no schema found for class "${record.class}", fallback check`)
+    curatorLog(`[curator] validation fallback: no schema for "${record.class}"`)
     const required = record.class === "checkpoint"
       ? ["id", "class", "summary", "mission", "current_state", "next_actions", "blockers", "risk_notes", "provenance", "created_at", "status"]
       : ["id", "class", "summary", "provenance", "created_at", "status"]
@@ -80,19 +102,19 @@ function validateRecordAgainstSchema(record) {
       return false
     }
     if (record.class === "checkpoint" && record.provenance && !record.provenance.session_id) {
-      curatorLog(`[curator] validation failed: provenance.session_id required`)
+      curatorLog(`[curator] validation failed: missing session_id`)
       return false
     }
     return true
   }
   const unsupported = findUnsupportedSchemaKeywords(schema)
   if (unsupported.length) {
-    curatorLog(`[curator] schema validation failed: unsupported keywords ${unsupported.join(", ")}`)
+    curatorLog(`[curator] validation failed: unsupported fields ${unsupported.join(", ")}`)
     return false
   }
   const errors = validateSchema(schema, record, "$")
   if (errors.length) {
-    curatorLog(`[curator] schema validation failed: ${errors.join("; ")}`)
+    curatorLog(`[curator] validation failed: ${errors.join("; ")}`)
     return false
   }
   if (record.class === "checkpoint") {
@@ -164,7 +186,6 @@ async function writeCheckpoint(root, project, directory, trigger, summary, optio
   const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
   if (!validateRecordAgainstSchema(safeRecord)) return null
   const dir = path.join(root, "memory", "checkpoints")
-  fs.mkdirSync(dir, { recursive: true })
   atomicWriteJson(path.join(dir, `${id}.json`), safeRecord)
   indexEntry(root, "checkpoints", safeRecord)
   updateLoopState(root, {
@@ -174,6 +195,7 @@ async function writeCheckpoint(root, project, directory, trigger, summary, optio
     updated_at: ts,
     status: trigger === "experimental.session.compacting" ? "active" : "idle",
   })
+  if (writtenThisSession.length >= 100) writtenThisSession.shift()
   writtenThisSession.push(id)
   curatorLog(`[curator] checkpoint written: ${id} (trigger: ${trigger})`)
   return id
@@ -261,7 +283,6 @@ function writeVerificationReceipt(root, project, directory, checkpointId) {
     environment_fingerprint: environmentFingerprint,
   }
   const dir = path.join(root, "memory", "verification_receipts")
-  fs.mkdirSync(dir, { recursive: true })
   const safeRecord = sanitizeRecord(record, { maxStringLength: 4000 })
   atomicWriteJson(path.join(dir, `${id}.json`), safeRecord)
   indexEntry(root, "verification_receipts", safeRecord)
@@ -369,7 +390,6 @@ async function handlePermissionReplied(directory, project, event) {
       }
     }
     const dir = path.join(root, "memory", "audits")
-    fs.mkdirSync(dir, { recursive: true })
     atomicWriteJson(path.join(dir, `${id}.json`), safeRecord)
     indexEntry(root, "audits", safeRecord)
     curatorLog(`[curator] permission audit logged: ${event.tool} -> ${event.action}`)
@@ -382,9 +402,16 @@ export const CuratorPlugin = async ({ project, directory }) => {
   return {
     event: async ({ event }) => {
       // A1: v1 migration owned by autorecall.mjs — removed to avoid race
-      if (event.type === "session.created") {
-        lastCheckpoint.ts = 0
-        writtenThisSession.length = 0
+      if (event.type === "session.created") {
+        lastCheckpoint.ts = 0
+        writtenThisSession.length = 0
+        try {
+          const root = getDataRoot()
+          ensureConsistency(root)
+          curatorLog("[curator] consistency repair: all memory/runtime dirs verified")
+        } catch (err) {
+          curatorLog(`[curator] consistency repair failure: ${safeLogMessage(err.message)}`)
+        }
       }
       if (event.type === "session.idle") {
         await handleSessionIdle(directory, project)

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",
+    "harness_root": "%USERPROFILE%\\.config\\opencode",
     "project_root": "C:/path/to/project",
     "project": "my-project",
     "session_id": "session-123",

package/index.mjs

@@ -25,7 +25,9 @@ export default async (input) => {
     OhcPlugin(input),
     UpdaterPlugin(input),
   ])
-  const [bootstrap, autorecall, curator, skillBuilder, memoryTools, ambient, ohc, updater] = results.map(r => r.status === 'fulfilled' ? r.value : {})
+  const pluginNames = ["Bootstrap", "Autorecall", "Curator", "SkillBuilder", "MemoryTools", "AmbientMemory", "Ohc", "Updater"]
+  results.forEach((r, i) => { if (r.status === "rejected") console.error(`[openhermes] ${pluginNames[i]} plugin failed:`, r.reason) })
+  const [bootstrap, autorecall, curator, skillBuilder, memoryTools, ambient, ohc, updater] = results.map(r => r.status === "fulfilled" ? r.value : {})
 
   const merged = {}
 

package/lib/handoff.mjs

@@ -2,11 +2,6 @@
 // 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++

package/lib/hardening.mjs

@@ -3,10 +3,11 @@ import fs from "node:fs"
 import os from "node:os"
 import path from "node:path"
 
-const SECRET_KEY_PATTERN = /(token|secret|password|passwd|passphrase|api[-_ ]?key|access[-_ ]?key|refresh[-_ ]?token|authorization|cookie|bearer)/i
+const SECRET_KEY_PATTERN = /(token|secret|password|passwd|passphrase|pwd|credential|auth|api[-_ ]?key|access[-_ ]?key|refresh[-_ ]?token|authorization|cookie|bearer)/i
 const TEXT_REDACTIONS = [
   [/\bsk-[A-Za-z0-9]{16,}\b/g, "[REDACTED]"],
   [/\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g, "[REDACTED]"],
+  [/\bgithub_pat_[A-Za-z0-9_]+\b/g, "[REDACTED]"],
   [/\bxox[baprs]-[A-Za-z0-9-]+\b/g, "[REDACTED]"],
   [/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}\b/gi, "Bearer [REDACTED]"],
   [/\b[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b/g, "[REDACTED]"],
@@ -111,7 +112,11 @@ function readJson(fp, fallback) {
 
 function readJsonl(fp) {
   try {
-    return fs.readFileSync(fp, "utf8").trim().split("\n").filter(Boolean).map(l => JSON.parse(l))
+    const results = []
+    for (const l of fs.readFileSync(fp, "utf8").trim().split("\n").filter(Boolean)) {
+      try { results.push(JSON.parse(l)) } catch {}
+    }
+    return results
   } catch { return [] }
 }
 
@@ -125,4 +130,17 @@ function buildEnvironmentFingerprint(root, directory, project) {
   })
 }
 
-export { atomicWriteJson, buildEnvironmentFingerprint, fingerprintEnvironment, fingerprintFile, isPlainObject, isTruthy, readJson, readJsonl, redactSensitiveText, sanitizeRecord, truncateText }
+function toDisplayPath(absPath) {
+  if (!absPath) return ''
+  const normalized = absPath.replace(/\\/g, '/')
+  const idx = normalized.lastIndexOf('/openhermes/')
+  if (idx !== -1) return 'openhermes' + normalized.slice(idx + 11)
+  const parts = normalized.split('/').filter(Boolean)
+  return parts.slice(-2).join('/')
+}
+
+function branded(prefix, message) {
+  return `OpenHermes${prefix ? ` ${prefix}` : ''}: ${message}`
+}
+
+export { atomicWriteJson, branded, buildEnvironmentFingerprint, fingerprintEnvironment, fingerprintFile, isPlainObject, isTruthy, readJson, readJsonl, redactSensitiveText, sanitizeRecord, toDisplayPath, truncateText }

package/lib/memory-tools-plugin.mjs

@@ -37,6 +37,11 @@ function buildEntry(cls, r) {
   const e = { id: r.id, summary: r.summary, status: r.status, updated_at: r.updated_at ?? r.created_at, path: path.join("openhermes", "memory", PLURALS[cls], `${r.id}.json`), scope: r.scope ?? null, project: r.project ?? null }
   if (cls === "audit") { e.target = r.target; e.overall_score = r.overall_score }
   if (cls === "backlog") { e.priority = r.priority; e.trigger = r.trigger }
+  if (cls === "decision") { e.choice = r.choice; e.reason = r.reason }
+  if (cls === "constraint") { e.description = r.description }
+  if (cls === "instinct") { e.source = r.source }
+  if (cls === "checkpoint") { e.mission = r.mission }
+  if (cls === "verification_receipt") { e.artifact = r.artifact; e.result = r.result }
   return e
 }
 
@@ -58,6 +63,7 @@ function sortRecent(entries) {
 
 function filterActive(entries) { return entries.filter(e => !hasExpired(e)) }
 
+// CAUTION: read-modify-write — safe within single session; concurrent sessions may race
 function writeObject(cls, record) {
   const dir = classDir(cls)
   fs.mkdirSync(dir, { recursive: true })
@@ -80,7 +86,9 @@ function upsertMistake(record) {
   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")
-  fs.writeFileSync(fp, text ? `${text}\n` : "", "utf8")
+  const tmp = fp + ".tmp"
+  fs.writeFileSync(tmp, text ? `${text}\n` : "", "utf8")
+  fs.renameSync(tmp, fp)
 }
 
 function queryList(cls, limit = 10) {
@@ -174,10 +182,6 @@ function handleAdd(cls, id, dataStr) {
         if (!prov.file_refs.some(r => typeof r === "string" && r.trim())) prov.file_refs.push("auto-filled")
       }
     }
-    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: ${unsupported.join(", ")}`
@@ -211,7 +215,7 @@ function handleLatest(cls) {
   const list = queryList(cls, 100)
   const active = filterActive(list)
   if (!active[0]?.id) return "no active records"
-  const record = queryGet(cls, active[0].id)
+  const record = cls === "mistake" ? active[0] : queryGet(cls, active[0].id)
   if (!record) return "no active records"
   return stableStringify(record)
 }
@@ -246,13 +250,12 @@ function handleSearch(query, scope, classes, project, limit) {
     .sort((a, b) => b.score - a.score)
     .slice(0, lim)
   
-  // Fetch full records for top results to get richer fields
   const results = scored.map(e => {
     if (e._cls === "mistake") return e
     const full = queryGet(e._cls, e.id)
-    return full || e
+    return full ? { ...full, score: e.score } : e
   })
-  
+
   const lines = results.map(e => `  ${e.id} (${e.score}pt): ${truncateText(e.summary || "", 80)}`)
   return `${results.length} result${results.length === 1 ? "" : "s"} for '${q}'\n` + lines.join("\n")
 }

package/lib/ohc/compress/state.mjs

@@ -13,7 +13,7 @@ export function allocateRunId(state) {
 }
 
 export function wrapBlockSummary(blockId, summary) {
-  return `[OHC: Compressed bk${blockId}]\n\n${summary}\n<ohc-ref>bk${blockId}</ohc-ref>`
+  return `[Compressed bk${blockId}]\n\n${summary}\n<ohc-ref>bk${blockId}</ohc-ref>`
 }
 
 export function applyCompressionState(state, input, selection, anchorMessageId, blockId, storedSummary, consumedBlockIds) {
@@ -33,7 +33,7 @@ export function applyCompressionState(state, input, selection, anchorMessageId,
     endId: input.endId,
     summary: storedSummary,
     summaryTokens: input.summaryTokens || 0,
-    compressedTokens: 0,
+    compressedTokens: input.compressedTokens || 0,
     consumedBlockIds: Array.isArray(consumedBlockIds) ? consumedBlockIds : [],
     deactivatedByBlockId: undefined,
     deactivatedByUser: false,

package/lib/ohc/config.mjs

@@ -16,8 +16,7 @@ const DEFAULTS = {
   turnProtection: { enabled: false, turns: 4 },
   protectedFilePatterns: [],
   compress: {
-    maxContextLimit: 150000,
-    minContextLimit: 50000,
+
     nudgeFrequency: 5,
     iterationNudgeThreshold: 15,
     nudgeForce: "soft",
@@ -99,8 +98,6 @@ function mergeTurnProtection(base, override) {
 function mergeCompress(base, override) {
   if (!override || typeof override !== "object") return base
   return {
-    maxContextLimit: override.maxContextLimit ?? base.maxContextLimit,
-    minContextLimit: override.minContextLimit ?? base.minContextLimit,
     nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
     iterationNudgeThreshold: override.iterationNudgeThreshold ?? base.iterationNudgeThreshold,
     nudgeForce: override.nudgeForce ?? base.nudgeForce,
@@ -175,6 +172,8 @@ export function loadConfig(ctx) {
   config.max = typeof config.max === "number" && config.max > 0 ? config.max : DEFAULTS.max
   config.min = typeof config.min === "number" ? Math.max(10000, Math.min(config.min, config.max - 10000)) : DEFAULTS.min
 
+  try { writeDefaults() } catch { /* best-effort */ }
+
   return config
 }
 

package/lib/ohc/message-ids.mjs

@@ -114,6 +114,16 @@ function allocateNextRef(state) {
   return formatMessageRef(1)
 }
 
+export function cleanupMessageRefs(state, removedRawIds) {
+  for (const rawId of removedRawIds) {
+    const ref = state.messageIds.byRawId.get(rawId)
+    if (ref) {
+      state.messageIds.byRawId.delete(rawId)
+      state.messageIds.byRef.delete(ref)
+    }
+  }
+}
+
 export function injectMessageIds(state, messages) {
   for (const msg of messages) {
     if (isIgnoredUserMessage(msg)) continue

package/lib/ohc/notify.mjs

@@ -1,56 +1,50 @@
 function formatTokenCount(tokens) {
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`.replace(".0M", "M")
   if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K")
   return String(tokens)
 }
 
-function buildProgressBar(prunedCount, visibleCount, width) {
-  width = width || 30
-  const total = prunedCount + visibleCount
-  if (total === 0) return `\u2502${"\u2591".repeat(width)}\u2502  0% active`
-  const activeRatio = visibleCount / total
-  const activeW = Math.round(activeRatio * width)
-  const prunedW = width - activeW
-  const bar = "\u2588".repeat(Math.min(activeW, width)) + "\u2591".repeat(Math.min(prunedW, width))
-  return `\u2502${bar.slice(0, width)}\u2502  ${Math.round(activeRatio * 100)}% active`
+function truncate(str, max) {
+  if (!str) return ""
+  return str.length > max ? str.slice(0, max) + "\u2026" : str
 }
 
-function buildMinimal(count, tokensRemoved, savedTotal, blockCount) {
-  const label = "Compression"
-  return `\u25A3 OHC | ~${formatTokenCount(savedTotal)} saved total \u2014 ${label}`
+function buildCompressionDetailed(count, savedTotal, blockCount, summary) {
+  const parts = [
+    `${formatTokenCount(savedTotal)} saved \u00b7 ${count} msg${count === 1 ? "" : "s"} removed \u00b7 #${blockCount} block${blockCount === 1 ? "" : "s"}`,
+  ]
+  if (summary) parts.push(truncate(summary, 48))
+  return parts.join("\n")
 }
 
-function buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary) {
-  const label = "Compression"
-  let msg = `\u25A3 OHC | ~${formatTokenCount(savedTotal)} saved total`
-  if (prunedCount + visibleCount > 0) {
-    msg += `\n\n${buildProgressBar(prunedCount, visibleCount)}`
-  }
-  msg += `\n\n\u25A3 ${label} #${blockCount}`
-  msg += `\n\u2192 ${count} message${count === 1 ? "" : "s"} removed`
-  if (summary) msg += `\n\u2192 Summary: ${summary}`
-  return msg
+function buildCompressionMinimal(count, savedTotal, blockCount) {
+  return `${formatTokenCount(savedTotal)} saved \u00b7 ${blockCount} block${blockCount === 1 ? "" : "s"} \u00b7 ${count} msg${count === 1 ? "" : "s"} removed`
 }
 
-function buildStrategyNotification(strategy, count, detail) {
-  return `\u25A3 OHC | ${strategy}: ${count} pruned${detail ? ` (${detail})` : ""}`
+function buildMemoryMessage(action, cls, id, summary) {
+  const idPart = id ? truncate(id, 28) : ""
+  return [action, cls, idPart].filter(Boolean).join(" \u00b7 ")
 }
 
-export async function sendCompressNotification(client, sessionId, config, count, summary, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount) {
+export async function sendCompressNotification(client, sessionId, config, count, summary, tokensRemoved, ss, currentMessageCount) {
   if (count === 0) return false
 
-  const notifType = config.notification ?? "toast"
-  const notifMode = config.notificationMode ?? "minimal"
+  const savedTotal = ss?.totalTokensSaved || 0
+  const blockCount = ss?.blockCount || 0
+
+  const notifType = config.notification ?? "chat"
+  const notifMode = config.notificationMode ?? "detailed"
 
   if (notifType === "off") return false
 
   if (notifType === "toast") {
     const message = notifMode === "minimal"
-      ? buildMinimal(count, tokensRemoved, savedTotal, blockCount)
-      : buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary)
+      ? buildCompressionMinimal(count, savedTotal, blockCount)
+      : buildCompressionDetailed(count, savedTotal, blockCount, summary)
     try {
       await client.tui.showToast({
         body: {
-          title: "OHC: Compression",
+          title: "OHC Compression",
           message,
           variant: "info",
           duration: 5000,
@@ -60,12 +54,15 @@ export async function sendCompressNotification(client, sessionId, config, count,
     return true
   }
 
+  const message = notifMode === "minimal"
+    ? buildCompressionMinimal(count, savedTotal, blockCount)
+    : buildCompressionDetailed(count, savedTotal, blockCount, summary)
   try {
     await client.session.prompt({
       path: { id: sessionId },
       body: {
         noReply: true,
-        parts: [{ type: "text", text: buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary), ignored: true }],
+        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
       },
     })
   } catch {}
@@ -74,16 +71,16 @@ export async function sendCompressNotification(client, sessionId, config, count,
 
 export async function sendStrategyNotification(client, sessionId, config, strategy, count, detail) {
   if (count === 0) return false
-  const notifType = config.notification ?? "toast"
+  const notifType = config.notification ?? "chat"
   if (notifType === "off") return false
 
-  const message = buildStrategyNotification(strategy, count, detail)
+  const message = detail ? `${strategy} \u2014 ${count} pruned \u00b7 ${truncate(detail, 36)}` : `${strategy} \u2014 ${count} pruned`
 
   if (notifType === "toast") {
     try {
       await client.tui.showToast({
         body: {
-          title: `OHC: ${strategy}`,
+          title: "OHC Strategy",
           message,
           variant: "info",
           duration: 3000,
@@ -98,7 +95,7 @@ export async function sendStrategyNotification(client, sessionId, config, strate
       path: { id: sessionId },
       body: {
         noReply: true,
-        parts: [{ type: "text", text: message, ignored: true }],
+        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
       },
     })
   } catch {}
@@ -107,27 +104,15 @@ export async function sendStrategyNotification(client, sessionId, config, strate
 
 export async function sendMemoryNotification(client, sessionId, config, action, cls, id, summary) {
   const notifType = config.notification ?? "toast"
-  const notifMode = config.notificationMode ?? "minimal"
-
   if (notifType === "off") return false
 
-  const buildHeader = (action, summary) => `[Memory] ${summary}`
-  const buildDetailed = (action, cls, id, summary) => {
-    let msg = `\u25A3 Memory ${action}`
-    if (cls) msg += `\n\u2192 Class: ${cls}`
-    if (id) msg += `\n\u2192 ID: ${id}`
-    if (summary) msg += `\n\u2192 ${summary}`
-    return msg
-  }
+  const message = buildMemoryMessage(action, cls, id, summary)
 
   if (notifType === "toast") {
-    const message = notifMode === "minimal"
-      ? buildHeader(action, summary)
-      : buildDetailed(action, cls, id, summary)
     try {
       await client.tui.showToast({
         body: {
-          title: "Memory",
+          title: "OHC Memory",
           message,
           variant: "info",
           duration: 4000,
@@ -142,7 +127,7 @@ export async function sendMemoryNotification(client, sessionId, config, action,
       path: { id: sessionId },
       body: {
         noReply: true,
-        parts: [{ type: "text", text: buildDetailed(action, cls, id, summary), ignored: true }],
+        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
       },
     })
   } catch {}

package/lib/ohc/protected-patterns.mjs

@@ -1,7 +1,7 @@
 const DEFAULT_PROTECTED_TOOLS = new Set([
   "task", "skill", "todowrite", "todoread",
   "compress", "batch", "plan_enter", "plan_exit",
-  "write", "edit",
+  "write", "edit", "bash", "webfetch",
 ])
 
 export function isToolNameProtected(toolName, extraProtected = []) {
@@ -34,7 +34,8 @@ export function isFilePathProtected(filePaths, protectedPatterns = []) {
 function globMatch(filePath, pattern) {
   const regexStr = pattern
     .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*/g, ".*")
+    .replace(/\*\*/g, ".*")
+    .replace(/\*/g, "[^/]*")
     .replace(/\?/g, ".")
   try {
     return new RegExp(`^${regexStr}$`, "i").test(filePath)

package/lib/ohc/pruner.mjs

@@ -1,6 +1,6 @@
 import { tool } from "@opencode-ai/plugin"
 import { loadConfig } from "./config.mjs"
-import { selectMessagesToReap, totalTokens } from "./reaper.mjs"
+import { selectMessagesToReap, totalTokens, msgTokens } from "./reaper.mjs"
 import {
   loadOhcState, saveOhcState, createSessionState,
   serializeState, deserializeState,
@@ -8,8 +8,8 @@ import {
 } from "./state.mjs"
 import { sendCompressNotification } from "./notify.mjs"
 import { deduplicate, purgeErrors } from "./strategies/index.mjs"
-import { applyPruneTools, filterCompressedBlocks } from "./prune-apply.mjs"
-import { assignMessageRefs, injectMessageIds } from "./message-ids.mjs"
+import { applyPruneTools, filterCompressedBlocks, applyFullToolRemoval } from "./prune-apply.mjs"
+import { assignMessageRefs, injectMessageIds, cleanupMessageRefs } from "./message-ids.mjs"
 import { syncCompressionBlocks } from "./block-sync.mjs"
 import { buildSearchContext, resolveBoundaryIds, resolveSelection, resolveAnchorMessageId, validateNonOverlapping } from "./compress/search.mjs"
 import { allocateBlockId, allocateRunId, wrapBlockSummary, applyCompressionState } from "./compress/state.mjs"
@@ -38,16 +38,16 @@ function getSessionId(messages) {
 }
 
 function buildNudge(pct, max) {
-  if (pct > 0.95) return `[OHC] Context critically high (${Math.round(pct * 100)}% of ${max.toLocaleString()} token budget). Oldest messages will be pruned immediately if limit exceeded. Use the \`compress\` tool now.`
-  if (pct > 0.85) return `[OHC] Context at ${Math.round(pct * 100)}%. Proactive compression recommended. Run \`compress\` to free space.`
-  if (pct > 0.70) return `[OHC] Context at ${Math.round(pct * 100)}% of budget. Consider using \`compress\` to keep room for new content.`
+  if (pct > 0.95) return `OHC: Context is nearly full \u2014 use \`compress\` now.`
+  if (pct > 0.85) return `OHC: Context usage is high. Run \`compress\` to free space.`
+  if (pct > 0.70) return `OHC: Context is growing. Consider \`compress\` to keep room.`
   return null
 }
 
 function summarizeRemoved(selected, summary) {
   const n = selected.length
-  if (summary) return `[Compressed: ${summary} — ${n} message${n === 1 ? "" : "s"} removed]`
-  return `[Auto-pruned: ${n} message${n === 1 ? "" : "s"} removed]`
+  if (summary) return `[OHC: Compressed] ${summary} \u2014 ${n} message${n === 1 ? "" : "s"} removed`
+  return `[OHC: Auto-pruned] ${n} message${n === 1 ? "" : "s"} removed`
 }
 
 function createSummaryMessage(text) {
@@ -75,7 +75,6 @@ async function applyCompress(ctx, sessionId, summary, max, min, targetTokens) {
     for (const r of selected) ss.prunedIds.add(r.id)
     ss.summary = summarizeRemoved(selected, summary)
     ss.anchorMessageId = selected[0].id
-    saveOhcState(sessionId, serializeState(ss))
   }
 
   const tokensRemoved = selected.reduce((s, r) => s + r.tokens, 0)
@@ -84,6 +83,8 @@ async function applyCompress(ctx, sessionId, summary, max, min, targetTokens) {
   if (ss) {
     ss.blockCount++
     ss.totalTokensSaved += tokensRemoved
+    ss.totalMessagesRemoved += selected.length
+    saveOhcState(sessionId, serializeState(ss))
   }
   return { removed: selected.length, afterTotal, tokensRemoved, beforeTotal, beforeCount: msgs.length, afterCount: msgs.length - selected.length }
 }
@@ -98,7 +99,7 @@ function estimateSummaryTokens(messages) {
   for (const m of messages) {
     if (m.info?.role === "system" && Array.isArray(m.parts)) {
       for (const p of m.parts) {
-        if (p.type === "text" && p.text?.startsWith("[Compressed:") || p.text?.startsWith("[Auto-pruned:")) {
+        if (p.type === "text" && (p.text?.startsWith("[OHC: Compressed]") || p.text?.startsWith("[OHC: Auto-pruned]"))) {
           total += Math.ceil(p.text.length / 4)
         }
       }
@@ -133,12 +134,21 @@ async function executeRangeCompress(ctx, sessionId, callId, topic, content) {
 
   const runId = allocateRunId(ss)
   const notifications = []
+  let totalActualTokensRemoved = 0
+  const allMessageIds = []
 
   for (const plan of plans) {
     const blockId = allocateBlockId(ss)
     const storedSummary = wrapBlockSummary(blockId, plan.entry.summary)
     const summaryTokens = Math.ceil(storedSummary.length / 4)
 
+    const actualTokensRemoved = plan.selection.messageIds.reduce((sum, mid) => {
+      const msg = searchContext.rawMessagesById.get(mid)
+      return msg ? sum + msgTokens(msg) : sum
+    }, 0)
+    totalActualTokensRemoved += actualTokensRemoved
+    allMessageIds.push(...plan.selection.messageIds)
+
     applyCompressionState(
       ss,
       {
@@ -151,6 +161,7 @@ async function executeRangeCompress(ctx, sessionId, callId, topic, content) {
         compressMessageId: plan.selection.messageIds[0],
         compressCallId: callId,
         summaryTokens,
+        compressedTokens: actualTokensRemoved,
       },
       plan.selection,
       plan.anchorMessageId,
@@ -160,7 +171,8 @@ async function executeRangeCompress(ctx, sessionId, callId, topic, content) {
     )
 
     ss.blockCount++
-    ss.totalTokensSaved += summaryTokens
+    ss.totalTokensSaved += actualTokensRemoved
+    ss.totalMessagesRemoved += plan.selection.messageIds.length
 
     notifications.push({
       blockId,
@@ -170,11 +182,14 @@ async function executeRangeCompress(ctx, sessionId, callId, topic, content) {
     })
   }
 
+  saveOhcState(sessionId, serializeState(ss))
+
   return {
-    messageIds: plans.flatMap(p => p.selection.messageIds),
-    compressedTokens: 0,
+    messageIds: allMessageIds,
+    compressedTokens: totalActualTokensRemoved,
     summaryRef: content[0]?.summary || topic,
     blockCount: plans.length,
+    afterCount: rawMessages.length - allMessageIds.length,
   }
 }
 
@@ -194,7 +209,7 @@ export const OhcPlugin = async (ctx) => {
     const total = ss.compressionTiming.totalDurationMs || 0
     const lastSec = (last / 1000).toFixed(1)
     const totalSec = (total / 1000).toFixed(1)
-    return `, last compress ${lastSec}s, total ${totalSec}s`
+    return ` (last: ${lastSec}s, total: ${totalSec}s)`
   }
 
   function computeRoleBreakdown(messages) {
@@ -233,11 +248,7 @@ export const OhcPlugin = async (ctx) => {
     "experimental.chat.system.transform": async (_input, output) => {
       if (systemInjected || !output.system?.length) return
       systemInjected = true
-      const summaryBufNote = config.compress?.summaryBuffer ? ` Summary messages extend the budget.` : ``
-      const protectedToolsList = (config.compress?.protectedTools || []).length
-        ? ` Protected tools (${(config.compress.protectedTools).join(", ")}) are preserved.`
-        : ``
-      output.system[output.system.length - 1] += `\n\n## OHC Context Management\n- OHC manages all compression. Set \`compaction.auto: false\` in opencode.json.\n- Default budget: ${max.toLocaleString()} tokens. Floor: ${min.toLocaleString()}.${summaryBufNote}${protectedToolsList}\n\n### Compress Tool\nUse \`compress\` to free context space. Two modes:\n- **Legacy**: \`{ summary }\` — oldest messages first\n- **Range**: \`{ topic, content: [{startId, endId, summary}] }\` — target specific ranges\n  - \`startId\` / \`endId\`: \`ohcNNNN\` (message) or \`bkNN\` (block)\n  - Each message in context has an \`<ohc-ref>\` tag with its ID\n  - Ranges must be non-overlapping in one call\n  - Summary replaces the entire range`
+      output.system[output.system.length - 1] += `\n\n## Context Management\nOpenHermes manages context compression automatically. Set \`compaction.auto: false\` in opencode.json to disable.\n\n### Compress Tool\nUse \`compress\` to free context space. Two modes:\n- **Summary mode**: \`{ summary }\` — compresses oldest messages first\n- **Range mode**: \`{ topic, content: [{startId, endId, summary}] }\` — targets specific conversation ranges\n  - \`startId\` / \`endId\`: \`ohcNNNN\` (message ref) or \`bkNN\` (block ref)\n  - Ranges must not overlap within one call`
     },
 
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -261,6 +272,7 @@ export const OhcPlugin = async (ctx) => {
       deduplicate(ss, config, output.messages)
       purgeErrors(ss, config, output.messages)
       applyPruneTools(ss, output.messages)
+      applyFullToolRemoval(ss, output.messages)
 
       const now = Date.now()
       const recentlyPruned = ss.lastAutoPruneAt && (now - ss.lastAutoPruneAt) < AUTOPRUNE_COOLDOWN
@@ -268,6 +280,7 @@ export const OhcPlugin = async (ctx) => {
       if (ss.prunedIds.size > 0 && !recentlyPruned) {
         const currentIds = new Set(output.messages.map(m => m.info?.id).filter(Boolean))
         if ([...ss.prunedIds].every(id => !currentIds.has(id))) {
+          cleanupMessageRefs(ss, ss.prunedIds)
           ss.prunedIds.clear()
           ss.summary = null
           ss.anchorMessageId = null
@@ -283,10 +296,11 @@ export const OhcPlugin = async (ctx) => {
           for (const r of selected) ss.prunedIds.add(r.id)
           if (!ss.summary) ss.summary = summarizeRemoved(selected, null)
           if (!ss.anchorMessageId) ss.anchorMessageId = selected[0].id
-          saveOhcState(sessionId, serializeState(ss))
           const tokensRemoved = selected.reduce((s, r) => s + r.tokens, 0)
           ss.blockCount++
           ss.totalTokensSaved += tokensRemoved
+          ss.totalMessagesRemoved += selected.length
+          saveOhcState(sessionId, serializeState(ss))
           ss.lastAutoPruneAt = now
           ss._pruneCycleDone = true
         }
@@ -342,7 +356,7 @@ export const OhcPlugin = async (ctx) => {
       const iterationThreshold = config.compress?.iterationNudgeThreshold ?? 15
       const iterCount = countIterationsSinceLastUser(output.messages)
       if (iterCount >= iterationThreshold && iterCount % 5 === 0) {
-        const iterNudge = `[OHC] ${iterCount} AI iterations since your last message. Consider summarizing completed work with \`compress\`.`
+        const iterNudge = `OHC: ${iterCount} AI turns since your last input. Summarize with \`compress\`.`
         if (nudgeText) nudgeText += "\n\n" + iterNudge
         else nudgeText = iterNudge
       }
@@ -415,8 +429,12 @@ export const OhcPlugin = async (ctx) => {
         const strategyPruned = ss?.prune?.tools?.size || 0
         const timing = buildTimingStr(ss)
         const activeBlockIds = [...(ss?.prune?.messages?.activeBlockIds || [])].filter(id => Number.isInteger(id)).sort((a, b) => a - b)
-        const blockLine = activeBlockIds.length ? ` Blocks: bk${activeBlockIds.join(", bk")}.` : ""
-        const text = `[OHC Status] ${msgs.length} messages visible (${prunedCount} auto-pruned, ${strategyPruned} strategy-pruned)${blockLine}${timing}. ~${Math.round(t / 1000)}K / ${max.toLocaleString()} tokens (${Math.round((t / max) * 100)}%). Soft floor: ${min.toLocaleString()}.`
+        const blockLine = activeBlockIds.length ? ` bk${activeBlockIds.join(", bk")}.` : ""
+        const summaryBufferTotal = config.compress?.summaryBuffer
+          ? estimateSummaryTokens(msgs)
+          : 0
+        const effectiveMax = max + summaryBufferTotal
+        const text = `OHC: ${msgs.length} visible (${prunedCount} auto, ${strategyPruned} strategy) \u00b7 ~${Math.round(t / 1000)}K tok (${Math.round((t / effectiveMax) * 100)}%)${blockLine}${timing}`
         await ctx.client.session.prompt({
           path: { id: input.sessionID },
           body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
@@ -432,8 +450,8 @@ export const OhcPlugin = async (ctx) => {
         const autoPruned = ss?.prunedIds?.size || 0
         const timing = buildTimingStr(ss)
         const activeBlockIds = [...(ss?.prune?.messages?.activeBlockIds || [])].filter(id => Number.isInteger(id)).sort((a, b) => a - b)
-        const blockLine = activeBlockIds.length ? ` Active: bk${activeBlockIds.join(", bk")}.` : ""
-        const text = `[OHC Stats] ${blocks} total compression blocks${blockLine} ~${Math.round(totalSaved / 1000)}K tokens saved${timing}. Auto-pruned: ${autoPruned} messages. Strategy-pruned: ${dedupPruned} calls.`
+        const blockLine = activeBlockIds.length ? ` \u00b7 bk${activeBlockIds.join(", bk")}` : ""
+        const text = `OHC: ${blocks} blocks${blockLine} \u00b7 ~${Math.round(totalSaved / 1000)}K saved \u00b7 auto: ${autoPruned}, strategy: ${dedupPruned}${timing}`
         await ctx.client.session.prompt({
           path: { id: input.sessionID },
           body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
@@ -448,14 +466,14 @@ export const OhcPlugin = async (ctx) => {
           if (ss) ss.manualMode = "active"
           await ctx.client.session.prompt({
             path: { id: input.sessionID },
-            body: { noReply: true, parts: [{ type: "text", text: "[OHC] Manual mode enabled. Agent will not autonomously compress.", ignored: true }] },
+            body: { noReply: true, parts: [{ type: "text", text: "OHC Manual: active \u2014 agent will not autonomously compress", ignored: true }] },
           })
         } else {
           const ss = getOrCreateState(input.sessionID)
           if (ss) ss.manualMode = false
           await ctx.client.session.prompt({
             path: { id: input.sessionID },
-            body: { noReply: true, parts: [{ type: "text", text: "[OHC] Manual mode disabled. Agent can compress autonomously.", ignored: true }] },
+            body: { noReply: true, parts: [{ type: "text", text: "OHC Manual: off \u2014 agent can compress autonomously", ignored: true }] },
           })
         }
         throw new Error("__OHC_MANUAL_HANDLED__")
@@ -475,11 +493,11 @@ export const OhcPlugin = async (ctx) => {
         try {
           const result = await applyCompress(ctx, input.sessionID, focus, max, min, targetTokens)
           const cmdSs = getOrCreateState(input.sessionID)
-          await sendCompressNotification(ctx.client, input.sessionID, config, result.removed, focus, result.tokensRemoved, cmdSs?.totalTokensSaved || 0, cmdSs?.blockCount || 0, result.removed, result.afterCount)
+          await sendCompressNotification(ctx.client, input.sessionID, config, result.removed, focus, result.tokensRemoved, cmdSs, result.afterCount)
           output.parts.length = 0
           output.parts.push({
             type: "text",
-            text: `[OHC] Compressed: ${result.removed} messages removed. Summary: ${focus}`,
+            text: `OHC: Compressed ${result.removed} msgs. Summary: ${focus}`,
           })
         } catch {
           output.parts.length = 0
@@ -513,8 +531,8 @@ export const OhcPlugin = async (ctx) => {
         }
 
         const activeBlockIds = [...(ss?.prune?.messages?.activeBlockIds || [])].filter(id => Number.isInteger(id)).sort((a, b) => a - b)
-        const blockLine = activeBlockIds.length ? ` Active blocks: bk${activeBlockIds.join(", bk")}.` : ""
-        const text = `[OHC Context] ${msgs.length} visible messages (${autoPruned + stratPruned} pruned). Tokens: ~${Math.round(visibleTokens / 1000)}K visible / ~${Math.round(totalTokensWithPruned / 1000)}K total. ${blocks} compression blocks, ~${Math.round(totalSaved / 1000)}K saved. ${blockLine}\n\nBreakdown:\n${roleLines.join("\n")}`
+        const blockLine = activeBlockIds.length ? ` \u00b7 bk${activeBlockIds.join(", bk")}` : ""
+        const text = `OHC: ${msgs.length} visible (${autoPruned + stratPruned} pruned) \u00b7 ~${Math.round(visibleTokens / 1000)}K/~${Math.round(totalTokensWithPruned / 1000)}K \u00b7 ${blocks} blocks, ~${Math.round(totalSaved / 1000)}K saved${blockLine}\n\nRole breakdown:\n${roleLines.map(r => `  ${r}`).join("\n")}`
         await ctx.client.session.prompt({
           path: { id: input.sessionID },
           body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
@@ -539,13 +557,13 @@ export const OhcPlugin = async (ctx) => {
           }
         }
         applyPruneTools(ss, output.messages)
-        const text = `[OHC] Swept: ${sweptCount} tool calls pruned.`
+        const text = `OHC Sweep: ${sweptCount} tool call${sweptCount === 1 ? "" : "s"} pruned`
         output.parts.length = 0
         output.parts.push({ type: "text", text })
         return
       }
 
-      const text = "OHC commands: /ohc status — /ohc stats — /ohc context — /ohc sweep [n] — /ohc manual [on|off] — /ohc compress [focus]"
+      const text = "OHC: /ohc status | stats | context | sweep [n] | manual [on|off] | compress [focus]"
       await ctx.client.session.prompt({
         path: { id: input.sessionID },
         body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
@@ -555,7 +573,7 @@ export const OhcPlugin = async (ctx) => {
 
     tool: {
       compress: tool({
-        description: "Compress conversation content to free context space. Supports two modes: range mode (specify content array with startId/endId/summary per entry) and legacy mode (specify summary with optional targetTokens). Use range mode for precise targeting; fall back to legacy for general oldest-first pruning. When using range mode, wrap each boundary pair: startId (ohcNNNN or bkNN) must appear before endId. Each entry's summary replaces that conversation range entirely. Provide a technical summary of what was removed, including file paths, function signatures, decisions, and constraints.",
+        description: "Compress conversation content to free context space. Two modes: range mode (specify content array with startId/endId/summary per entry) and summary mode (specify summary with optional targetTokens). Use range for precise targeting; fall back to summary for general oldest-first pruning. In range mode, each startId/endId pair uses message or block references found in conversation. Each entry's summary replaces the entire range. Provide a technical summary of what was removed, including file paths, function signatures, decisions, and constraints.",
         args: {
           topic: tool.schema.string().optional().describe("Range mode: Short label (3-5 words) for the overall batch — e.g. 'Auth System Exploration'"),
           content: tool.schema.array(tool.schema.object({
@@ -574,15 +592,15 @@ export const OhcPlugin = async (ctx) => {
             const result = await executeRangeCompress(ctx, sessionId, callId, args.topic || "Compression", args.content)
             toolCtx.metadata({ title: "Compress Range" })
             const resultSs = getOrCreateState(sessionId)
-            await sendCompressNotification(ctx.client, sessionId, config, result.messageIds.length, result.summaryRef, result.compressedTokens, resultSs?.totalTokensSaved || 0, resultSs?.blockCount || 0, result.messageIds.length, 0)
-            return `Compressed ${result.messageIds.length} messages across ${args.content.length} range(s). Summary: "${truncateText(result.summaryRef, 200)}"`
+            await sendCompressNotification(ctx.client, sessionId, config, result.messageIds.length, result.summaryRef, result.compressedTokens, resultSs, result.afterCount || 0)
+            return `OHC: Compressed ${result.messageIds.length} msgs across ${args.content.length} range(s). Summary: "${truncateText(result.summaryRef, 200)}"`
           }
 
           const result = await applyCompress(ctx, sessionId, args.summary, max, min, args.targetTokens)
           toolCtx.metadata({ title: "Compress" })
           const toolSs = getOrCreateState(sessionId)
-          await sendCompressNotification(ctx.client, sessionId, config, result.removed, truncateText(args.summary, 200), result.tokensRemoved, toolSs?.totalTokensSaved || 0, toolSs?.blockCount || 0, result.removed, result.afterCount)
-          return `Compressed: ${result.removed} messages removed. Summary: "${truncateText(args.summary, 200)}"`
+          await sendCompressNotification(ctx.client, sessionId, config, result.removed, truncateText(args.summary, 200), result.tokensRemoved, toolSs, result.afterCount)
+          return `OHC: Compressed ${result.removed} msgs. Summary: "${truncateText(args.summary, 200)}"`
         },
       }),
     },

package/lib/ohc/reaper.mjs

@@ -7,10 +7,10 @@ function partTokens(part) {
       t += (typeof part.state.output === "string" ? part.state.output : JSON.stringify(part.state.output ?? "")).length / 4
     return Math.ceil(t)
   }
-  return Math.ceil(JSON.stringify(part).length / 4)
+  try { return Math.ceil(JSON.stringify(part).length / 4) } catch { return 0 }
 }
 
-function msgTokens(msg) {
+export function msgTokens(msg) {
   return (Array.isArray(msg.parts) ? msg.parts : []).reduce((s, p) => s + partTokens(p), 0)
 }
 

package/lib/ohc/state.mjs

@@ -89,6 +89,7 @@ export function createSessionState() {
     summary: null,
     anchorMessageId: null,
     totalTokensSaved: 0,
+    totalMessagesRemoved: 0,
     blockCount: 0,
   }
 }
@@ -136,6 +137,7 @@ export function serializeState(state) {
     },
     lastAutoPruneAt: state.lastAutoPruneAt,
     totalTokensSaved: state.totalTokensSaved,
+    totalMessagesRemoved: state.totalMessagesRemoved,
     blockCount: state.blockCount,
     summary: state.summary,
     anchorMessageId: state.anchorMessageId,
@@ -148,6 +150,7 @@ export function serializeState(state) {
     },
     compressionTiming: {
       starts: Object.fromEntries(state.compressionTiming?.starts || new Map()),
+      pendingByCallId: pruneMapToObj(state.compressionTiming?.pendingByCallId || new Map()),
       lastDurationMs: state.compressionTiming?.lastDurationMs || 0,
       totalDurationMs: state.compressionTiming?.totalDurationMs || 0,
     },
@@ -180,6 +183,7 @@ export function deserializeState(saved) {
   }
   state.lastAutoPruneAt = saved.lastAutoPruneAt || null
   state.totalTokensSaved = saved.totalTokensSaved || 0
+  state.totalMessagesRemoved = saved.totalMessagesRemoved || 0
   state.blockCount = saved.blockCount || 0
   state.summary = saved.summary || null
   state.anchorMessageId = saved.anchorMessageId || null
@@ -213,12 +217,10 @@ export function buildToolIdList(state, messages) {
 }
 
 export function syncToolCache(state, messages) {
-  let maxTurn = 0
+  let userTurn = 0
   for (const msg of messages) {
-    if (msg.info?.role === "user") {
-      const lastUser = state.toolIdList.length > 0
-      if (lastUser) maxTurn++
-    }
+    const hasUserText = msg.info?.role === "user" && msg.parts?.some(p => p.type === "text" && p.text?.trim())
+    if (hasUserText) userTurn++
     if (!Array.isArray(msg.parts)) continue
     for (const part of msg.parts) {
       if (part.type !== "tool" || !part.callID) continue
@@ -231,13 +233,13 @@ export function syncToolCache(state, messages) {
         tool: part.tool || "unknown",
         parameters: part.state?.input || {},
         status: part.state?.status || "pending",
-        turn: maxTurn,
+        turn: userTurn,
         tokenCount: estimateToolTokens(part),
         lastSeen: Date.now(),
       })
     }
   }
-  state.currentTurn = Math.max(state.currentTurn, maxTurn)
+  state.currentTurn = Math.max(state.currentTurn, userTurn)
 }
 
 function estimateToolTokens(part) {

package/lib/ohc/updater.mjs

@@ -87,38 +87,37 @@ async function handleUpdateMe(ctx, input, output) {
     output.parts.length = 0
     output.parts.push({
       type: "text",
-      text: `[Update-Me] No OpenHermes cache found under OpenCode package/node_modules caches.
-Restart OpenCode to redownload from ${info.method === "git" ? "git HEAD" : "npm registry"}.`,
+      text: `[Update-Me] No OpenHermes plugin cache found.\nRestart OpenCode to redownload from ${info.method === "git" ? "git HEAD" : "npm registry"}.`,
     })
     return
   }
 
-  const deleted = []
-  const failed = []
+  let clearedCount = 0
+  let failedCount = 0
+  let firstError = null
   for (const dir of cacheDirs) {
     try {
       fs.rmSync(dir.path, { recursive: true, force: true })
-      deleted.push(dir.name)
+      clearedCount++
     } catch (e) {
-      failed.push({ name: dir.name, error: e.message })
+      failedCount++
+      if (!firstError) firstError = e.message
     }
   }
 
   output.parts.length = 0
   let msg = `[Update-Me] OpenHermes update (${info.method})\n`
 
-  if (deleted.length > 0) {
-    msg += `\nCleared:\n`
-    for (const d of deleted) msg += `  ✓ ${d}\n`
+  if (clearedCount > 0) {
+    msg += `\n  ✓ Cleared OpenHermes plugin cache (${clearedCount} entr${clearedCount === 1 ? "y" : "ies"}).`
   }
 
-  if (failed.length > 0) {
-    msg += `\n⚠ Could not remove (file may be locked):\n`
-    for (const f of failed) msg += `  ✗ ${f.name} — ${f.error}\n`
-    msg += `Try deleting manually:\n  ${CACHE_ROOTS.join("\n  ")}\n`
+  if (failedCount > 0) {
+    msg += `\n  ⚠ ${failedCount} entr${failedCount === 1 ? "y" : "ies"} could not be removed (may be locked).`
+    if (firstError) msg += `\n  ${firstError}`
   }
 
-  msg += `\nRestart OpenCode to load the latest OpenHermes from ${info.method === "git" ? "git HEAD" : "npm registry"}.`
+  msg += `\n\nRestart OpenCode to load the latest OpenHermes from ${info.method === "git" ? "git HEAD" : "npm registry"}.`
 
   output.parts.push({ type: "text", text: msg })
 }

package/lib/paths.mjs

@@ -2,6 +2,7 @@ import path from "node:path"
 import os from "node:os"
 import fs from "node:fs"
 import { fileURLToPath } from "node:url"
+import { isTruthy } from "./hardening.mjs"
 
 const HOME = process.env.USERPROFILE || os.homedir()
 const DATA_ROOT = path.join(HOME, ".local", "share", "opencode", "openhermes")
@@ -45,6 +46,4 @@ export function getSchemaRoot() {
   return path.resolve(PKG_DIR, "..", "schemas")
 }
 
-function isTruthy(value) {
-  return /^(1|true|yes|on)$/i.test(String(value || ""))
-}
+

package/lib/schema-validator.mjs

@@ -1,10 +1,8 @@
+import { isPlainObject } from "./hardening.mjs"
+
 const SUPPORTED_SCHEMA_KEYS = new Set(["type", "const", "enum", "format", "minimum", "maximum", "required", "properties", "items"])
 const SCHEMA_METADATA_KEYS = new Set(["$schema", "title", "description", "default"])
 
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}
-
 function matchesType(type, value) {
   if (type === "null") return value === null
   if (type === "array") return Array.isArray(value)
@@ -26,7 +24,7 @@ function validateNode(schema, value, at, errors) {
   }
 
   if (typeof value === "string" && schema.format === "date-time" && Number.isNaN(Date.parse(value))) errors.push(`${at} must be a valid date-time string`)
-  if (typeof value === "number" || Number.isInteger(value)) {
+  if (typeof value === "number") {
     if (schema.minimum !== undefined && value < schema.minimum) errors.push(`${at} must be >= ${schema.minimum}`)
     if (schema.maximum !== undefined && value > schema.maximum) errors.push(`${at} must be <= ${schema.maximum}`)
   }
@@ -64,6 +62,10 @@ function visitSchemaNode(schema, at, unsupported) {
       visitSchemaNode(value, `${at}.items`, unsupported)
       continue
     }
+    if (key === "$defs" || key === "definitions") {
+      if (isPlainObject(value)) for (const defName of Object.keys(value)) visitSchemaNode(value[defName], `${at}.${key}.${defName}`, unsupported)
+      continue
+    }
     if (!SUPPORTED_SCHEMA_KEYS.has(key) && !SCHEMA_METADATA_KEYS.has(key)) unsupported.push(`${at} uses unsupported schema keyword "${key}"`)
   }
 }

package/lib/search.mjs

@@ -3,7 +3,7 @@ export function scoreRelevance(r, query, project) {
   const tokens = q.split(/\s+/).filter(t => t.length > 2)
   let score = 0
 
-  const primaryFields = [r.summary, r.description, r.mission, r.current_state, r.failure, r.root_cause, r.fix, r.prevention, r.id].filter(Boolean)
+  const primaryFields = [r.summary, r.description, r.mission, r.current_state, r.failure, r.root_cause, r.fix, r.prevention, r.id, r.choice, r.reason, r.source, r.artifact, r.result].filter(Boolean)
   const secondaryFields = [r.command, r.project, r.scope].filter(Boolean)
   const listFields = [...(Array.isArray(r.tags) ? r.tags : []), ...(Array.isArray(r.next_actions) ? r.next_actions : []), ...(Array.isArray(r.refs) ? r.refs : [])].filter(Boolean)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openhermes",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "OpenHermes plugin suite for OpenCode — autonomous checkpointing, native memory tools, subagent routing, slash commands, and skill-candidate detection.",
   "type": "module",
   "license": "MIT",

package/schemas/backlog.schema.json

@@ -37,7 +37,7 @@
     "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
     "title": { "type": "string", "description": "Human-readable title for this backlog item" },
     "priority": { "type": "string", "enum": ["low", "medium", "high", "critical", "P0", "P1", "P2", "P3", "P4"], "description": "Priority level (low/medium/high/critical or P0-P4)" },
-    "trigger": { "type": "string", "enum": ["audit", "mistake", "drift", "user", "manual"], "description": "What triggered creation of this item" },
+    "trigger": { "type": "string", "enum": ["audit", "mistake", "drift", "user", "manual"], "default": "manual", "description": "What triggered creation of this item" },
     "evidence_refs": { "type": "array", "items": { "type": "string" }, "description": "References to evidence (audit IDs, mistake IDs, file paths)" },
     "done_when": { "type": "array", "items": { "type": "string" }, "description": "Acceptance criteria — concrete conditions for closure" },
     "description": { "type": "string", "description": "Optional description" },

package/schemas/instinct.schema.json

@@ -35,11 +35,11 @@
     "review_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
     "decay_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
     "archived_at": { "type": ["string", "null"], "format": "date-time", "description": "ISO-8601 or null" },
-    "trigger": { "type": "string", "description": "Condition or pattern that triggers this instinct" },
+    "trigger": { "type": "string", "default": "manual", "description": "Condition or pattern that triggers this instinct" },
     "action": { "type": "string", "description": "Recommended action when triggered" },
     "success_count": { "type": "integer", "minimum": 0, "default": 0, "description": "Number of successful applications" },
     "failure_count": { "type": "integer", "minimum": 0, "default": 0, "description": "Number of failed applications" },
-    "promotion_state": { "type": "string", "enum": ["project", "candidate_global", "global"], "description": "Current promotion level" },
+    "promotion_state": { "type": "string", "enum": ["project", "candidate_global", "global"], "default": "project", "description": "Current promotion level" },
     "description": { "type": "string", "description": "Optional description" },
     "environment_fingerprint": {
       "type": "object",

package/schemas/mistake.schema.json

@@ -8,7 +8,7 @@
     "id": { "type": "string", "description": "Unique identifier, recommended pattern: mistake-YYYYMMDD-short-slug" },
     "class": { "type": "string", "const": "mistake" },
     "project": { "type": ["string", "null"], "description": "Project identifier; null for global/openhermes scope" },
-    "scope": { "type": "string", "enum": ["project", "global", "harness"], "description": "Scope of applicability" },
+    "scope": { "type": "string", "enum": ["project", "global", "session", "harness"], "description": "Scope of applicability" },
     "summary": { "type": "string", "description": "One-line description of the mistake" },
     "tags": { "type": "array", "items": { "type": "string" }, "description": "Searchable tags" },
     "source": { "type": "string", "enum": ["user", "agent", "audit", "migration", "repair"], "description": "Origin of this record" },