openhermes 1.5.6 → 1.13.1

package/lib/memory-tools-plugin.mjs

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

package/lib/ohc/config.mjs

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

package/lib/ohc/pruner.mjs

@@ -0,0 +1,239 @@
+import { tool } from "@opencode-ai/plugin"
+import { loadConfig } from "./config.mjs"
+import { selectMessagesToReap, totalTokens } from "./reaper.mjs"
+import { loadOhcState, saveOhcState } from "./state.mjs"
+
+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.`
+  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]`
+}
+
+function createSummaryMessage(text) {
+  return { parts: [{ type: "text", text }], info: { role: "system" } }
+}
+
+async function applyCompress(ctx, sessionId, summary, max, min, targetTokens) {
+  const ss = getOrCreateState(sessionId)
+  ss.prunedIds.clear()
+
+  const res = await ctx.client.session.messages({ path: { id: sessionId } })
+  const msgs = res?.data || res || []
+  if (!Array.isArray(msgs)) return { removed: 0, message: "no messages" }
+
+  const selected = selectMessagesToReap(msgs, max, min, "compress", targetTokens)
+  if (selected.length === 0) return { removed: 0, message: "already within target" }
+
+  for (const r of selected) ss.prunedIds.add(r.id)
+  ss.summary = summarizeRemoved(selected, summary)
+  ss.anchorMessageId = selected[0].id
+  saveOhcState(sessionId, {
+    prunedMessageIds: [...ss.prunedIds],
+    summary: ss.summary,
+    anchorMessageId: ss.anchorMessageId,
+  })
+
+  return { removed: selected.length }
+}
+
+const stateCache = new Map()
+
+function getOrCreateState(sessionId) {
+  if (!sessionId) return null
+  let s = stateCache.get(sessionId)
+  if (!s) {
+    const persisted = loadOhcState(sessionId)
+    s = {
+      prunedIds: new Set(persisted?.prunedMessageIds || []),
+      summary: persisted?.summary || null,
+      anchorMessageId: persisted?.anchorMessageId || null,
+      lastNudgePct: 0,
+    }
+    stateCache.set(sessionId, s)
+  }
+  return s
+}
+
+export const OhcPlugin = async (ctx) => {
+  const config = loadConfig()
+  if (!config.enabled) return {}
+
+  const max = config.max
+  const min = config.min
+  if (max <= min + 10000) return {}
+
+  let systemInjected = false
+
+  return {
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (systemInjected || !output.system?.length) return
+      systemInjected = true
+      output.system[output.system.length - 1] += `\n\n## Context Management (OHC)\n- OHC manages all compression. Set \`compaction.auto: false\` in opencode.json to prevent double pruning.\n- Default soft budget: ${max.toLocaleString()} tokens. Soft floor: ${min.toLocaleString()}.\n- These are advisory — the agent can override by passing \`targetTokens\` to the \`compress\` tool.\n- Call \`compress\` with a summary to free context space. Optionally specify \`targetTokens\` (lower = more aggressive).`
+    },
+
+    "experimental.chat.messages.transform": async (_input, output) => {
+      if (!output?.messages?.length) return
+
+      const sessionId = output.messages.find(m => m.info?.sessionID)?.info?.sessionID
+      if (!sessionId) return
+
+      const ss = getOrCreateState(sessionId)
+      if (!ss) return
+
+      if (ss.prunedIds.size > 0) {
+        const currentIds = new Set(output.messages.map(m => m.info?.id).filter(Boolean))
+        if ([...ss.prunedIds].every(id => !currentIds.has(id))) {
+          ss.prunedIds.clear()
+          ss.summary = null
+          ss.anchorMessageId = null
+          saveOhcState(sessionId, {
+            prunedMessageIds: [],
+            summary: null,
+            anchorMessageId: null,
+          })
+        }
+      }
+
+      const currentTotal = totalTokens(output.messages)
+      if (currentTotal > max) {
+        const selected = selectMessagesToReap(output.messages, max, min)
+        if (selected.length > 0) {
+          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, {
+            prunedMessageIds: [...ss.prunedIds],
+            summary: ss.summary,
+            anchorMessageId: ss.anchorMessageId,
+          })
+        }
+      }
+
+      if (ss.prunedIds.size > 0) {
+        const prunedIds = ss.prunedIds
+        const summary = ss.summary
+        const anchorId = ss.anchorMessageId
+        const result = []
+        let injected = false
+
+        for (const msg of output.messages) {
+          const msgId = msg.info?.id
+
+          if (anchorId && msgId === anchorId && !injected && summary) {
+            result.push(createSummaryMessage(summary))
+            injected = true
+          }
+
+          if (msgId !== undefined && prunedIds.has(msgId)) continue
+
+          result.push(msg)
+        }
+
+        if (!injected && summary && result.length > 1) {
+          result.splice(1, 0, createSummaryMessage(summary))
+        }
+
+        output.messages.length = 0
+        output.messages.push(...result)
+      }
+
+      const afterTotal = totalTokens(output.messages)
+      const pct = afterTotal / max
+      const nudge = buildNudge(pct, max)
+      if (nudge && pct > ss.lastNudgePct + 0.05) {
+        ss.lastNudgePct = pct
+        for (let i = output.messages.length - 1; i >= 0; i--) {
+          const m = output.messages[i]
+          if (m.info?.role === "assistant" && m.parts?.length) {
+            const textPart = m.parts.find(p => p.type === "text")
+            if (textPart) { textPart.text += "\n\n" + nudge; break }
+          }
+        }
+      }
+    },
+
+    "command.execute.before": async (input, output) => {
+      if (input.command !== "ohc") return
+      const sub = (input.arguments || "").trim().toLowerCase()
+      const args = (input.arguments || "").trim()
+
+      if (sub === "status") {
+        let msgs = [], t = 0
+        try {
+          if (ctx?.client?.session?.messages) {
+            const res = await ctx.client.session.messages({ path: { id: input.sessionID } })
+            msgs = res?.data || res || []
+            t = totalTokens(msgs)
+          }
+        } catch {}
+        const ss = getOrCreateState(input.sessionID)
+        const prunedCount = ss?.prunedIds.size || 0
+        const text = `[OHC Status] ${msgs.length} messages visible (${prunedCount} pruned), ~${Math.round(t / 1000)}K / ${max.toLocaleString()} tokens (${Math.round((t / max) * 100)}%). Soft floor: ${min.toLocaleString()}.`
+        await ctx.client.session.prompt({
+          path: { id: input.sessionID },
+          body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
+        })
+        throw new Error("__OHC_STATUS_HANDLED__")
+      }
+
+      if (sub.startsWith("compress")) {
+        const rest = args.replace(/^compress\s*/i, "").trim()
+        const numMatch = rest.match(/^(\d+)\s*(.*)/)
+        let targetTokens
+        let focus
+        if (numMatch) {
+          targetTokens = parseInt(numMatch[1], 10)
+          focus = numMatch[2].trim() || "Manual compression by user"
+        } else {
+          focus = rest || "Manual compression by user"
+        }
+        try {
+          const result = await applyCompress(ctx, input.sessionID, focus, max, min, targetTokens)
+          output.parts.length = 0
+          output.parts.push({
+            type: "text",
+            text: `[OHC] Compressed: ${result.removed} messages removed. Summary: ${focus}`,
+          })
+        } catch {
+          output.parts.length = 0
+          output.parts.push({ type: "text", text: `/ohc compress ${focus}` })
+        }
+        return
+      }
+
+      const text = "OHC commands: /ohc status — /ohc compress [targetTokens] [focus description]"
+      await ctx.client.session.prompt({
+        path: { id: input.sessionID },
+        body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
+      })
+      throw new Error("__OHC_HELP_HANDLED__")
+    },
+
+    tool: {
+      compress: tool({
+        description: "Proactively compress old conversation content to free context space. Provide a technical summary of what was removed. Optionally specify targetTokens to control how much to keep (lower = more aggressive).",
+        args: {
+          summary: tool.schema.string().describe("Technical summary of the compressed content. Include what was removed and key decisions preserved."),
+          targetTokens: tool.schema.number().optional().describe("Estimated target after compression (heuristic, not exact). Lower = more aggressive. Default uses soft config floor."),
+        },
+        async execute(args, toolCtx) {
+          const result = await applyCompress(ctx, toolCtx.sessionID, args.summary, max, min, args.targetTokens)
+          toolCtx.metadata({ title: "Compress" })
+          return `Compressed: ${result.removed} messages removed. Summary: "${truncateText(args.summary, 200)}"`
+        },
+      }),
+    },
+  }
+}
+
+function truncateText(s, n) {
+  if (!s || s.length <= n) return s || ""
+  return s.slice(0, n) + "..."
+}

package/lib/ohc/reaper.mjs

@@ -0,0 +1,61 @@
+function partTokens(part) {
+  if (part.type === "text") return Math.ceil((part.text || "").length / 4)
+  if (part.type === "tool") {
+    let t = 0
+    if (part.state?.input) t += JSON.stringify(part.state.input).length / 4
+    if (part.state?.output)
+      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)
+}
+
+function msgTokens(msg) {
+  return (Array.isArray(msg.parts) ? msg.parts : []).reduce((s, p) => s + partTokens(p), 0)
+}
+
+export function totalTokens(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((s, m) => s + msgTokens(m), 0)
+}
+
+/**
+ * Select oldest messages to remove.
+ * Returns array of { id, msg, tokens } without mutating the input.
+ * Never removes index 0 (system prompt) or the last message (latest turn).
+ *
+ * mode "auto":          remove just enough to bring total under maxLimit
+ * mode "compress":      remove everything down to floor (deep prune)
+ *
+ * targetOverride: when set, replaces floor/minFloor — agent explicit request
+ *   overrides the soft config defaults. Used when user asks "compress to X".
+ */
+export function selectMessagesToReap(messages, maxLimit, minFloor, mode = "auto", targetOverride) {
+  if (!messages?.length || messages.length < 3) return []
+
+  let total = totalTokens(messages)
+  const selected = []
+
+  if (mode === "compress") {
+    const floor = targetOverride ?? minFloor
+    let i = 1
+    while (i < messages.length - 1) {
+      const t = msgTokens(messages[i])
+      if (total - t < floor) break
+      total -= t
+      selected.push({ id: String(messages[i].info?.id ?? i), msg: messages[i], tokens: t })
+      i++
+    }
+  } else {
+    const floor = targetOverride ?? minFloor
+    let i = 1
+    while (i < messages.length - 1 && total > maxLimit) {
+      const t = msgTokens(messages[i])
+      if (total - t < floor) break
+      total -= t
+      selected.push({ id: String(messages[i].info?.id ?? i), msg: messages[i], tokens: t })
+      i++
+    }
+  }
+
+  return selected
+}

package/lib/ohc/state.mjs

@@ -0,0 +1,32 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const STATE_DIR = path.join(os.homedir(), ".local", "share", "opencode")
+const STATE_FILE = path.join(STATE_DIR, "ohc-state.json")
+
+function readAll() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+function writeAll(data) {
+  fs.mkdirSync(STATE_DIR, { recursive: true })
+  fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2), "utf8")
+}
+
+export function loadOhcState(sessionId) {
+  if (!sessionId) return null
+  const all = readAll()
+  return all[sessionId] || null
+}
+
+export function saveOhcState(sessionId, data) {
+  if (!sessionId) return
+  const all = readAll()
+  all[sessionId] = { ...data, updatedAt: new Date().toISOString() }
+  writeAll(all)
+}