opencode-dejavu 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.6.0 — 2026-08-26
+
+### Added (only well-grounded triggers)
+- **Gates heal.** dejavu previously only saw failures, so a gate kept reminding even after the underlying command was fixed (the `ruff check .` false positive). Now a SUCCESS matching an enforced gate increments `succeededAfterGate`; after `HEAL_SUCCESSES` (3) consecutive successes the gate retires to `watching` and logs `healed`, so fixed commands stop triggering. A failure resets the streak.
+
+## 2.5.1 — 2026-08-26
+
+### Fixed
+- Cross-project index + forensic log now key on the gate's OWN key (post fuzzy-consolidation), not the raw failure key. Before, a failure that fuzzy-merged into an existing gate indexed a key with no gate — orphaning the entry and silently starving that gate's cross-project escalation (the "INDEX ORPHANS" you'd see in doctor).
+
 ## 2.5.0 — 2026-08-24
 
 ### Changed (the three known gaps, closed)

package/README.md

@@ -72,6 +72,7 @@ Restart OpenCode. Gates appear automatically as failures recur — nothing to co
 - **Bounded memory** — per-session maps are capped (200 sessions) and freed on `session.deleted`; handled part IDs evict FIFO; TTL expiry re-runs every 6 h in long-lived processes.
 - **Migration** — gates outside the blocking policy are demoted to `watching` automatically; project copies of already-global gates are merged into the global gate (evidence is consolidated, never deleted).
 - **Self-healing** — every init reconciles the stores: an unparseable `gates.json` is quarantined (bytes preserved as `gates.json.corrupt-<ts>`), gate records are strictly parsed and mechanically repaired (inverted dates swapped, duplicate keys merged, secrets re-scrubbed, stale blocking demoted), unparseable log lines are excised to `log.jsonl.corrupt`, and the cross-project index is reconciled. Every repair is logged as a `repaired`/`quarantined` event.
+- **Gates heal, not just accumulate** — dejavu sees successes too: a SUCCESS matching an enforced gate grows `succeededAfterGate`, and after 3 in a row the gate retires to `watching` (logged `healed`), so a command you fixed stops triggering reminders. A failure resets the streak. This kills the "ruff check passed 10 times but dejavu still reminds" false positive.
 
 ## Observability (debugging aids)
 
@@ -112,7 +113,7 @@ 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), `NOISE_TTL_DAYS` (7), `REVIEW_FIRES` (10), `MAX_GATES` (2000).
+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), `HEAL_SUCCESSES` (3).
 
 ## Roadmap
 

package/index.ts

@@ -236,8 +236,6 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
         // grep/pytest/linters: exit 1 is often the INTENDED outcome, not a mistake.
         const intended = exitCode === 1 && isIntendedNonzero(rawCommand, 1)
         const failed = exitCode !== null ? exitCode !== 0 && !intended : detection.matched
-        if (!failed) return
-        const snippet = scrubSecrets(detection.matched ? detection.snippet : `exit code ${exitCode}`)
 
         const args = scrubbedArgs(((input as { args?: unknown }).args ?? {}) as Record<string, unknown>)
         let signature = callSignature(input.tool, args)
@@ -247,9 +245,9 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
         }
         if (!signature) return
 
-        // Attribution: if a segment of a failed chain matches an already-known
-        // pattern, record the failure under that segment's key — the chain
-        // wrapper changes every time, the recurring part does not.
+        // Attribution: if a segment of the chain matches an already-known
+        // pattern, attribute to that segment's key — the chain wrapper changes
+        // every time, the recurring part does not.
         let recordSignature = signature
         if (input.tool === "bash" && typeof args.command === "string") {
           for (const segSig of bashSegmentSignatures(args.command)) {
@@ -259,10 +257,19 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
             }
           }
         }
-
         const key = patternKey(recordSignature)
         const session = typeof input.sessionID === "string" ? input.sessionID : "unknown"
 
+        // A SUCCESS matching an enforced gate is evidence the command got fixed —
+        // track the streak so healed commands stop reminding (only bash gates
+        // enforce, so only bash successes can heal).
+        if (!failed) {
+          if (isBash) await stores.recordSuccess({ key, signature: recordSignature, tool: input.tool })
+          return
+        }
+
+        const snippet = scrubSecrets(detection.matched ? detection.snippet : `exit code ${exitCode}`)
+
         const result = await stores.recordFailure({
           key,
           signature: recordSignature,
@@ -275,7 +282,7 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
 
         await stores.logAll({
           type: "detected",
-          key,
+          key: result.gate.key,
           tool: input.tool,
           session,
           project: directory,
@@ -285,7 +292,7 @@ export const Dejavu: Plugin = async ({ directory, client }) => {
         })
 
         if (result.promoted) {
-          await stores.logAll({ type: "promoted", key, tool: input.tool, session, project: directory })
+          await stores.logAll({ type: "promoted", key: result.gate.key, tool: input.tool, session, project: directory })
           await logClient(
             "info",
             `dejavu: gate promoted — "${result.gate.signature}" (${result.gate.count}x, ${result.gate.sessions.length} sessions)`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dejavu",
-  "version": "2.5.0",
+  "version": "2.6.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/AGENTS.md

@@ -40,6 +40,7 @@ Two dependency-free modules: `patterns.ts` (pure functions — call identity, no
 - Inside `runLocked` always `load(true)`; unlocked `load()` peeks are routing hints only, never a basis for mutation
 - Hot-path reads use the 1s TTL cache + key index (`byKey`/`enforcedOnly`); mutations inside locks use `load(true)`; `save()` refreshes the cache directly
 - The remind→block chain is persisted ON THE GATE (`remindedSessions`/`failedSessions`) and enforced under the store lock — process memory holds nothing authoritative, so several windows and restarts share one escalation
+- Successes heal: `recordSuccess` grows `succeededAfterGate` on an enforced gate; at `HEAL_SUCCESSES` (3) it retires to `watching` and logs `healed`. A failure resets the streak in `recordFailure`. Only bash successes heal (only bash gates enforce)
 - Log appends and rotation take the log lock — every OpenCode window shares the global log; unlocked appends interleave into broken JSON
 - Every gate read from disk crosses `coerceGateShape` + `repairGate` in `load()` — enforcement never sees raw state; hopeless records are dropped, repairable ones coerced
 - Quarantine preserves bytes: unparseable files are renamed to `*.corrupt-*`, never deleted; every repair emits a `repaired`/`quarantined` log event

package/src/store.ts

@@ -4,7 +4,7 @@ import { canBlock, canRemind, fuzzySimilar, FUZZY_MAX_LEN, isRepoLocal, scrubSec
 import { coerceGateShape, repairGate } from "./validate"
 
 /** Bumped on behavior changes; stamped into init log events so stale sessions are visible. */
-export const PLUGIN_VERSION = "2.5.0"
+export const PLUGIN_VERSION = "2.6.0"
 
 export interface Gate {
   /** sha1 signature prefix — the pattern identity */
@@ -31,6 +31,9 @@ export interface Gate {
   recurredAfterReminder: number
   /** the core health metric: failures of this pattern AFTER it became a gate */
   recurredAfterGate: number
+  /** consecutive successes after the gate was enforced — reaching HEAL_SUCCESSES
+   * retires the gate to watching (the underlying command got fixed) */
+  succeededAfterGate?: number
   /** flagged for manual review when the gate fires often but errors stopped */
   review?: boolean
   /** sessions currently reminded about this gate: sessionID -> remind time (ms).
@@ -73,6 +76,7 @@ export type LogEventType =
   | "quarantined"
   | "degraded"
   | "retired-healed"
+  | "healed"
 
 export interface LogEvent {
   type: LogEventType
@@ -108,6 +112,9 @@ export const PROMOTE_COUNT_PROBE = 5
 export const PROBE_TOOLS = new Set(["read", "glob", "grep", "write", "edit"])
 /** distinct sessions required — same-session loops never promote */
 export const PROMOTE_SESSIONS = 2
+/** consecutive successes after a gate that retire it — the command is fixed,
+ * so the gate must stop reminding (the ruff-check-false-positive case) */
+export const HEAL_SUCCESSES = 3
 /** store size bound: flooding with unique failures must not bloat gates.json
  * or slow the fuzzy scan — the weakest watching gate is evicted past this */
 export const MAX_GATES = 2000
@@ -933,6 +940,8 @@ export class Stores {
       // Only an exact-key failure updates the evidence: a crafted near-duplicate
       // must not overwrite a legitimate gate's snippet via fuzzy consolidation.
       if (!fuzzyConsolidated) gate.snippet = scrubSecrets(input.snippet)
+      // A failure breaks any heal streak — the command is still broken.
+      gate.succeededAfterGate = 0
 
       let promoted = false
       const threshold = PROBE_TOOLS.has(input.tool) ? PROMOTE_COUNT_PROBE : PROMOTE_COUNT
@@ -954,14 +963,17 @@ export class Stores {
       // ever sees its own store's directory, so alone it can never reach two
       // projects. A pattern seen in enough distinct project dirs is an
       // agent-level habit, not a repo quirk — move it to the global store.
+      // Keyed by the gate's OWN key (post fuzzy-consolidation), not the raw
+      // failure key — otherwise consolidated failures index a key that has no
+      // gate, orphaning the entry and starving the gate's escalation.
       // Lock order is always gates -> index and project -> global: no cycles.
       const moved = gate
       const indexProjects = await this.globalStore.runLockedIndex(async () => {
         const index = await this.globalStore.loadIndex(true)
-        let entry = index.keys[input.key]
+        let entry = index.keys[moved.key]
         if (!entry) {
           entry = { projects: [], lastSeen: now }
-          index.keys[input.key] = entry
+          index.keys[moved.key] = entry
         }
         if (input.projectDir !== "" && !entry.projects.includes(input.projectDir)) {
           entry.projects.push(input.projectDir)
@@ -1003,4 +1015,34 @@ export class Stores {
       return { gate: moved, store, promoted, wentGlobal }
     })
   }
+
+  /**
+   * A SUCCESS matching an enforced gate is evidence the underlying command got
+   * fixed. Track a streak; once it reaches HEAL_SUCCESSES the gate retires to
+   * watching so it stops reminding on a now-healthy command (the
+   * `ruff check .` false-positive case). Only enforced (blocking/reminding)
+   * gates heal; a failure resets the streak in recordFailure.
+   */
+  async recordSuccess(input: { key: string; signature: string; tool: string }): Promise<void> {
+    const match = await this.findGate(input.key, input.signature)
+    if (match === null || match.gate.status === "watching") return
+    const store = match.store
+    const gateKey = match.gate.key
+    await store.runLocked(async () => {
+      const fresh = (await store.load(true)).find((g) => g.key === gateKey)
+      if (fresh === undefined || fresh.status === "watching") return
+      fresh.succeededAfterGate = (fresh.succeededAfterGate ?? 0) + 1
+      const healed = fresh.succeededAfterGate >= HEAL_SUCCESSES
+      if (healed) fresh.status = "watching"
+      await store.save()
+      if (healed) {
+        await store.log({
+          type: "healed",
+          key: fresh.key,
+          tool: fresh.tool,
+          snippet: `succeeded ${fresh.succeededAfterGate}x in a row after the gate — retired to watching`,
+        })
+      }
+    })
+  }
 }

package/src/validate.ts

@@ -52,6 +52,9 @@ export function coerceGateShape(raw: unknown): Gate | null {
     recurredAfterReminder: num(r.recurredAfterReminder, 0),
     recurredAfterGate: num(r.recurredAfterGate, 0),
   }
+  if (typeof r.succeededAfterGate === "number" && Number.isFinite(r.succeededAfterGate) && r.succeededAfterGate > 0) {
+    gate.succeededAfterGate = Math.floor(r.succeededAfterGate)
+  }
   if (typeof r.correction === "string") gate.correction = r.correction
   if (r.review === true) gate.review = true
   if (r.remindedSessions !== null && typeof r.remindedSessions === "object" && !Array.isArray(r.remindedSessions)) {