opencode-dejavu 2.3.1 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 2.4.0 — 2026-08-24
+
+### Added
+- Noise TTL: weak one-off patterns (below the promotion threshold, never enforced) expire after 7 days instead of 60 — memory is for recurring mistakes, not one-shot noise.
+- Correction lifecycle signal: an expired gate that had a correction and zero recurrences after promotion logs `retired-healed` — the mechanical "the teaching worked"; doctor reports such gates as TEACHING.
+
+### Notes
+- V2 plugin API migration awaits upstream: `tool.execute.error` (opencode issue #27900) is drafted but unmerged — the event-stream scan remains the file-tool failure channel until then.
+
 ## 2.3.1 — 2026-08-24
 
 ### Fixed (adversarial + security review round)

package/README.md

@@ -112,11 +112,11 @@ bun run typecheck        # tsc --noEmit (index.ts + src/**)
 bun test/smoke.ts        # behavioral smoke test, no framework needed
 ```
 
-Tunables are named constants at the top of `index.ts` and `src/store.ts`: `PROMOTE_COUNT` (3), `PROMOTE_COUNT_PROBE` (5), `PROMOTE_SESSIONS` (2), `GLOBAL_PROJECTS` (2), `TTL_DAYS` (60), `REVIEW_FIRES` (10).
+Tunables are named constants at the top of `index.ts` and `src/store.ts`: `PROMOTE_COUNT` (3), `PROMOTE_COUNT_PROBE` (5), `PROMOTE_SESSIONS` (2), `GLOBAL_PROJECTS` (2), `TTL_DAYS` (60), `NOISE_TTL_DAYS` (7), `REVIEW_FIRES` (10), `MAX_GATES` (2000).
 
 ## Roadmap
 
-- v2: recurrence-after-gate reporting command; V2 plugin API error hooks when stable
+- v2: recurrence-after-gate reporting command; V2 plugin API error hooks — `tool.execute.error` is drafted upstream (opencode issue #27900) but unmerged; the event-stream scan remains the file-tool failure channel until it lands
 - v3: auto-proposal of ast-grep rules for statically detectable patterns (repo-level CI gates)
 
 ## License

package/index.ts

@@ -19,6 +19,8 @@ import { GateStore, Stores, type Gate, PLUGIN_VERSION } from "./src/store"
 const GLOBAL_PROJECTS = 2
 /** gates expire when the pattern has not recurred for this many days */
 const TTL_DAYS = 60
+/** weak one-off patterns (below promotion threshold, never enforced) rot this fast */
+const NOISE_TTL_DAYS = 7
 /** how often a long-lived process re-runs expiry */
 const TTL_INTERVAL_MS = 6 * 60 * 60 * 1000
 /** a gate firing this often without killing the error gets flagged for review */
@@ -91,7 +93,7 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
   try {
     await stores.reconcileAll(GLOBAL_PROJECTS)
     await stores.migrate()
-    await stores.expireAll(TTL_DAYS)
+    await stores.expireAll(TTL_DAYS, NOISE_TTL_DAYS)
     await stores.rotateLogs()
     await stores.logAll({ type: "init", key: "dejavu", version: PLUGIN_VERSION })
     await logClient("info", `dejavu initialized v${PLUGIN_VERSION}`)
@@ -104,7 +106,7 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
   // Long-lived processes re-run expiry periodically.
   const ttlTimer = setInterval(() => {
     // expiry is best-effort; the timer keeps running regardless
-    stores.expireAll(TTL_DAYS).catch(() => {})
+    stores.expireAll(TTL_DAYS, NOISE_TTL_DAYS).catch(() => {})
   }, TTL_INTERVAL_MS)
   ;(ttlTimer as { unref?: () => void }).unref?.()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dejavu",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Cross-session memory prosthesis for OpenCode: detects recurring tool-call failures and promotes them into enforced gates. Remind first, block on same-session repeat offense.",
   "type": "module",
   "main": "index.ts",

package/src/store.ts

@@ -4,7 +4,7 @@ import { canBlock, fuzzySimilar, FUZZY_MAX_LEN, scrubSecrets } from "./patterns"
 import { coerceGateShape, repairGate } from "./validate"
 
 /** Bumped on behavior changes; stamped into init log events so stale sessions are visible. */
-export const PLUGIN_VERSION = "2.3.1"
+export const PLUGIN_VERSION = "2.4.0"
 
 export interface Gate {
   /** sha1 signature prefix — the pattern identity */
@@ -71,6 +71,7 @@ export type LogEventType =
   | "repaired"
   | "quarantined"
   | "degraded"
+  | "retired-healed"
 
 export interface LogEvent {
   type: LogEventType
@@ -350,13 +351,23 @@ export class GateStore {
     })
   }
 
-  /** Caller must hold the lock. */
-  async expire(ttlDays: number): Promise<Gate[]> {
+  /**
+   * Caller must hold the lock. Weak one-off patterns (below the promotion
+   * threshold, never enforced) rot faster than proven ones — a pattern that
+   * never recurred enough to matter is noise, not memory.
+   */
+  async expire(ttlDays: number, noiseTtlDays: number): Promise<Gate[]> {
     const gates = await this.load(true)
-    const cutoff = Date.now() - ttlDays * DAY_MS
-    const expired = gates.filter((g) => Date.parse(g.lastSeen) < cutoff)
+    const now = Date.now()
+    const expired = gates.filter((g) => {
+      const ttl = g.status === "blocking" || g.count >= PROMOTE_COUNT ? ttlDays : noiseTtlDays
+      return Date.parse(g.lastSeen) < now - ttl * DAY_MS
+    })
     if (expired.length === 0) return []
-    this.gates = gates.filter((g) => Date.parse(g.lastSeen) >= cutoff)
+    const expiredKeys = new Set(expired.map((g) => g.key))
+    this.gates = gates.filter((g) => !expiredKeys.has(g.key))
+    this.keyIndex = null
+    this.blockingCache = null
     await this.save()
     return expired
   }
@@ -596,12 +607,19 @@ export class Stores {
     }
   }
 
-  async expireAll(ttlDays: number): Promise<void> {
+  async expireAll(ttlDays: number, noiseTtlDays: number): Promise<void> {
     for (const store of this.scopes()) {
       await store.runLocked(async () => {
-        const expired = await store.expire(ttlDays)
+        const expired = await store.expire(ttlDays, noiseTtlDays)
         for (const gate of expired) {
-          await store.log({ type: "expired", key: gate.key, tool: gate.tool })
+          // Correction lifecycle: a corrected gate that never recurred after
+          // promotion means the pattern died out — the mechanical signal that
+          // the teaching worked.
+          if (gate.correction !== undefined && gate.recurredAfterGate === 0) {
+            await store.log({ type: "retired-healed", key: gate.key, tool: gate.tool, snippet: gate.correction.slice(0, 200) })
+          } else {
+            await store.log({ type: "expired", key: gate.key, tool: gate.tool })
+          }
         }
       })
     }