openhermes 2.6.1 → 4.0.0

package/lib/memory-tools-plugin.mjs

@@ -1,365 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-import { fileURLToPath } from "node:url"
-import path from "node:path"
-import fs from "node:fs"
-import os from "node:os"
-
-import { atomicWriteJson, fingerprintEnvironment, readJson, readJsonl, sanitizeRecord, truncateText } from "./hardening.mjs"
-import { findUnsupportedSchemaKeywords, validateSchema } from "./schema-validator.mjs"
-import { getMemoryRoot, getRuntimeRoot } from "./paths.mjs"
-import { loadConfig } from "./ohc/config.mjs"
-import { sendMemoryNotification } from "./ohc/notify.mjs"
-import { scoreRelevance } from "./search.mjs"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const SCHEMAS_DIR = path.resolve(__dirname, "..", "schemas")
-const MEMORY_DIR = getMemoryRoot()
-
-const CLASSES = ["audit", "checkpoint", "mistake", "instinct", "decision", "constraint", "backlog", "verification_receipt"]
-const PLURALS = { audit: "audits", checkpoint: "checkpoints", mistake: "mistakes", instinct: "instincts", decision: "decisions", constraint: "constraints", backlog: "backlog", verification_receipt: "verification_receipts" }
-
-function isPlainObject(v) { return !!v && typeof v === "object" && !Array.isArray(v) }
-
-function classDir(cls) { return path.join(MEMORY_DIR, PLURALS[cls]) }
-
-function stableStringify(v, space = 0) {
-  function sort(o) {
-    if (Array.isArray(o)) return o.map(sort)
-    if (!isPlainObject(o)) return o
-    const r = {}
-    for (const k of Object.keys(o).sort()) r[k] = sort(o[k])
-    return r
-  }
-  return JSON.stringify(sort(v), null, space)
-}
-
-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 }
-  return e
-}
-
-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 sortRecent(entries) {
-  function ts(e) { return e?.updated_at ?? e?.created_at ?? "" }
-  return [...entries].sort((a, b) => {
-    const at = Date.parse(ts(a)), bt = Date.parse(ts(b))
-    if (!Number.isNaN(at) && !Number.isNaN(bt) && at !== bt) return bt - at
-    return String(ts(b)).localeCompare(String(ts(a)))
-  })
-}
-
-function filterActive(entries) { return entries.filter(e => !hasExpired(e)) }
-
-function writeObject(cls, record) {
-  const dir = classDir(cls)
-  fs.mkdirSync(dir, { recursive: true })
-  const fp = path.join(dir, `${record.id}.json`)
-  atomicWriteJson(fp, record)
-  const indexPath = path.join(dir, "index.json")
-  let index = readJson(indexPath, [])
-  if (!Array.isArray(index)) index = []
-  const idx = index.findIndex(e => e?.id === record.id)
-  const entry = buildEntry(cls, record)
-  if (idx >= 0) index[idx] = entry; else index.push(entry)
-  atomicWriteJson(indexPath, index)
-}
-
-function upsertMistake(record) {
-  const dir = classDir("mistake")
-  fs.mkdirSync(dir, { recursive: true })
-  const fp = path.join(dir, "mistakes.jsonl")
-  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")
-  fs.writeFileSync(fp, text ? `${text}\n` : "", "utf8")
-}
-
-function queryList(cls, limit = 10) {
-  if (cls === "mistake") {
-    return sortRecent(filterActive(readJsonl(path.join(classDir(cls), "mistakes.jsonl")))).slice(0, limit)
-  }
-  const dir = classDir(cls)
-  const index = readJson(path.join(dir, "index.json"), [])
-  if (!Array.isArray(index)) return []
-  return sortRecent(filterActive(index)).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)
-}
-
-function enforceAuditEvidence(record) {
-  const prov = isPlainObject(record.provenance) ? record.provenance : {}
-  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) {
-  if (!context || typeof context.metadata !== "function") return
-  context.metadata({ title })
-}
-
-function fillSchemaDefaults(record, schema) {
-  const required = Array.isArray(schema.required) ? schema.required : []
-  for (const field of required) {
-    const prop = schema.properties?.[field]
-    if (!prop) { if (!(field in record)) record[field] = null; continue }
-
-    const types = Array.isArray(prop.type) ? prop.type : [prop.type]
-    const t = types.find(t => t !== "null") || types[0]
-
-    if (t === "object" && prop.properties) {
-      if (record[field] == null) record[field] = {}
-      if (isPlainObject(record[field])) fillSchemaDefaults(record[field], prop)
-      continue
-    }
-
-    if (field in record) continue
-    if (prop.default !== undefined) { record[field] = structuredClone(prop.default); continue }
-    if (prop.const !== undefined) { record[field] = prop.const; continue }
-    if (prop.enum) { record[field] = prop.enum[0]; continue }
-    if (t === "integer" || t === "number") {
-      record[field] = prop.minimum !== undefined ? prop.minimum : 0
-      continue
-    }
-    switch (t) {
-      case "string":
-        record[field] = prop.minLength > 1 ? "x".repeat(prop.minLength) : field
-        break
-      case "boolean": record[field] = false; break
-      case "array": record[field] = []; break
-      default: record[field] = field; break
-    }
-  }
-}
-
-function sanitizeId(raw) {
-  return raw.replace(/[<>:"/\\|?*]/g, "_").replace(/\.\./g, "_").trim()
-}
-
-function handleAdd(cls, id, dataStr) {
-  let parsed
-  try { parsed = JSON.parse(dataStr) } catch (e) { parsed = null }
-  if (!isPlainObject(parsed)) {
-    const txt = String(dataStr ?? parsed ?? "").slice(0, 200)
-    parsed = { summary: txt }
-  }
-  if (!id?.trim()) return "non-blank id is required"
-  id = sanitizeId(id.trim())
-
-  const now = new Date().toISOString()
-  const existing = queryGet(cls, id)
-  const existingIsActive = existing && !hasExpired(existing)
-  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)
-  if (schema) {
-    fillSchemaDefaults(record, schema)
-
-    const required = Array.isArray(schema.required) ? schema.required : []
-    if (required.includes("provenance")) {
-      if (!record.provenance?.session_id) record.provenance = { ...record.provenance, session_id: `auto-${now}` }
-      if (cls === "audit" && !enforceAuditEvidence(record)) {
-        const prov = record.provenance
-        if (!Array.isArray(prov.file_refs)) prov.file_refs = []
-        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(", ")}`
-    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: ${errs.join("; ")}`
-  }
-
-  if (cls === "mistake") upsertMistake(record)
-  else writeObject(cls, record)
-
-  const action = existingIsActive ? "updated" : "saved"
-  return `${action}: ${id.trim()}`
-}
-
-function handleFetch(cls, id) {
-  if (!id?.trim()) return "non-blank id is required"
-  id = sanitizeId(id.trim())
-  const record = queryGet(cls, id)
-  if (!record) return `not found: ${id}`
-  return stableStringify(record)
-}
-
-function handleList(cls, limit = 10) {
-  const entries = queryList(cls, Math.min(limit, 100))
-  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 "no active records"
-  const record = queryGet(cls, active[0].id)
-  if (!record) return "no active records"
-  return stableStringify(record)
-}
-
-function handleSearch(query, scope, classes, project, limit) {
-  const q = (query || "").trim()
-  if (!q) return "non-blank query is required"
-  const clsList = Array.isArray(classes) && classes.length ? classes : CLASSES
-  const lim = Math.min(limit ?? 10, 50)
-  let candidates = []
-  for (const cls of clsList) {
-    if (cls === "mistake") {
-      for (const m of readJsonl(path.join(classDir(cls), "mistakes.jsonl"))) {
-        if (!hasExpired(m)) candidates.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)) candidates.push({ ...entry, _cls: cls })
-      }
-    }
-  }
-  if (scope === "global") candidates = candidates.filter(r => r.scope === "global" || !r.scope)
-  else if (scope === "local") candidates = candidates.filter(r => r.scope === "project" || r.scope === "session")
-  
-  // Score using index entries (summary-based)
-  const scored = candidates
-    .map(e => ({ ...e, score: scoreRelevance(e, q, project || "") }))
-    .filter(e => e.score > 0)
-    .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
-  })
-  
-  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")
-}
-
-function handleArchive(cls, id) {
-  if (!id?.trim()) return "non-blank id is required"
-  id = sanitizeId(id.trim())
-  const record = queryGet(cls, id)
-  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 (ctx) => {
-  fs.mkdirSync(MEMORY_DIR, { recursive: true })
-  fs.mkdirSync(getRuntimeRoot(), { recursive: true })
-
-  const config = loadConfig()
-
-  return {
-    tool: {
-      ohc_save: 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, `save ${args.class}: ${args.id}`)
-          const result = handleAdd(args.class, args.id, args.data)
-          if (result.startsWith("saved:") || result.startsWith("updated:")) {
-            const action = result.startsWith("saved:") ? "Saved" : "Updated"
-            sendMemoryNotification(ctx?.client, context.sessionID, config, action, args.class, args.id, null).catch(() => {})
-          }
-          return result
-        },
-      }),
-
-      ohc_get: 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, `fetch ${args.class}: ${args.id}`)
-          return handleFetch(args.class, args.id)
-        },
-      }),
-
-      ohc_list: 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}`)
-          return handleList(args.class, args.limit)
-        },
-      }),
-
-      ohc_latest: 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}`)
-          return handleLatest(args.class)
-        },
-      }),
-
-      ohc_search: 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"),
-          classes: tool.schema.array(tool.schema.enum(CLASSES)).optional().describe("Memory classes to search (default: all)"),
-          project: tool.schema.string().optional().describe("Project filter"),
-          limit: tool.schema.number().optional().default(10).describe("Max results (max 50)"),
-        },
-        async execute(args, context) {
-          setToolTitle(context, `search: ${truncateText(args.query, 48)}`)
-          return handleSearch(args.query, args.scope, args.classes, args.project, args.limit)
-        },
-      }),
-
-      ohc_archive: 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}`)
-          const result = handleArchive(args.class, args.id)
-          if (result.startsWith("archived:")) {
-            sendMemoryNotification(ctx?.client, context.sessionID, config, "Archived", args.class, args.id, null).catch(() => {})
-          }
-          return result
-        },
-      }),
-    },
-  }
-}

package/lib/ohc/block-sync.mjs

@@ -1,69 +0,0 @@
-export function syncCompressionBlocks(state, messages) {
-  const ms = state.prune.messages
-  if (!ms?.blocksById?.size) return
-
-  const messageIds = new Set()
-  for (const msg of messages) {
-    if (msg.info?.id) messageIds.add(msg.info.id)
-  }
-
-  const prevActive = new Set(ms.activeBlockIds)
-
-  ms.activeBlockIds.clear()
-  ms.activeByAnchorMessageId?.clear()
-
-  const now = Date.now()
-  const ordered = [...ms.blocksById.values()].sort(
-    (a, b) => (a.createdAt || 0) - (b.createdAt || 0) || a.blockId - b.blockId,
-  )
-
-  for (const block of ordered) {
-    const hasOrigin = typeof block.compressMessageId === "string" &&
-      block.compressMessageId.length > 0 &&
-      messageIds.has(block.compressMessageId)
-
-    if (!hasOrigin) {
-      block.active = false
-      block.deactivatedAt = now
-      continue
-    }
-
-    if (block.deactivatedByUser) {
-      block.active = false
-      if (block.deactivatedAt === undefined) block.deactivatedAt = now
-      continue
-    }
-
-    const consumed = Array.isArray(block.consumedBlockIds) ? block.consumedBlockIds : []
-    for (const cid of consumed) {
-      if (!ms.activeBlockIds.has(cid)) continue
-      const cb = ms.blocksById.get(cid)
-      if (cb) {
-        cb.active = false
-        cb.deactivatedAt = now
-        cb.deactivatedByBlockId = block.blockId
-      }
-      ms.activeBlockIds.delete(cid)
-    }
-
-    block.active = true
-    block.deactivatedAt = undefined
-    block.deactivatedByBlockId = undefined
-    ms.activeBlockIds.add(block.blockId)
-  }
-
-  for (const entry of ms.byMessageId.values()) {
-    const all = Array.isArray(entry.allBlockIds)
-      ? [...new Set(entry.allBlockIds.filter(id => Number.isInteger(id) && id > 0))]
-      : []
-    entry.allBlockIds = all
-    entry.activeBlockIds = all.filter(id => ms.activeBlockIds.has(id))
-  }
-
-  let deactivated = 0
-  let reactivated = 0
-  for (const id of prevActive) { if (!ms.activeBlockIds.has(id)) deactivated++ }
-  for (const id of ms.activeBlockIds) { if (!prevActive.has(id)) reactivated++ }
-
-  return { deactivated, reactivated }
-}

package/lib/ohc/compress/search.mjs

@@ -1,152 +0,0 @@
-import { parseBoundaryId, formatBlockRef } from "../message-ids.mjs"
-import { totalTokens } from "../reaper.mjs"
-
-export function buildSearchContext(state, rawMessages) {
-  const rawMessagesById = new Map()
-  const rawIndexById = new Map()
-
-  for (const msg of rawMessages) {
-    if (msg.info?.id) rawMessagesById.set(msg.info.id, msg)
-  }
-  for (let i = 0; i < rawMessages.length; i++) {
-    const msg = rawMessages[i]
-    if (msg?.info?.id) rawIndexById.set(msg.info.id, i)
-  }
-
-  const summaryByBlockId = new Map()
-  const ms = state.prune?.messages
-  if (ms?.blocksById) {
-    for (const [blockId, block] of ms.blocksById) {
-      if (block.active) summaryByBlockId.set(blockId, block)
-    }
-  }
-
-  return { rawMessages, rawMessagesById, rawIndexById, summaryByBlockId }
-}
-
-export function resolveBoundaryIds(context, state, startId, endId) {
-  const lookup = buildBoundaryLookup(context, state)
-
-  const parsedStart = parseBoundaryId(startId)
-  const parsedEnd = parseBoundaryId(endId)
-
-  if (!parsedStart) throw new Error(`startId "${startId}" is invalid. Use ohcNNNN (message) or bkNN (block).`)
-  if (!parsedEnd) throw new Error(`endId "${endId}" is invalid. Use ohcNNNN (message) or bkNN (block).`)
-
-  const startRef = lookup.get(parsedStart.ref)
-  const endRef = lookup.get(parsedEnd.ref)
-
-  if (!startRef) throw new Error(`startId ${parsedStart.ref} not found in context.`)
-  if (!endRef) throw new Error(`endId ${parsedEnd.ref} not found in context.`)
-
-  if (startRef.rawIndex > endRef.rawIndex) {
-    throw new Error(`startId ${parsedStart.ref} appears after endId ${parsedEnd.ref}. Start must come before end.`)
-  }
-
-  return { startReference: startRef, endReference: endRef }
-}
-
-function buildBoundaryLookup(context, state) {
-  const lookup = new Map()
-
-  for (const [msgRef, rawId] of state.messageIds.byRef) {
-    const rawMsg = context.rawMessagesById.get(rawId)
-    if (!rawMsg) continue
-
-    const rawIndex = context.rawIndexById.get(rawId)
-    if (rawIndex === undefined) continue
-
-    lookup.set(msgRef, { kind: "message", rawIndex, messageId: rawId })
-  }
-
-  const summaries = Array.from(context.summaryByBlockId.values()).sort((a, b) => a.blockId - b.blockId)
-  for (const summary of summaries) {
-    const anchorMsg = context.rawMessagesById.get(summary.anchorMessageId)
-    if (!anchorMsg) continue
-
-    const rawIndex = context.rawIndexById.get(summary.anchorMessageId)
-    if (rawIndex === undefined) continue
-
-    const bkRef = formatBlockRef(summary.blockId)
-    if (!lookup.has(bkRef)) {
-      lookup.set(bkRef, {
-        kind: "compressed-block",
-        rawIndex,
-        blockId: summary.blockId,
-        anchorMessageId: summary.anchorMessageId,
-      })
-    }
-  }
-
-  return lookup
-}
-
-export function resolveSelection(context, startReference, endReference) {
-  const messageIds = []
-  const messageSeen = new Set()
-  const toolIds = []
-  const toolSeen = new Set()
-  const requiredBlockIds = []
-  const requiredBlockSeen = new Set()
-
-  for (let i = startReference.rawIndex; i <= endReference.rawIndex; i++) {
-    const msg = context.rawMessages[i]
-    if (!msg) continue
-
-    const mid = msg.info?.id
-    if (mid && !messageSeen.has(mid)) {
-      messageSeen.add(mid)
-      messageIds.push(mid)
-    }
-
-    const parts = Array.isArray(msg.parts) ? msg.parts : []
-    for (const part of parts) {
-      if (part.type !== "tool" || !part.callID || toolSeen.has(part.callID)) continue
-      toolSeen.add(part.callID)
-      toolIds.push(part.callID)
-    }
-  }
-
-  const selectedIds = new Set(messageIds)
-  const summariesInRange = []
-  for (const block of context.summaryByBlockId.values()) {
-    if (!selectedIds.has(block.anchorMessageId)) continue
-    const idx = context.rawIndexById.get(block.anchorMessageId)
-    if (idx === undefined) continue
-    summariesInRange.push({ blockId: block.blockId, rawIndex: idx })
-  }
-
-  summariesInRange.sort((a, b) => a.rawIndex - b.rawIndex || a.blockId - b.blockId)
-  for (const s of summariesInRange) {
-    if (!requiredBlockSeen.has(s.blockId)) {
-      requiredBlockSeen.add(s.blockId)
-      requiredBlockIds.push(s.blockId)
-    }
-  }
-
-  if (messageIds.length === 0) {
-    throw new Error("No messages found in the specified range.")
-  }
-
-  return { startReference, endReference, messageIds, toolIds, requiredBlockIds }
-}
-
-export function resolveAnchorMessageId(startReference) {
-  if (startReference.kind === "compressed-block") {
-    if (!startReference.anchorMessageId) throw new Error("Compressed block has no anchor message ID")
-    return startReference.anchorMessageId
-  }
-  if (!startReference.messageId) throw new Error("No message ID in start reference")
-  return startReference.messageId
-}
-
-export function validateNonOverlapping(ranges) {
-  const sorted = [...ranges].sort((a, b) => a.selection.startReference.rawIndex - b.selection.startReference.rawIndex)
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = sorted[i - 1]
-    const curr = sorted[i]
-    if (curr.selection.startReference.rawIndex <= prev.selection.endReference.rawIndex) {
-      throw new Error(`content[${prev.index}] (${prev.entry.startId}..${prev.entry.endId}) overlaps content[${curr.index}] (${curr.entry.startId}..${curr.entry.endId}).`)
-    }
-  }
-}

package/lib/ohc/compress/state.mjs

@@ -1,76 +0,0 @@
-export function allocateBlockId(state) {
-  const ms = state.prune.messages
-  const id = ms.nextBlockId
-  ms.nextBlockId++
-  return id
-}
-
-export function allocateRunId(state) {
-  const ms = state.prune.messages
-  const id = ms.nextRunId
-  ms.nextRunId++
-  return id
-}
-
-export function wrapBlockSummary(blockId, summary) {
-  return `[OHC: Compressed bk${blockId}]\n\n${summary}\n<ohc-ref>bk${blockId}</ohc-ref>`
-}
-
-export function applyCompressionState(state, input, selection, anchorMessageId, blockId, storedSummary, consumedBlockIds) {
-  const ms = state.prune.messages
-
-  const block = {
-    blockId,
-    active: true,
-    topic: input.topic,
-    batchTopic: input.batchTopic || input.topic,
-    mode: input.mode || "range",
-    runId: input.runId,
-    compressMessageId: input.compressMessageId,
-    compressCallId: input.compressCallId || null,
-    anchorMessageId,
-    startId: input.startId,
-    endId: input.endId,
-    summary: storedSummary,
-    summaryTokens: input.summaryTokens || 0,
-    compressedTokens: input.compressedTokens || 0,
-    consumedBlockIds: Array.isArray(consumedBlockIds) ? consumedBlockIds : [],
-    deactivatedByBlockId: undefined,
-    deactivatedByUser: false,
-    deactivatedAt: undefined,
-    createdAt: Date.now(),
-  }
-
-  ms.blocksById.set(blockId, block)
-  ms.activeBlockIds.add(blockId)
-
-  if (anchorMessageId) {
-    ms.activeByAnchorMessageId.set(anchorMessageId, blockId)
-  }
-
-  for (const rawMessageId of selection.messageIds) {
-    let entry = ms.byMessageId.get(rawMessageId)
-    if (!entry) {
-      entry = { tokenCount: 0, allBlockIds: [], activeBlockIds: [] }
-      ms.byMessageId.set(rawMessageId, entry)
-    }
-    if (!entry.allBlockIds.includes(blockId)) {
-      entry.allBlockIds.push(blockId)
-    }
-    if (!entry.activeBlockIds.includes(blockId)) {
-      entry.activeBlockIds.push(blockId)
-    }
-  }
-
-  for (const cid of consumedBlockIds) {
-    const cb = ms.blocksById.get(cid)
-    if (cb) {
-      cb.active = false
-      cb.deactivatedAt = Date.now()
-      cb.deactivatedByBlockId = blockId
-      ms.activeBlockIds.delete(cid)
-    }
-  }
-
-  return block
-}