opencode-dejavu 2.5.1 → 2.7.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 2.7.0 — 2026-08-26
+
+### Added (no more manual corrections)
+- **Auto-corrections.** A promoted gate now always ships with a mechanical, overridable default correction (`suggestCorrection`), chosen by command family (stale `--check` artifacts, failing tests, type errors, network, installs) or from the captured error line — so a gate never sits "NOT TEACHING" awaiting a human. `migrate()` backfills existing enforced gates.
+- **Richer snippets.** For exit-code failures whose output matched no signature, dejavu keeps the last non-empty output line (`failureSnippet`) instead of a bare "exit code N", giving corrections real context.
+
+## 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

package/README.md

@@ -72,6 +72,8 @@ 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.
+- **Auto-corrections, no manual work** — a promoted gate always ships with a mechanical, overridable default correction chosen by command family (stale `--check` artifacts, failing tests, type errors, network, installs) or from the captured error line, so a gate never sits "NOT TEACHING" awaiting a human. `migrate()` backfills existing gates. Snippets now keep the last output line (`failureSnippet`) instead of a bare "exit code N".
 
 ## Observability (debugging aids)
 
@@ -112,7 +114,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

@@ -5,6 +5,7 @@ import {
   bashSegmentSignatures,
   callSignature,
   detectFailure,
+  failureSnippet,
   isIntendedNonzero,
   isNoiseError,
   parameterizeError,
@@ -236,8 +237,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 +246,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 +258,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 : failureSnippet(text, exitCode))
+
         const result = await stores.recordFailure({
           key,
           signature: recordSignature,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-dejavu",
-  "version": "2.5.1",
+  "version": "2.7.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/patterns.ts

@@ -460,6 +460,22 @@ export function detectFailure(outputText: string): FailureDetection {
   return { matched: false, snippet: "" }
 }
 
+/**
+ * For exit-code failures whose output matched no signature, a bare
+ * "exit code N" gives a human/agent nothing to write a correction from.
+ * Bash output is command output (safe to surface), so keep the last non-empty
+ * line — compilers/test runners print their summary at the end.
+ */
+export function failureSnippet(outputText: string, exitCode: number | null): string {
+  const lines = outputText
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l !== "")
+  const tail = lines[lines.length - 1]
+  if (tail !== undefined && tail !== "") return tail.slice(0, 200)
+  return `exit code ${exitCode}`
+}
+
 // --- Noise filtering ----------------------------------------------------------
 
 /**
@@ -478,3 +494,33 @@ const NOISE_ERRORS: RegExp[] = [
 export function isNoiseError(errorText: string): boolean {
   return NOISE_ERRORS.some((rule) => rule.test(errorText))
 }
+
+// --- Default corrections ------------------------------------------------------
+
+/**
+ * Mechanical, overridable default correction chosen by command family, so a
+ * promoted gate always ships with SOME teaching text instead of sitting
+ * "NOT TEACHING" until a human writes one. Rules, not an LLM — the hot path
+ * stays mechanical; a human/agent may refine the text later.
+ */
+export function suggestCorrection(signature: string, snippet: string): string {
+  if (/(^|\s)(--check|--dry-run|verify|check)\b/i.test(signature) && /dart run|generate|sync/i.test(signature)) {
+    return "Generated artifacts are stale — run the same script WITHOUT the check flag to regenerate, then commit the result."
+  }
+  if (/\b(pytest|jest|vitest|mocha|cucumbertest|flutter test|npm test|gradlew\b[^\n]*test|dart test)\b/i.test(signature)) {
+    return "A test is failing — read the failing assertion in the output and fix the code or the expectation; do not re-run the suite blindly."
+  }
+  if (/\b(tsc|typecheck|type-check)\b/i.test(signature)) {
+    return "Type errors — run the compiler, read the reported file:line diagnostics, and fix the types before retrying."
+  }
+  if (/\b(curl|wget)\b/i.test(signature)) {
+    return "Network/endpoint failure — verify the URL is reachable, check rate limits and timeouts; retry with backoff, not immediately."
+  }
+  if (/\b(npm|yarn|pnpm|bun)\s+(install|ci)\b/i.test(signature)) {
+    return "Dependency install failed — inspect the resolver error; try the lockfile/legacy-peer-deps route the repo documents."
+  }
+  if (snippet !== "" && snippet !== "exit code 1") {
+    return `Last error: "${snippet}" — address that specific error before retrying this exact call.`
+  }
+  return "This exact call keeps failing — inspect the last output line and change approach before retrying."
+}

package/src/store.ts

@@ -1,10 +1,10 @@
 import { appendFile, mkdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises"
 import { dirname, join } from "node:path"
-import { canBlock, canRemind, fuzzySimilar, FUZZY_MAX_LEN, isRepoLocal, scrubSecrets } from "./patterns"
+import { canBlock, canRemind, fuzzySimilar, FUZZY_MAX_LEN, isRepoLocal, scrubSecrets, suggestCorrection } 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.5.1"
+export const PLUGIN_VERSION = "2.7.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
@@ -720,6 +727,12 @@ export class Stores {
               changed = true
             }
           }
+          // Backfill: an enforced gate with no correction gets a mechanical
+          // default so it teaches immediately instead of sitting "NOT TEACHING".
+          if (gate.status !== "watching" && gate.correction === undefined) {
+            gate.correction = suggestCorrection(gate.signature, gate.snippet)
+            changed = true
+          }
         }
         if (changed) await store.save()
       })
@@ -933,6 +946,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
@@ -946,6 +961,11 @@ export class Stores {
           gate.status = "reminding"
           promoted = true
         }
+        // A promoted gate always ships with SOME teaching text (mechanical
+        // default, overridable) so it never sits "NOT TEACHING" awaiting a human.
+        if (promoted && gate.correction === undefined) {
+          gate.correction = suggestCorrection(gate.signature, gate.snippet)
+        }
       }
 
       await store.save()
@@ -1006,4 +1026,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)) {