@knikolov/opencode-plugin-simple-memory 1.0.4 → 1.1.1

package/README.md

@@ -18,7 +18,13 @@ A persistent memory plugin for [OpenCode](https://opencode.ai) that enables the
 
 2. Start using memory commands in your conversations.
 
-Memories are stored in `.opencode/memory/` as daily logfmt files.
+Memories are stored in `.opencode/memory/` as daily logfmt files. Existing logfmt files remain readable across plugin updates.
+
+Automatic memory loading and saving are opt-in. When enabled, the plugin can load and save context automatically:
+
+- Before a response, it injects a short relevant-memory block based on the latest user message.
+- When the user explicitly says “remember ...”, it saves that memory automatically.
+- It does not automatically save arbitrary conversation content.
 
 ## Updating
 
@@ -37,7 +43,7 @@ opencode
 
 ## Tools
 
-The plugin provides five tools:
+The plugin provides nine tools:
 
 | Tool | Description |
 |------|-------------|
@@ -46,6 +52,10 @@ The plugin provides five tools:
 | `memory_update` | Update an existing memory |
 | `memory_forget` | Delete a memory (with audit logging) |
 | `memory_list` | List all scopes and types for discovery |
+| `memory_export` | Export memories as `jsonl`, `json`, or `logfmt` |
+| `memory_import` | Import memories from `jsonl`, `json`, or compatible `logfmt` |
+| `memory_compact` | Rewrite memory files chronologically and remove exact duplicates |
+| `memory_context` | Build a compact relevant-memory context pack |
 
 ## Memory Types
 
@@ -96,6 +106,131 @@ AI: [calls memory_forget with type="preference", scope="user",
     Done. I've removed your language preference from memory.
 ```
 
+## Recall Filters
+
+`memory_recall` supports the original filters plus optional richer filters:
+
+- `scope` - filter by scope. By default this keeps the original contains-style matching.
+- `type` - filter by memory type.
+- `query` - rank by matching words across type, scope, content, and tags.
+- `limit` - maximum results. Query results return the best matches; non-query results return the latest memories.
+- `tags` - require all provided tags.
+- `since` / `until` - filter by ISO timestamp or date prefix.
+- `match` - scope matching mode: `contains`, `exact`, or `prefix`.
+
+## Automatic Context
+
+Automatic context loading is disabled by default. When `autoLoad` is enabled, the plugin uses OpenCode chat hooks to remember the latest user message, search active memories, and inject a compact block like this into system context:
+
+```md
+Relevant Memory:
+- context/deploy/staging: Use materialize-deployments.cjs for staging runtime restart
+- context/tests: Run make staging-live-onboarding-e2e for staging onboarding
+```
+
+Automatic context saving is also disabled by default. When `autoSave` is enabled, it is intentionally conservative and only stores explicit requests such as:
+
+```text
+remember that I prefer minimal diffs
+```
+
+That request is stored as a `preference` memory in scope `user` with tag `auto`. Other explicit remember requests default to `context/user` unless they look like a decision, blocker, pattern, or preference.
+
+Configure the behavior through plugin options by using OpenCode's plugin tuple form. The first item is the package name and the second item is the options object passed to the plugin:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@knikolov/opencode-plugin-simple-memory",
+      {
+        "autoLoad": true,
+        "autoSave": true,
+        "autoHookTimeoutMs": 100,
+        "contextLimit": 5,
+        "contextMaxChars": 1200,
+        "contextMinScore": 1,
+        "autoSaveScope": "user"
+      }
+    ]
+  ]
+}
+```
+
+Configuration options:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `autoLoad` | `false` | Enables automatic relevant-memory injection before responses. The plugin uses the latest user message as the search query and appends a compact `Relevant Memory:` block to system context when matches exist. |
+| `autoSave` | `false` | Enables automatic saving only for explicit user requests like `remember that I prefer minimal diffs`. It does not save arbitrary conversation content. |
+| `autoHookTimeoutMs` | `100` | Maximum time each automatic hook can spend on memory work. Hooks fail open after this timeout so memory loading or saving cannot block normal responses. |
+| `contextLimit` | `5` | Maximum number of memories included in the automatic relevant-memory block. |
+| `contextMaxChars` | `1200` | Maximum character budget for the automatic relevant-memory block. Matching memories are truncated to stay within this budget. |
+| `contextMinScore` | `1` when there is a query | Minimum relevance score required for automatic context loading. Increase this to make injected memory stricter; set it lower to include weaker matches. |
+| `autoSaveScope` | `"user"` | Scope used for automatic explicit `remember ...` saves unless the inferred memory itself provides something more specific. |
+
+To keep automatic behavior disabled while retaining manual tools, omit options entirely or set both flags to `false`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@knikolov/opencode-plugin-simple-memory",
+      {
+        "autoLoad": false,
+        "autoSave": false
+      }
+    ]
+  ]
+}
+```
+
+For local development, point OpenCode at the checkout with a `file://` URL and pass the same options:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "file:///absolute/path/to/opencode-plugin-simple-memory/index.ts",
+      {
+        "autoLoad": true,
+        "autoSave": true
+      }
+    ]
+  ]
+}
+```
+
+OpenCode loads plugin configuration at startup. Restart OpenCode after changing configuration.
+
+## Storage Format
+
+Memory files are daily logfmt files named `YYYY-MM-DD.logfmt` under `.opencode/memory/`.
+
+Each active memory record uses these fields:
+
+```logfmt
+ts=2026-05-28T10:00:00.000Z type=context scope=api content="Remember this" issue=#51 tags=backend,current
+```
+
+Compatibility notes:
+
+- Existing unquoted `scope`, `issue`, and `tags` records remain readable.
+- New records quote fields only when needed, except `content`, which is always quoted.
+- Multiline content is stored on one physical line using escaped `\n` sequences and is restored during recall/export.
+- Updates and deletes append audit records to `.opencode/memory/deletions.logfmt`.
+
+## Maintenance
+
+`memory_forget` keeps its original behavior when called with only `scope`, `type`, and `reason`: it deletes all exact matches. To delete only one matching memory, pass `query`.
+
+`memory_export` and `memory_import` can move memories between projects or back up the store. `jsonl` is the default export/import format.
+
+`memory_compact` removes exact duplicate active records and rewrites active memory files in chronological order. Use `dryRun: true` to preview the change.
+
 ## Local Development
 
 Clone the repository and install dependencies:
@@ -106,6 +241,13 @@ cd opencode-plugin-simple-memory
 bun install
 ```
 
+Run checks:
+
+```bash
+bun test
+bun run typecheck
+```
+
 Point your OpenCode config to the local checkout via a `file://` URL:
 
 ```json

package/package.json

@@ -1,17 +1,32 @@
 {
   "name": "@knikolov/opencode-plugin-simple-memory",
   "module": "index.ts",
-  "version": "1.0.4",
+  "version": "1.1.1",
+  "description": "Persistent project memory tools for OpenCode",
   "author": "knikolov",
   "repository": "https://github.com/cnicolov/opencode-plugin-simple-memory",
+  "homepage": "https://github.com/cnicolov/opencode-plugin-simple-memory#readme",
+  "bugs": "https://github.com/cnicolov/opencode-plugin-simple-memory/issues",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "memory",
+    "agent"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bun run tsc --noEmit"
+  },
   "files": [
     "index.ts",
-    "src"
+    "src/index.ts"
   ],
   "license": "MIT",
   "type": "module",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.153"
+  },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.0.153",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/src/index.ts

@@ -1,53 +1,186 @@
 import { type Plugin, tool } from "@opencode-ai/plugin"
+import { appendFile, mkdir, rename } from "node:fs/promises"
+import { join } from "node:path"
 
-let MEMORY_DIR = ".opencode/memory"
+const MEMORY_TYPES = ["decision", "learning", "preference", "blocker", "context", "pattern"] as const
 
-const getMemoryFile = () => {
-  const date = new Date().toISOString().split("T")[0]
-  return Bun.file(`${MEMORY_DIR}/${date}.logfmt`)
-}
-
-const ensureDir = async () => {
-  const dir = Bun.file(MEMORY_DIR)
-  if (!(await dir.exists())) {
-    await Bun.$`mkdir -p ${MEMORY_DIR}`
-  }
-}
+type MemoryType = typeof MEMORY_TYPES[number]
 
 interface Memory {
   ts: string
-  type: string
+  type: MemoryType
   scope: string
   content: string
   issue?: string
   tags?: string[]
 }
 
+interface MemoryEntry {
+  memory: Memory
+  filepath: string
+  lineIndex: number
+}
+
+interface MemoryStore {
+  dir: string
+  ensureDir(): Promise<void>
+  appendMemory(memory: Memory): Promise<void>
+  appendDeletion(memory: Memory, reason: string): Promise<void>
+  readEntries(): Promise<MemoryEntry[]>
+  readDeletionLines(): Promise<string[]>
+  rewriteFile(filepath: string, lines: string[]): Promise<void>
+}
+
+interface PluginOptions {
+  autoLoad?: boolean
+  autoSave?: boolean
+  autoHookTimeoutMs?: number
+  contextLimit?: number
+  contextMaxChars?: number
+  contextMinScore?: number
+  autoSaveScope?: string
+}
+
+interface ContextOptions {
+  query?: string
+  scope?: string
+  tags?: string[]
+  types?: MemoryType[]
+  limit?: number
+  maxChars?: number
+  minScore?: number
+}
+
+const isMemoryType = (value: string): value is MemoryType => MEMORY_TYPES.includes(value as MemoryType)
+
+const dateFromTs = (ts: string) => ts.split("T")[0] || new Date().toISOString().split("T")[0]!
+
+const escapeValue = (value: string) => value
+  .replace(/\\/g, "\\\\")
+  .replace(/\n/g, "\\n")
+  .replace(/\r/g, "\\r")
+  .replace(/"/g, '\\"')
+
+const unescapeValue = (value: string) => {
+  let result = ""
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i]
+    if (char !== "\\") {
+      result += char
+      continue
+    }
+
+    const next = value[++i]
+    if (next === "n") result += "\n"
+    else if (next === "r") result += "\r"
+    else if (next === '"') result += '"'
+    else if (next === "\\") result += "\\"
+    else if (next !== undefined) result += `\\${next}`
+  }
+  return result
+}
+
+const needsQuotes = (value: string) => value === "" || /\s|"|\\/.test(value)
+
+const field = (key: string, value: string, alwaysQuote = false) => {
+  if (!alwaysQuote && !needsQuotes(value)) return `${key}=${value}`
+  return `${key}="${escapeValue(value)}"`
+}
+
+const parseFields = (line: string): Record<string, string> => {
+  const fields: Record<string, string> = {}
+  let index = 0
+
+  while (index < line.length) {
+    while (line[index] === " ") index++
+
+    const keyStart = index
+    while (index < line.length && line[index] !== "=" && line[index] !== " ") index++
+    const key = line.slice(keyStart, index)
+    if (!key || line[index] !== "=") break
+    index++
+
+    if (line[index] === '"') {
+      index++
+      let value = ""
+      while (index < line.length) {
+        const char = line[index]
+        if (char === '"') {
+          index++
+          break
+        }
+        if (char === "\\" && index + 1 < line.length) {
+          value += char + line[index + 1]
+          index += 2
+          continue
+        }
+        value += char
+        index++
+      }
+      fields[key] = unescapeValue(value)
+      continue
+    }
+
+    const valueStart = index
+    while (index < line.length && line[index] !== " ") index++
+    fields[key] = line.slice(valueStart, index)
+  }
+
+  return fields
+}
+
 const parseLine = (line: string): Memory | null => {
-  const tsMatch = line.match(/ts=([^\s]+)/)
-  const typeMatch = line.match(/type=([^\s]+)/)
-  const scopeMatch = line.match(/scope=([^\s]+)/)
-  const contentMatch = line.match(/content="([^"]*(?:\\"[^"]*)*)"/)
-  const issueMatch = line.match(/issue=([^\s]+)/)
-  const tagsMatch = line.match(/tags=([^\s]+)/)
+  const fields = parseFields(line)
+  const { ts, type, scope } = fields
 
-  if (!tsMatch?.[1] || !typeMatch?.[1] || !scopeMatch?.[1]) return null
+  if (!ts || !type || !scope || !isMemoryType(type)) return null
 
   return {
-    ts: tsMatch[1],
-    type: typeMatch[1],
-    scope: scopeMatch[1],
-    content: contentMatch?.[1]?.replace(/\\"/g, '"') || "",
-    issue: issueMatch?.[1],
-    tags: tagsMatch?.[1]?.split(","),
+    ts,
+    type,
+    scope,
+    content: fields.content || "",
+    issue: fields.issue,
+    tags: fields.tags ? fields.tags.split(",").filter(Boolean) : undefined,
   }
 }
 
-const formatMemory = (m: Memory): string => {
-  const date = m.ts.split("T")[0]
-  const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : ""
-  const issue = m.issue ? ` (${m.issue})` : ""
-  return `[${date}] ${m.type}/${m.scope}: ${m.content}${issue}${tags}`
+const encodeMemory = (memory: Memory): string => {
+  const parts = [
+    field("ts", memory.ts),
+    field("type", memory.type),
+    field("scope", memory.scope),
+    field("content", memory.content, true),
+  ]
+
+  if (memory.issue) parts.push(field("issue", memory.issue))
+  if (memory.tags?.length) parts.push(field("tags", memory.tags.join(",")))
+
+  return parts.join(" ")
+}
+
+const encodeDeletion = (memory: Memory, reason: string): string => {
+  const parts = [
+    field("ts", new Date().toISOString()),
+    field("action", "deleted"),
+    field("original_ts", memory.ts),
+    field("type", memory.type),
+    field("scope", memory.scope),
+    field("content", memory.content, true),
+    field("reason", reason, true),
+  ]
+
+  if (memory.issue) parts.push(field("issue", memory.issue))
+  if (memory.tags?.length) parts.push(field("tags", memory.tags.join(",")))
+
+  return parts.join(" ")
+}
+
+const formatMemory = (memory: Memory): string => {
+  const date = dateFromTs(memory.ts)
+  const tags = memory.tags?.length ? ` [${memory.tags.join(", ")}]` : ""
+  const issue = memory.issue ? ` (${memory.issue})` : ""
+  return `[${date}] ${memory.type}/${memory.scope}: ${memory.content}${issue}${tags}`
 }
 
 const scoreMatch = (memory: Memory, words: string[]): number => {
@@ -57,304 +190,587 @@ const scoreMatch = (memory: Memory, words: string[]): number => {
     if (searchable.includes(word)) score++
     if (memory.scope.toLowerCase() === word) score += 2
     if (memory.type.toLowerCase() === word) score += 2
+    if (memory.tags?.some((tag) => tag.toLowerCase() === word)) score += 2
   }
   return score
 }
 
-const remember = tool({
-  description: "Store a memory (decision, learning, preference, blocker, context, pattern)",
-  args: {
-    type: tool.schema
-      .enum(["decision", "learning", "preference", "blocker", "context", "pattern"])
-      .describe("Type of memory"),
-    scope: tool.schema.string().describe("Scope/area (e.g., auth, api, mobile)"),
-    content: tool.schema.string().describe("The memory content"),
-    issue: tool.schema.string().optional().describe("Related GitHub issue (e.g., #51)"),
-    tags: tool.schema.array(tool.schema.string()).optional().describe("Additional tags"),
-  },
-  async execute(args) {
-    await ensureDir()
+const typePriority: Record<MemoryType, number> = {
+  preference: 6,
+  decision: 5,
+  blocker: 4,
+  pattern: 3,
+  context: 2,
+  learning: 1,
+}
 
-    const ts = new Date().toISOString()
-    const issue = args.issue ? ` issue=${args.issue}` : ""
-    const tags = args.tags?.length ? ` tags=${args.tags.join(",")}` : ""
-    const content = args.content.replace(/"/g, '\\"')
-    const line = `ts=${ts} type=${args.type} scope=${args.scope} content="${content}"${issue}${tags}\n`
+const truncate = (value: string, maxLength: number) => {
+  const normalized = value.replace(/\s+/g, " ").trim()
+  if (normalized.length <= maxLength) return normalized
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`
+}
 
-    const file = getMemoryFile()
-    const existing = (await file.exists()) ? await file.text() : ""
-    await Bun.write(file, existing + line)
+const buildContextPack = (memories: Memory[], options: ContextOptions) => {
+  const query = options.query?.trim()
+  const words = query?.toLowerCase().split(/\s+/).filter(Boolean) || []
+  const minScore = options.minScore ?? (query ? 1 : 0)
+  const maxChars = options.maxChars && options.maxChars > 0 ? Math.floor(options.maxChars) : 1200
+  const limit = options.limit && options.limit > 0 ? Math.floor(options.limit) : 5
+  let results = memories
+
+  if (options.scope) results = results.filter((memory) => matchesScope(memory, options.scope!, "contains"))
+  if (options.types?.length) results = results.filter((memory) => options.types!.includes(memory.type))
+  if (options.tags?.length) {
+    const tags = options.tags.map((tag) => tag.toLowerCase())
+    results = results.filter((memory) => {
+      const memoryTags = memory.tags?.map((tag) => tag.toLowerCase()) || []
+      return tags.every((tag) => memoryTags.includes(tag))
+    })
+  }
 
-    return `Remembered: ${args.type} in ${args.scope}`
-  },
-})
+  const ranked = results
+    .map((memory) => ({
+      memory,
+      score: words.length ? scoreMatch(memory, words) : 0,
+    }))
+    .filter((item) => item.score >= minScore)
+    .sort((a, b) => {
+      const priority = typePriority[b.memory.type] - typePriority[a.memory.type]
+      return b.score - a.score || priority || b.memory.ts.localeCompare(a.memory.ts)
+    })
+    .slice(0, limit)
+
+  if (!ranked.length) return ""
+
+  const lines = ["Relevant Memory:"]
+  let used = lines[0]!.length + 1
+
+  for (const { memory } of ranked) {
+    const prefix = `- ${memory.type}/${memory.scope}: `
+    const remaining = maxChars - used - prefix.length
+    if (remaining <= 20) break
+
+    const line = `${prefix}${truncate(memory.content, Math.min(remaining, 260))}`
+    lines.push(line)
+    used += line.length + 1
+  }
 
-const getAllMemories = async (): Promise<Memory[]> => {
-  const glob = new Bun.Glob("*.logfmt")
-  const files = await Array.fromAsync(glob.scan(MEMORY_DIR))
+  return lines.length > 1 ? lines.join("\n") : ""
+}
 
-  if (!files.length) return []
+const textFromParts = (parts: unknown[]) => parts
+  .map((part) => {
+    if (typeof part !== "object" || !part) return ""
+    if (!("type" in part) || part.type !== "text") return ""
+    if (!("text" in part) || typeof part.text !== "string") return ""
+    return part.text
+  })
+  .filter(Boolean)
+  .join("\n")
+  .trim()
+
+const inferExplicitMemory = (text: string, defaultScope: string): Omit<Memory, "ts"> | null => {
+  if (/\b(don't|do not|dont)\s+remember\b/i.test(text)) return null
+
+  const match = text.match(/(?:^|\b)(?:please\s+)?remember(?:\s+that|:)?\s+([\s\S]+)$/i)
+  const content = match?.[1]?.trim()
+  if (!content) return null
+
+  const lower = content.toLowerCase()
+  const type: MemoryType = lower.includes("prefer")
+    ? "preference"
+    : lower.includes("decided") || lower.includes("decision")
+      ? "decision"
+      : lower.includes("blocked") || lower.includes("blocker")
+        ? "blocker"
+        : lower.includes("pattern") || lower.includes("always")
+          ? "pattern"
+          : "context"
 
-  const lines: string[] = []
-  for (const filename of files) {
-    if (filename === "deletions.logfmt") continue // skip audit log
-    const file = Bun.file(`${MEMORY_DIR}/${filename}`)
-    const text = await file.text()
-    lines.push(...text.trim().split("\n").filter(Boolean))
+  return {
+    type,
+    scope: defaultScope,
+    content,
+    tags: ["auto"],
   }
+}
 
-  return lines.map(parseLine).filter((m): m is Memory => m !== null)
+const withTimeout = async <T>(promise: Promise<T>, timeoutMs: number): Promise<T | undefined> => {
+  let timeout: Timer | undefined
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<undefined>((resolve) => {
+        timeout = setTimeout(() => resolve(undefined), timeoutMs)
+      }),
+    ])
+  } finally {
+    if (timeout) clearTimeout(timeout)
+  }
 }
 
-const logDeletion = async (memory: Memory, reason: string) => {
-  await ensureDir()
-  const ts = new Date().toISOString()
-  const content = memory.content.replace(/"/g, '\\"')
-  const originalTs = memory.ts
-  const issue = memory.issue ? ` issue=${memory.issue}` : ""
-  const tags = memory.tags?.length ? ` tags=${memory.tags.join(",")}` : ""
-  const escapedReason = reason.replace(/"/g, '\\"')
-  const line = `ts=${ts} action=deleted original_ts=${originalTs} type=${memory.type} scope=${memory.scope} content="${content}" reason="${escapedReason}"${issue}${tags}\n`
-
-  const file = Bun.file(`${MEMORY_DIR}/deletions.logfmt`)
-  const existing = (await file.exists()) ? await file.text() : ""
-  await Bun.write(file, existing + line)
+const createStore = (dir: string): MemoryStore => ({
+  dir,
+  async ensureDir() {
+    await mkdir(dir, { recursive: true })
+  },
+  async appendMemory(memory) {
+    await this.ensureDir()
+    await appendFile(join(dir, `${dateFromTs(memory.ts)}.logfmt`), `${encodeMemory(memory)}\n`, "utf8")
+  },
+  async appendDeletion(memory, reason) {
+    await this.ensureDir()
+    await appendFile(join(dir, "deletions.logfmt"), `${encodeDeletion(memory, reason)}\n`, "utf8")
+  },
+  async readEntries() {
+    await this.ensureDir()
+    const glob = new Bun.Glob("*.logfmt")
+    const files = (await Array.fromAsync(glob.scan(dir)))
+      .filter((filename) => filename !== "deletions.logfmt")
+      .sort()
+    const entries: MemoryEntry[] = []
+
+    for (const filename of files) {
+      const filepath = join(dir, filename)
+      const file = Bun.file(filepath)
+      const text = await file.text()
+      const lines = text.split("\n")
+
+      lines.forEach((line, lineIndex) => {
+        const memory = parseLine(line)
+        if (memory) entries.push({ memory, filepath, lineIndex })
+      })
+    }
+
+    return entries.sort((a, b) => a.memory.ts.localeCompare(b.memory.ts))
+  },
+  async readDeletionLines() {
+    const file = Bun.file(join(dir, "deletions.logfmt"))
+    if (!(await file.exists())) return []
+    return (await file.text()).trim().split("\n").filter(Boolean)
+  },
+  async rewriteFile(filepath, lines) {
+    await this.ensureDir()
+    const tmp = `${filepath}.${crypto.randomUUID()}.tmp`
+    await Bun.write(tmp, lines.length ? `${lines.join("\n")}\n` : "")
+    await rename(tmp, filepath)
+  },
+})
+
+const matchesScope = (memory: Memory, scope: string, mode: "contains" | "exact" | "prefix") => {
+  if (mode === "exact") return memory.scope === scope
+  if (mode === "prefix") return memory.scope.startsWith(scope)
+  return memory.scope === scope || memory.scope.includes(scope)
 }
 
-const recall = tool({
-  description: "Retrieve memories by scope, type, or search query",
+const startOfDateFilter = (value: string) => value.includes("T") ? value : `${value}T00:00:00.000Z`
+
+const endOfDateFilter = (value: string) => value.includes("T") ? value : `${value}T23:59:59.999Z`
+
+const filterMemories = (
+  memories: Memory[],
   args: {
-    scope: tool.schema.string().optional().describe("Filter by scope"),
-    type: tool.schema
-      .enum(["decision", "learning", "preference", "blocker", "context", "pattern"])
-      .optional()
-      .describe("Filter by type"),
-    query: tool.schema.string().optional().describe("Search term (space-separated words, matches any)"),
-    limit: tool.schema.number().optional().describe("Max results (default 20)"),
+    scope?: string
+    type?: MemoryType
+    query?: string
+    tags?: string[]
+    since?: string
+    until?: string
+    match?: "contains" | "exact" | "prefix"
   },
-  async execute(args) {
-    let results = await getAllMemories()
+) => {
+  let results = memories
+  const match = args.match || "contains"
+
+  if (args.scope) results = results.filter((memory) => matchesScope(memory, args.scope!, match))
+  if (args.type) results = results.filter((memory) => memory.type === args.type)
+  if (args.tags?.length) {
+    const tags = args.tags.map((tag) => tag.toLowerCase())
+    results = results.filter((memory) => {
+      const memoryTags = memory.tags?.map((tag) => tag.toLowerCase()) || []
+      return tags.every((tag) => memoryTags.includes(tag))
+    })
+  }
+  if (args.since) {
+    const since = startOfDateFilter(args.since)
+    results = results.filter((memory) => memory.ts >= since)
+  }
+  if (args.until) {
+    const until = endOfDateFilter(args.until)
+    results = results.filter((memory) => memory.ts <= until)
+  }
 
-    if (!results.length) return "No memories found"
+  if (!args.query) return results
 
-    const totalCount = results.length
+  const words = args.query.toLowerCase().split(/\s+/).filter(Boolean)
+  return results
+    .map((memory) => ({ memory, score: scoreMatch(memory, words) }))
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score || b.memory.ts.localeCompare(a.memory.ts))
+    .map((item) => item.memory)
+}
 
-    if (args.scope) {
-      results = results.filter((m) => m.scope === args.scope || m.scope.includes(args.scope!))
-    }
-    if (args.type) {
-      results = results.filter((m) => m.type === args.type)
+const chooseUpdateTarget = (matches: MemoryEntry[], query?: string) => {
+  if (matches.length <= 1) return { target: matches[0], message: undefined }
+  if (!query) {
+    return {
+      target: undefined,
+      message: `Found ${matches.length} memories for ${matches[0]!.memory.type}/${matches[0]!.memory.scope}. Provide a query to select which one to update, or use recall to see all matches.`,
     }
+  }
 
-    if (args.query) {
-      const words = args.query.toLowerCase().split(/\s+/).filter(Boolean)
-      const scored = results
-        .map((m) => ({ memory: m, score: scoreMatch(m, words) }))
-        .filter((x) => x.score > 0)
-        .sort((a, b) => b.score - a.score)
-      results = scored.map((x) => x.memory)
-    }
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean)
+  const scored = matches
+    .map((entry) => ({ ...entry, score: scoreMatch(entry.memory, words) }))
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || b.memory.ts.localeCompare(a.memory.ts))
 
-    const filteredCount = results.length
-    const limit = args.limit || 20
-    const limited = results.slice(-limit)
+  if (!scored.length) {
+    return {
+      target: undefined,
+      message: `Found ${matches.length} memories for ${matches[0]!.memory.type}/${matches[0]!.memory.scope}, but none matched query "${query}". Use recall to see all matches.`,
+    }
+  }
 
-    if (!limited.length) return "No matching memories"
+  return { target: scored[0], message: undefined }
+}
 
-    const header = filteredCount > limit
-      ? `Found ${filteredCount} memories (showing last ${limit} of ${totalCount} total)\n\n`
-      : filteredCount !== totalCount
-        ? `Found ${filteredCount} memories (${totalCount} total)\n\n`
-        : `Found ${filteredCount} memories\n\n`
+const createTools = (store: MemoryStore) => {
+  const remember = tool({
+    description: "Store a memory (decision, learning, preference, blocker, context, pattern)",
+    args: {
+      type: tool.schema.enum(MEMORY_TYPES).describe("Type of memory"),
+      scope: tool.schema.string().describe("Scope/area (e.g., auth, api, mobile)"),
+      content: tool.schema.string().describe("The memory content"),
+      issue: tool.schema.string().optional().describe("Related GitHub issue (e.g., #51)"),
+      tags: tool.schema.array(tool.schema.string()).optional().describe("Additional tags"),
+    },
+    async execute(args) {
+      await store.appendMemory({
+        ts: new Date().toISOString(),
+        type: args.type,
+        scope: args.scope.trim(),
+        content: args.content,
+        issue: args.issue?.trim() || undefined,
+        tags: args.tags?.map((tag) => tag.trim()).filter(Boolean),
+      })
 
-    return header + limited.map(formatMemory).join("\n")
-  },
-})
+      return `Remembered: ${args.type} in ${args.scope}`
+    },
+  })
+
+  const recall = tool({
+    description: "Retrieve memories by scope, type, tag, date, or search query",
+    args: {
+      scope: tool.schema.string().optional().describe("Filter by scope"),
+      type: tool.schema.enum(MEMORY_TYPES).optional().describe("Filter by type"),
+      query: tool.schema.string().optional().describe("Search term (space-separated words, matches any)"),
+      limit: tool.schema.number().optional().describe("Max results (default 20)"),
+      tags: tool.schema.array(tool.schema.string()).optional().describe("Only include memories with all of these tags"),
+      since: tool.schema.string().optional().describe("Only include memories at or after this ISO timestamp/date"),
+      until: tool.schema.string().optional().describe("Only include memories at or before this ISO timestamp/date"),
+      match: tool.schema.enum(["contains", "exact", "prefix"]).optional().describe("Scope match mode (default contains, matching earlier behavior)"),
+    },
+    async execute(args) {
+      const memories = (await store.readEntries()).map((entry) => entry.memory)
 
-const update = tool({
-  description: "Update an existing memory by scope and type (finds matching memory and updates its content)",
-  args: {
-    scope: tool.schema.string().describe("Scope of memory to update"),
-    type: tool.schema
-      .enum(["decision", "learning", "preference", "blocker", "context", "pattern"])
-      .describe("Type of memory"),
-    content: tool.schema.string().describe("The new content for the memory"),
-    query: tool.schema.string().optional().describe("Search term to find specific memory if multiple exist"),
-    issue: tool.schema.string().optional().describe("Update related GitHub issue (e.g., #51)"),
-    tags: tool.schema.array(tool.schema.string()).optional().describe("Update tags"),
-  },
-  async execute(args) {
-    const glob = new Bun.Glob("*.logfmt")
-    const files = await Array.fromAsync(glob.scan(MEMORY_DIR))
+      if (!memories.length) return "No memories found"
 
-    if (!files.length) return "No memory files found"
+      const totalCount = memories.length
+      const results = filterMemories(memories, args)
+      const filteredCount = results.length
+      const limit = args.limit && args.limit > 0 ? Math.floor(args.limit) : 20
+      const limited = args.query ? results.slice(0, limit) : results.slice(-limit)
 
-    // Find matching memories
-    const matches: { memory: Memory; filepath: string; lineIndex: number }[] = []
+      if (!limited.length) return "No matching memories"
 
-    for (const filename of files) {
-      if (filename === "deletions.logfmt") continue
-      const filepath = `${MEMORY_DIR}/${filename}`
-      const file = Bun.file(filepath)
-      const text = await file.text()
-      const lines = text.split("\n")
+      const header = filteredCount > limit
+        ? `Found ${filteredCount} memories (showing ${args.query ? "best" : "last"} ${limit} of ${totalCount} total)\n\n`
+        : filteredCount !== totalCount
+          ? `Found ${filteredCount} memories (${totalCount} total)\n\n`
+          : `Found ${filteredCount} memories\n\n`
 
-      lines.forEach((line, lineIndex) => {
-        const memory = parseLine(line)
-        if (!memory) return
-        if (memory.scope === args.scope && memory.type === args.type) {
-          matches.push({ memory, filepath, lineIndex })
-        }
+      return header + limited.map(formatMemory).join("\n")
+    },
+  })
+
+  const update = tool({
+    description: "Update an existing memory by scope and type (finds matching memory and updates its content)",
+    args: {
+      scope: tool.schema.string().describe("Scope of memory to update"),
+      type: tool.schema.enum(MEMORY_TYPES).describe("Type of memory"),
+      content: tool.schema.string().describe("The new content for the memory"),
+      query: tool.schema.string().optional().describe("Search term to find specific memory if multiple exist"),
+      issue: tool.schema.string().optional().describe("Update related GitHub issue (e.g., #51)"),
+      tags: tool.schema.array(tool.schema.string()).optional().describe("Update tags"),
+    },
+    async execute(args) {
+      const matches = (await store.readEntries()).filter((entry) => entry.memory.scope === args.scope && entry.memory.type === args.type)
+
+      if (!matches.length) return `No memories found for ${args.type} in ${args.scope}`
+
+      const { target, message } = chooseUpdateTarget(matches, args.query)
+      if (message) return message
+      if (!target) return `No memories found for ${args.type} in ${args.scope}`
+
+      await store.appendDeletion(target.memory, `Updated to: ${args.content}`)
+
+      const file = Bun.file(target.filepath)
+      const lines = (await file.text()).split("\n")
+      lines[target.lineIndex] = encodeMemory({
+        ts: new Date().toISOString(),
+        type: args.type,
+        scope: args.scope,
+        content: args.content,
+        issue: args.issue !== undefined ? args.issue : target.memory.issue,
+        tags: args.tags !== undefined ? args.tags : target.memory.tags,
       })
-    }
+      await store.rewriteFile(target.filepath, lines.filter((line) => line.length > 0))
 
-    if (matches.length === 0) {
-      return `No memories found for ${args.type} in ${args.scope}`
-    }
+      return `Updated ${args.type} in ${args.scope}: "${args.content}"`
+    },
+  })
 
-    // If multiple matches and query provided, filter by query
-    let target: typeof matches[number] | undefined = matches[0]
-    if (matches.length > 1) {
-      if (args.query) {
-        const words = args.query.toLowerCase().split(/\s+/).filter(Boolean)
-        const scored = matches
-          .map((m) => ({ ...m, score: scoreMatch(m.memory, words) }))
-          .filter((x) => x.score > 0)
-          .sort((a, b) => b.score - a.score)
+  const listMemories = tool({
+    description: "List all unique scopes and types in memory for discovery",
+    args: {},
+    async execute() {
+      const memories = (await store.readEntries()).map((entry) => entry.memory)
 
-        if (scored.length === 0) {
-          return `Found ${matches.length} memories for ${args.type}/${args.scope}, but none matched query "${args.query}". Use recall to see all matches.`
-        }
-        target = scored[0]
-      } else {
-        return `Found ${matches.length} memories for ${args.type}/${args.scope}. Provide a query to select which one to update, or use recall to see all matches.`
-      }
-    }
+      if (!memories.length) return "No memories found"
 
-    if (!target) {
-      return `No memories found for ${args.type} in ${args.scope}`
-    }
+      const scopes = new Map<string, number>()
+      const types = new Map<string, number>()
+      const scopeTypes = new Map<string, Set<string>>()
 
-    // Log the old version before updating
-    await logDeletion(target.memory, `Updated to: ${args.content}`)
+      for (const memory of memories) {
+        scopes.set(memory.scope, (scopes.get(memory.scope) || 0) + 1)
+        types.set(memory.type, (types.get(memory.type) || 0) + 1)
+        if (!scopeTypes.has(memory.scope)) scopeTypes.set(memory.scope, new Set())
+        scopeTypes.get(memory.scope)!.add(memory.type)
+      }
 
-    // Update the memory
-    const file = Bun.file(target.filepath)
-    const text = await file.text()
-    const lines = text.split("\n")
+      const blockers = memories.filter((memory) => memory.type === "blocker")
+      const lines = [`Total memories: ${memories.length}`, "", "Scopes:"]
+      for (const [scope, count] of [...scopes.entries()].sort((a, b) => b[1] - a[1])) {
+        const typeList = [...scopeTypes.get(scope)!].join(", ")
+        lines.push(`  ${scope}: ${count} (${typeList})`)
+      }
+      lines.push("", "Types:")
+      for (const [type, count] of [...types.entries()].sort((a, b) => b[1] - a[1])) {
+        lines.push(`  ${type}: ${count}`)
+      }
+      if (blockers.length) lines.push("", `Open blockers: ${blockers.length}`)
 
-    const ts = new Date().toISOString()
-    const issue = args.issue !== undefined ? args.issue : target.memory.issue
-    const tags = args.tags !== undefined ? args.tags : target.memory.tags
-    const issueStr = issue ? ` issue=${issue}` : ""
-    const tagsStr = tags?.length ? ` tags=${tags.join(",")}` : ""
-    const content = args.content.replace(/"/g, '\\"')
-    const newLine = `ts=${ts} type=${args.type} scope=${args.scope} content="${content}"${issueStr}${tagsStr}`
+      return lines.join("\n")
+    },
+  })
+
+  const forget = tool({
+    description: "Delete memories by scope and type (optionally narrowed by query; logs deletion for audit)",
+    args: {
+      scope: tool.schema.string().describe("Scope of memory to delete"),
+      type: tool.schema.enum(MEMORY_TYPES).describe("Type of memory"),
+      reason: tool.schema.string().describe("Why this is being deleted (for audit purposes)"),
+      query: tool.schema.string().optional().describe("Optional search term to delete only the best matching memory"),
+    },
+    async execute(args) {
+      const entries = await store.readEntries()
+      let matches = entries.filter((entry) => entry.memory.scope === args.scope && entry.memory.type === args.type)
 
-    lines[target.lineIndex] = newLine
-    await Bun.write(target.filepath, lines.join("\n"))
+      if (args.query && matches.length) {
+        const words = args.query.toLowerCase().split(/\s+/).filter(Boolean)
+        const scored = matches
+          .map((entry) => ({ ...entry, score: scoreMatch(entry.memory, words) }))
+          .filter((entry) => entry.score > 0)
+          .sort((a, b) => b.score - a.score || b.memory.ts.localeCompare(a.memory.ts))
+        matches = scored[0] ? [scored[0]] : []
+      }
 
-    return `Updated ${args.type} in ${args.scope}: "${args.content}"`
-  },
-})
+      if (!matches.length) return `No memories found for ${args.type} in ${args.scope}`
 
-const listMemories = tool({
-  description: "List all unique scopes and types in memory for discovery",
-  args: {},
-  async execute() {
-    const memories = await getAllMemories()
+      const byFile = new Map<string, Set<number>>()
+      for (const match of matches) {
+        if (!byFile.has(match.filepath)) byFile.set(match.filepath, new Set())
+        byFile.get(match.filepath)!.add(match.lineIndex)
+      }
 
-    if (!memories.length) return "No memories found"
+      for (const [filepath, lineIndexes] of byFile) {
+        const lines = (await Bun.file(filepath).text()).split("\n")
+        const filtered = lines.filter((line, index) => line.length > 0 && !lineIndexes.has(index))
+        await store.rewriteFile(filepath, filtered)
+      }
+      for (const match of matches) await store.appendDeletion(match.memory, args.reason)
 
-    const scopes = new Map<string, number>()
-    const types = new Map<string, number>()
-    const scopeTypes = new Map<string, Set<string>>()
+      return `Deleted ${matches.length} ${args.type} memory(s) from ${args.scope}. Reason: ${args.reason}\nDeletions logged to ${join(store.dir, "deletions.logfmt")}`
+    },
+  })
 
-    for (const m of memories) {
-      scopes.set(m.scope, (scopes.get(m.scope) || 0) + 1)
-      types.set(m.type, (types.get(m.type) || 0) + 1)
-      if (!scopeTypes.has(m.scope)) scopeTypes.set(m.scope, new Set())
-      scopeTypes.get(m.scope)!.add(m.type)
-    }
+  const exportMemories = tool({
+    description: "Export memories as jsonl, json, or logfmt",
+    args: {
+      format: tool.schema.enum(["jsonl", "json", "logfmt"]).optional().describe("Export format (default jsonl)"),
+      includeDeletions: tool.schema.boolean().optional().describe("Include deletion audit lines for logfmt exports"),
+    },
+    async execute(args) {
+      const format = args.format || "jsonl"
+      const memories = (await store.readEntries()).map((entry) => entry.memory)
+
+      if (format === "json") return JSON.stringify(memories, null, 2)
+      if (format === "logfmt") {
+        const lines = memories.map(encodeMemory)
+        if (args.includeDeletions) lines.push(...await store.readDeletionLines())
+        return lines.join("\n")
+      }
+      return memories.map((memory) => JSON.stringify(memory)).join("\n")
+    },
+  })
 
-    const lines: string[] = []
-    lines.push(`Total memories: ${memories.length}`)
-    lines.push("")
-    lines.push("Scopes:")
-    for (const [scope, count] of [...scopes.entries()].sort((a, b) => b[1] - a[1])) {
-      const typeList = [...scopeTypes.get(scope)!].join(", ")
-      lines.push(`  ${scope}: ${count} (${typeList})`)
-    }
-    lines.push("")
-    lines.push("Types:")
-    for (const [type, count] of [...types.entries()].sort((a, b) => b[1] - a[1])) {
-      lines.push(`  ${type}: ${count}`)
-    }
+  const importMemories = tool({
+    description: "Import memories from jsonl, json, or compatible logfmt",
+    args: {
+      data: tool.schema.string().describe("Memory data to import"),
+      format: tool.schema.enum(["jsonl", "json", "logfmt"]).optional().describe("Import format (default jsonl)"),
+    },
+    async execute(args) {
+      const format = args.format || "jsonl"
+      const imported: Memory[] = []
+
+      if (format === "json") {
+        const parsed = JSON.parse(args.data) as Memory[]
+        imported.push(...parsed)
+      } else if (format === "logfmt") {
+        imported.push(...args.data.split("\n").map(parseLine).filter((memory): memory is Memory => memory !== null))
+      } else {
+        imported.push(...args.data.split("\n").filter(Boolean).map((line) => JSON.parse(line) as Memory))
+      }
 
-    return lines.join("\n")
-  },
-})
+      let count = 0
+      for (const memory of imported) {
+        if (!isMemoryType(memory.type)) continue
+        await store.appendMemory({
+          ts: memory.ts || new Date().toISOString(),
+          type: memory.type,
+          scope: memory.scope,
+          content: memory.content,
+          issue: memory.issue,
+          tags: memory.tags,
+        })
+        count++
+      }
 
-const forget = tool({
-  description: "Delete a memory by scope and type (removes matching lines from all memory files, logs deletion for audit)",
-  args: {
-    scope: tool.schema.string().describe("Scope of memory to delete"),
-    type: tool.schema
-      .enum(["decision", "learning", "preference", "blocker", "context", "pattern"])
-      .describe("Type of memory"),
-    reason: tool.schema.string().describe("Why this is being deleted (for audit purposes)"),
-  },
-  async execute(args) {
-    const glob = new Bun.Glob("*.logfmt")
-    const files = await Array.fromAsync(glob.scan(MEMORY_DIR))
+      return `Imported ${count} memory(s)`
+    },
+  })
 
-    if (!files.length) return "No memory files found"
+  const compact = tool({
+    description: "Rewrite memory files in chronological order and remove exact duplicate records",
+    args: {
+      dryRun: tool.schema.boolean().optional().describe("Report what would change without rewriting files"),
+    },
+    async execute(args) {
+      const entries = await store.readEntries()
+      const unique = new Map<string, Memory>()
+      for (const entry of entries) {
+        const key = JSON.stringify(entry.memory)
+        if (!unique.has(key)) unique.set(key, entry.memory)
+      }
 
-    let deleted = 0
-    const deletedMemories: Memory[] = []
+      const duplicateCount = entries.length - unique.size
+      if (args.dryRun) return `Would compact ${entries.length} memories to ${unique.size} unique memories (${duplicateCount} duplicate(s) removed)`
 
-    for (const filename of files) {
-      if (filename === "deletions.logfmt") continue // skip audit log
-      const filepath = `${MEMORY_DIR}/${filename}`
-      const file = Bun.file(filepath)
-      const text = await file.text()
-      const lines = text.split("\n")
-      const filtered = lines.filter((line) => {
-        const memory = parseLine(line)
-        if (!memory) return true
-        if (memory.scope === args.scope && memory.type === args.type) {
-          deleted++
-          deletedMemories.push(memory)
-          return false
-        }
-        return true
-      })
-      if (filtered.length !== lines.length) {
-        await Bun.write(filepath, filtered.join("\n"))
+      const byDate = new Map<string, string[]>()
+      for (const memory of [...unique.values()].sort((a, b) => a.ts.localeCompare(b.ts))) {
+        const date = dateFromTs(memory.ts)
+        if (!byDate.has(date)) byDate.set(date, [])
+        byDate.get(date)!.push(encodeMemory(memory))
       }
-    }
 
-    // Log all deletions to audit file
-    for (const memory of deletedMemories) {
-      await logDeletion(memory, args.reason)
-    }
+      const files = new Set(entries.map((entry) => entry.filepath))
+      for (const filepath of files) await store.rewriteFile(filepath, [])
+      for (const [date, lines] of byDate) await store.rewriteFile(join(store.dir, `${date}.logfmt`), lines)
 
-    if (deleted === 0) return `No memories found for ${args.type} in ${args.scope}`
-    return `Deleted ${deleted} ${args.type} memory(s) from ${args.scope}. Reason: ${args.reason}\nDeletions logged to ${MEMORY_DIR}/deletions.logfmt`
-  },
-})
+      return `Compacted ${entries.length} memories to ${unique.size} unique memories (${duplicateCount} duplicate(s) removed)`
+    },
+  })
+
+  const context = tool({
+    description: "Build a compact relevant-memory context pack for the current task",
+    args: {
+      query: tool.schema.string().optional().describe("Task text to match against memories"),
+      scope: tool.schema.string().optional().describe("Optional scope filter"),
+      tags: tool.schema.array(tool.schema.string()).optional().describe("Only include memories with all of these tags"),
+      types: tool.schema.array(tool.schema.enum(MEMORY_TYPES)).optional().describe("Only include these memory types"),
+      limit: tool.schema.number().optional().describe("Maximum memories to include (default 5)"),
+      maxChars: tool.schema.number().optional().describe("Maximum characters in the context pack (default 1200)"),
+      minScore: tool.schema.number().optional().describe("Minimum query relevance score (default 1 when query is provided)"),
+    },
+    async execute(args) {
+      const memories = (await store.readEntries()).map((entry) => entry.memory)
+      const pack = buildContextPack(memories, args)
+      return pack || "No relevant memories"
+    },
+  })
 
-export const MemoryPlugin: Plugin = async (_ctx) => {
-  MEMORY_DIR = `${_ctx.directory}/.opencode/memory`
   return {
-    tool: {
-      memory_remember: remember,
-      memory_recall: recall,
-      memory_update: update,
-      memory_forget: forget,
-      memory_list: listMemories,
-    },
+    memory_remember: remember,
+    memory_recall: recall,
+    memory_update: update,
+    memory_forget: forget,
+    memory_list: listMemories,
+    memory_export: exportMemories,
+    memory_import: importMemories,
+    memory_compact: compact,
+    memory_context: context,
   }
 }
 
+export const MemoryPlugin = (async (ctx, options?: PluginOptions) => {
+  const store = createStore(join(ctx.directory, ".opencode", "memory"))
+  const autoLoad = options?.autoLoad ?? false
+  const autoSave = options?.autoSave ?? false
+  const autoHookTimeoutMs = options?.autoHookTimeoutMs && options.autoHookTimeoutMs > 0 ? options.autoHookTimeoutMs : 100
+  let latestPrompt: string | undefined
+
+  return {
+    tool: createTools(store),
+    "chat.message": async (input, output) => {
+      const text = textFromParts(output.parts)
+      if (!text) return
+
+      latestPrompt = text
+
+      if (!autoSave) return
+
+      await withTimeout((async () => {
+        const memory = inferExplicitMemory(text, options?.autoSaveScope || "user")
+        if (!memory) return
+
+        await store.appendMemory({
+          ...memory,
+          ts: new Date().toISOString(),
+        })
+      })(), autoHookTimeoutMs)
+    },
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!autoLoad) return
+
+      if (!latestPrompt) return
+
+      const pack = await withTimeout((async () => {
+        const memories = (await store.readEntries()).map((entry) => entry.memory)
+        return buildContextPack(memories, {
+          query: latestPrompt,
+          limit: options?.contextLimit,
+          maxChars: options?.contextMaxChars,
+          minScore: options?.contextMinScore,
+        })
+      })(), autoHookTimeoutMs)
+      if (!pack) return
+
+      output.system.push(`${pack}\n\nUse these memories only when they are relevant. Do not mention this block unless asked.`)
+    },
+  }
+}) satisfies Plugin
+
 export default MemoryPlugin