opencode-dejavu 2.7.0 → 2.27.0

package/src/validate.ts

@@ -5,7 +5,7 @@
  * coerceGateShape + repairGate satisfies the data-model invariants.
  */
 import type { Gate } from "./store"
-import { canBlock, canRemind, scrubSecrets } from "./patterns"
+import { canBlock, canRemind, looksLikeSuccess, sanitizeForStore, suggestCorrection } from "./patterns"
 
 /** sha1 prefix-12, the only key shape patternKey ever emits */
 const KEY_SHAPE = /^[0-9a-f]{12}$/
@@ -15,6 +15,10 @@ const SNIPPET_MAX = 200
 const SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1000
 /** bound per-gate session state so long-lived gates cannot bloat */
 const SESSION_STATE_CAP = 50
+/** The auto-correction template is a FIXED shape — a correction matching it
+ * byte-for-byte around its quoted snippet is machine-generated; anything else
+ * is a human/agent edit and must never be re-derived. */
+const AUTO_TEMPLATE_CORRECTION = /^Last error: "(.*)" — address that specific error before retrying this exact call\.$/
 
 /**
  * Structural parse of one persisted gate object. Returns a well-shaped Gate
@@ -34,6 +38,10 @@ export function coerceGateShape(raw: unknown): Gate | null {
   const strings = (v: unknown): string[] =>
     Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : []
   const str = (v: unknown, fallback: string): string => (typeof v === "string" ? v : fallback)
+  // Unparseable dates would make a gate immortal (expire() compares
+  // Date.parse(...) < cutoff; NaN never is) — reset them instead.
+  const dateStr = (v: unknown, fallback: string): string =>
+    typeof v === "string" && !Number.isNaN(Date.parse(v)) ? v : fallback
   const now = new Date().toISOString()
 
   const gate: Gate = {
@@ -44,19 +52,39 @@ export function coerceGateShape(raw: unknown): Gate | null {
     count: num(r.count, 0),
     sessions: strings(r.sessions),
     projects: strings(r.projects),
-    firstSeen: str(r.firstSeen, now),
-    lastSeen: str(r.lastSeen, now),
+    firstSeen: dateStr(r.firstSeen, now),
+    lastSeen: dateStr(r.lastSeen, now),
     snippet: str(r.snippet, ""),
     remindedCount: num(r.remindedCount, 0),
     blockedCount: num(r.blockedCount, 0),
     recurredAfterReminder: num(r.recurredAfterReminder, 0),
     recurredAfterGate: num(r.recurredAfterGate, 0),
+    overrideCount: num(r.overrideCount, 0),
   }
-  if (typeof r.succeededAfterGate === "number" && Number.isFinite(r.succeededAfterGate) && r.succeededAfterGate > 0) {
+  if (typeof r.succeededAfterGate === "number" && Number.isFinite(r.succeededAfterGate) && r.succeededAfterGate >= 0) {
     gate.succeededAfterGate = Math.floor(r.succeededAfterGate)
   }
+  if (typeof r.promotionCount === "number" && Number.isFinite(r.promotionCount) && r.promotionCount > 0) {
+    gate.promotionCount = Math.floor(r.promotionCount)
+  }
   if (typeof r.correction === "string") gate.correction = r.correction
   if (r.review === true) gate.review = true
+  if (r.feedbackDemoted === true) gate.feedbackDemoted = true
+  if (Array.isArray(r.reoffenseSessions)) {
+    const sessions = r.reoffenseSessions.filter((x): x is string => typeof x === "string")
+    if (sessions.length > 0) gate.reoffenseSessions = sessions.slice(-SESSION_STATE_CAP)
+  }
+  if (r.feedbackBaseline !== null && typeof r.feedbackBaseline === "object" && !Array.isArray(r.feedbackBaseline)) {
+    const b = r.feedbackBaseline as Record<string, unknown>
+    const recurred = typeof b.recurred === "number" && Number.isFinite(b.recurred) && b.recurred >= 0 ? Math.floor(b.recurred) : 0
+    const overrides = typeof b.overrides === "number" && Number.isFinite(b.overrides) && b.overrides >= 0 ? Math.floor(b.overrides) : 0
+    if (recurred > 0 || overrides > 0) gate.feedbackBaseline = { recurred, overrides }
+  }
+  if (r.retireBaseline !== null && typeof r.retireBaseline === "object" && !Array.isArray(r.retireBaseline)) {
+    const b = r.retireBaseline as Record<string, unknown>
+    const count = typeof b.count === "number" && Number.isFinite(b.count) && b.count >= 0 ? Math.floor(b.count) : 0
+    if (count > 0) gate.retireBaseline = { count }
+  }
   if (r.remindedSessions !== null && typeof r.remindedSessions === "object" && !Array.isArray(r.remindedSessions)) {
     const sessions: Record<string, number> = {}
     for (const [session, at] of Object.entries(r.remindedSessions as Record<string, unknown>)) {
@@ -95,22 +123,43 @@ export function repairGate(gate: Gate): boolean {
     gate.lastSeen = swap
     changed = true
   }
+  // The retirement baseline anchors a count AT retirement — it can never exceed
+  // the lifetime count. Clamp a corrupted overshoot; dropping it instead would
+  // re-open the instant re-promotion the baseline exists to damp.
+  if (gate.retireBaseline !== undefined && gate.retireBaseline.count > gate.count) {
+    gate.retireBaseline.count = gate.count
+    changed = true
+  }
   if (gate.snippet.length > SNIPPET_MAX) {
     gate.snippet = gate.snippet.slice(0, SNIPPET_MAX)
     changed = true
   }
-  const signature = scrubSecrets(gate.signature)
+  // A success-shaped snippet is not failure evidence — clear it so the next
+  // failure re-captures a real error line (heals legacy data at the boundary).
+  if (looksLikeSuccess(gate.snippet)) {
+    gate.snippet = ""
+    changed = true
+  }
+  // AUTO_TEMPLATE corrections are machine-made, so re-derive from current evidence on every repair: success-shaped quotes and stale platform advice reach old gates; human edits never match the template byte-for-byte and are untouched.
+  if (gate.correction !== undefined && AUTO_TEMPLATE_CORRECTION.test(gate.correction)) {
+    const rederived = suggestCorrection(gate.signature, gate.snippet)
+    if (rederived !== gate.correction) {
+      gate.correction = rederived
+      changed = true
+    }
+  }
+  const signature = sanitizeForStore(gate.signature)
   if (signature !== gate.signature) {
     gate.signature = signature
     changed = true
   }
-  const snippet = scrubSecrets(gate.snippet)
+  const snippet = sanitizeForStore(gate.snippet)
   if (snippet !== gate.snippet) {
     gate.snippet = snippet
     changed = true
   }
   if (gate.correction !== undefined) {
-    let correction = scrubSecrets(gate.correction)
+    let correction = sanitizeForStore(gate.correction)
     if (correction.length > SNIPPET_MAX) {
       // Unbounded corrections are a context-pollution vector; the companion
       // skill mandates one actionable line anyway.
@@ -165,6 +214,8 @@ export function repairGate(gate: Gate): boolean {
   // blocking to reminding if the shape can still remind, else to watching.
   if (gate.status === "blocking" && !canBlock(gate.tool, gate.signature)) {
     gate.status = canRemind(gate.tool, gate.signature) ? "reminding" : "watching"
+    // reset at the transition: the old tier's counter is stale; reminding accrues fresh
+    if (gate.recurredAfterReminder > 0) gate.recurredAfterReminder = 0
     changed = true
   }
   if (gate.status === "reminding" && !canRemind(gate.tool, gate.signature)) {