openhermes 1.12.1 → 2.5.0

package/harness/rules/retrieval.md

@@ -56,10 +56,10 @@ Self-improving agents rot by saving too much. These rules prevent memory spam:
 
 ## Retrieval Implementation
 
-1. Start with `latest_memory(class)` for the most likely relevant class.
-2. Then use `search_memory(query, classes, project, limit)` with narrow, task-shaped filters.
-3. Use `fetch_memory(class, id)` only for specific records surfaced by step 1 or 2.
-4. Use `list_memory(class, limit)` only when you need a small class sample or a bounded discovery pass.
+1. Start with `ohc_latest(class)` for the most likely relevant class.
+2. Then use `ohc_search(query, classes, project, limit)` with narrow, task-shaped filters.
+3. Use `ohc_get(class, id)` only for specific records surfaced by step 1 or 2.
+4. Use `ohc_list(class, limit)` only when you need a small class sample or a bounded discovery pass.
 5. Never read full memory index files for routine task work.
 6. Read whole indexes only when the task is explicitly about auditing, repairing, or regenerating the index itself.
 7. For project-level file search with grep/glob patterns: delegate to `explore` subagent.
@@ -69,7 +69,7 @@ Self-improving agents rot by saving too much. These rules prevent memory spam:
 
 **NEVER start broad. Always needle-precision first.**
 
-1. Start with the single most targeted tool for the question: `grep` for a pattern, `glob` for a filename, `latest_memory` for a memory class, `search_memory` with narrow filters.
+1. Start with the single most targeted tool for the question: `grep` for a pattern, `glob` for a filename, `ohc_latest` for a memory class, `ohc_search` with narrow filters.
 2. Read the minimum number of files to answer the question — often 1-3, not 16+.
 3. Stop immediately when you have enough signal to answer.
 4. Only broaden when every precise method is exhausted and the answer is still missing.

package/harness/rules/runtime-guards.md

@@ -100,7 +100,7 @@ function detectStateDrift(compressedBuffer) {
 
 ## Enforcement Points
 
-### Memory Write (add_memory)
+### Memory Write (ohc_save)
 ```javascript
 // In openhermes-memory MCP server
 function putMemoryObject(obj) {

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/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/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" },
+      })
+    }
+  }
+})