claude-mem-lite 2.5.4 → 2.9.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.3.2",
+      "version": "2.9.2",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.5.3",
+  "version": "2.9.2",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/dispatch-feedback.mjs

@@ -2,7 +2,7 @@
 // Runs at Stop hook to track adoption and outcomes of recommendations
 
 import { getSessionInvocations, updateInvocation, updateResourceStats } from './registry.mjs';
-import { debugCatch, EDIT_TOOLS } from './utils.mjs';
+import { debugCatch, debugLog, EDIT_TOOLS } from './utils.mjs';
 
 // ─── Adoption Detection ──────────────────────────────────────────────────────
 
@@ -60,26 +60,80 @@ function detectSkillAdoption(resourceName, invocationName, skillInput) {
 }
 
 /**
- * Check if a recommended resource was adopted in the session events.
+ * Check if event timestamp is within the behavioral detection window.
+ * @param {number} eventTs Event timestamp (ms)
+ * @param {number} recTime Recommendation time (ms)
+ * @param {number} windowMs Window size (default 10 minutes)
+ * @returns {boolean}
+ */
+const BEHAVIORAL_WINDOW_MS = 600000; // 10 minutes (widened from 2 min for methodology skills)
+
+function isWithinWindow(eventTs, recTime, windowMs = BEHAVIORAL_WINDOW_MS) {
+  if (recTime === null || recTime === undefined || eventTs === null || eventTs === undefined) return true;
+  const delta = eventTs - recTime;
+  return delta >= 0 && delta <= windowMs;
+}
+
+/**
+ * Detect TDD pattern: Bash(test fail) → Edit → Bash(test pass)
+ */
+function detectTDDPattern(events, recTime) {
+  let testFailed = false, edited = false;
+  for (const e of events) {
+    if (!isWithinWindow(e.timestamp, recTime)) continue;
+    const cmd = (e.tool_input?.command || '').toLowerCase();
+    const resp = e.tool_response || '';
+    if (e.tool_name === 'Bash' && /test|jest|vitest|pytest|mocha/i.test(cmd) && /fail|error|FAIL/i.test(resp)) {
+      testFailed = true;
+    }
+    if (testFailed && EDIT_TOOLS.has(e.tool_name)) edited = true;
+    if (edited && e.tool_name === 'Bash' && /test|jest|vitest|pytest|mocha/i.test(cmd) && /pass|passed|✓|\bok\b/i.test(resp) && !/fail|error/i.test(resp)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Detect verification pattern: successful test/lint/build near session end
+ */
+function detectVerificationPattern(events, recTime) {
+  const lastEvents = events.slice(-5);
+  return lastEvents.some(e => {
+    if (!isWithinWindow(e.timestamp, recTime)) return false;
+    if (e.tool_name !== 'Bash') return false;
+    const cmd = (e.tool_input?.command || '').toLowerCase();
+    const resp = e.tool_response || '';
+    const isVerifyCmd = /\b(test|lint|eslint|build|tsc|typecheck|vitest|jest)\b/.test(cmd);
+    const isSuccess = resp.length > 0 && !/error|fail|exception/i.test(resp);
+    return isVerifyCmd && isSuccess;
+  });
+}
+
+/**
+ * Multi-tier adoption detection for recommended resources.
+ * Returns { adopted: boolean, score: number } where score indicates confidence:
+ *   1.0 = explicit (Skill/Agent tool invocation)
+ *   0.5 = behavioral (detected methodology pattern: TDD, debug, review)
+ *   0.2 = inferred (verification pattern near session end)
+ *
  * @param {object} invocation Invocation record with resource info
  * @param {object[]} sessionEvents Array of tool events from the session
- * @returns {boolean} true if the resource was used
+ * @returns {{ adopted: boolean, score: number }}
  */
 function detectAdoption(invocation, sessionEvents) {
-  if (!sessionEvents || sessionEvents.length === 0) return false;
+  if (!sessionEvents || sessionEvents.length === 0) return { adopted: false, score: 0 };
 
   const { resource_name, resource_type, invocation_name } = invocation;
 
+  // Tier 1: Explicit adoption — Skill/Agent tool invocation (strongest signal)
   for (const event of sessionEvents) {
-    // Skill adoption: Claude used the Skill tool with matching name
     if (resource_type === 'skill' && event.tool_name === 'Skill') {
       if (detectSkillAdoption(resource_name, invocation_name || '', event.tool_input?.skill)) {
-        return true;
+        return { adopted: true, score: 1.0 };
       }
     }
 
-    // Agent adoption: Claude used Agent tool with matching agent type/description
-    // Normalizes hyphens/colons to spaces for comparison (e.g. "code-review-ai" ↔ "code review ai")
     if (resource_type === 'agent' && event.tool_name === 'Agent') {
       const desc = (event.tool_input?.description || '').toLowerCase();
       const prompt = (event.tool_input?.prompt || '').toLowerCase();
@@ -95,36 +149,59 @@ function detectAdoption(invocation, sessionEvents) {
           subTypeCompact === nameCompact ||
           subType.includes(nameNorm) || subType.includes(nameCompact) ||
           subTypeNorm.includes(nameNorm)) {
-        return true;
+        return { adopted: true, score: 1.0 };
       }
     }
   }
 
-  // Behavioral adoption: detect usage patterns matching the recommended resource
+  // Tier 2: Behavioral adoption — methodology patterns (10 min window)
   const resourceLower = resource_name.toLowerCase();
+  const recTime = invocation.created_at ? new Date(invocation.created_at).getTime() : 0;
 
-  // Debugging pattern: Read→Bash(error)→Read→Edit cycle
+  // TDD pattern: Bash(test fail) → Edit → Bash(test pass)
+  if (resourceLower.includes('tdd') || resourceLower.includes('test-driven')) {
+    if (detectTDDPattern(sessionEvents, recTime)) {
+      return { adopted: true, score: 0.5 };
+    }
+  }
+
+  // Debugging pattern: Read → Bash(error) → Edit cycle
   if (resourceLower.includes('debug') || resourceLower.includes('troubleshoot')) {
-    let hasRead = false, hasBashError = false, hasEditAfterError = false;
-    for (const e of sessionEvents) {
-      if (e.tool_name === 'Read') hasRead = true;
-      if (e.tool_name === 'Bash' && /error|fail|exception/i.test(e.tool_response || '')) hasBashError = true;
-      if (hasBashError && EDIT_TOOLS.has(e.tool_name)) hasEditAfterError = true;
+    const firstRelevant = sessionEvents.find(e =>
+      e.tool_name === 'Read' ||
+      (e.tool_name === 'Bash' && /error|fail|exception/i.test(e.tool_response || ''))
+    );
+    if (isWithinWindow(firstRelevant?.timestamp, recTime)) {
+      let hasRead = false, hasBashError = false, hasEditAfterError = false;
+      for (const e of sessionEvents) {
+        if (e.tool_name === 'Read') hasRead = true;
+        if (e.tool_name === 'Bash' && /error|fail|exception/i.test(e.tool_response || '')) hasBashError = true;
+        if (hasBashError && EDIT_TOOLS.has(e.tool_name)) hasEditAfterError = true;
+      }
+      if (hasRead && hasBashError && hasEditAfterError) {
+        return { adopted: true, score: 0.5 };
+      }
     }
-    if (hasRead && hasBashError && hasEditAfterError) return true;
   }
 
   // Code review pattern: Agent with 'review' in prompt/description
   if (resourceLower.includes('review')) {
     for (const e of sessionEvents) {
-      if (e.tool_name === 'Agent') {
+      if (e.tool_name === 'Agent' && isWithinWindow(e.timestamp, recTime)) {
         const text = ((e.tool_input?.prompt || '') + (e.tool_input?.description || '')).toLowerCase();
-        if (text.includes('review')) return true;
+        if (text.includes('review')) return { adopted: true, score: 0.5 };
       }
     }
   }
 
-  return false;
+  // Tier 3: Inferred adoption — verification near session end
+  if (resourceLower.includes('verif') || resourceLower.includes('quality') || resourceLower.includes('check')) {
+    if (detectVerificationPattern(sessionEvents, recTime)) {
+      return { adopted: true, score: 0.2 };
+    }
+  }
+
+  return { adopted: false, score: 0 };
 }
 
 // ─── Outcome Detection ───────────────────────────────────────────────────────
@@ -175,7 +252,7 @@ function detectOutcome(sessionEvents) {
  * @returns {string} Rejection reason
  */
 function classifyRejection(invocation, sessionEvents) {
-  if (!sessionEvents || sessionEvents.length === 0) return 'session_end';
+  if (!sessionEvents || sessionEvents.length === 0) return 'no_events';
 
   const recTime = new Date(invocation.created_at).getTime();
   const afterEvents = sessionEvents.filter(e =>
@@ -230,10 +307,12 @@ export async function collectFeedback(db, sessionId, sessionEvents = []) {
       // Skip if already collected (prevents double-collection from stop + session-start)
       if (inv.outcome) continue;
 
-      const adopted = detectAdoption(inv, sessionEvents);
+      const { adopted, score: adoptScore } = detectAdoption(inv, sessionEvents);
       const outcome = adopted ? detectOutcome(sessionEvents) : 'ignored';
-      const score = adopted ? (outcome === 'success' ? 1.0 : outcome === 'partial' ? 0.5 : 0.2) : 0;
-      const rejection_reason = adopted ? null : classifyRejection(inv, sessionEvents);
+      // Combine adoption confidence with outcome quality
+      const outcomeMultiplier = outcome === 'success' ? 1.0 : outcome === 'partial' ? 0.7 : 0.3;
+      const score = adopted ? adoptScore * outcomeMultiplier : 0;
+      const rejection_reason = adopted ? null : (classifyRejection(inv, sessionEvents) || 'unclassified');
 
       // Update invocation record
       updateInvocation(db, inv.id, {
@@ -251,10 +330,36 @@ export async function collectFeedback(db, sessionId, sessionEvents = []) {
         }
       }
     }
+
+    // Auto-demote zombie resources: >10 recommendations with 0 adoptions → on_request mode
+    // This prevents chronic false positives from continuing to waste recommendation slots
+    autodemoteZombies(db);
   } catch (e) {
     debugCatch(e, 'collectFeedback');
   }
 }
 
+/**
+ * Auto-demote resources with high recommendation count and zero adoption to on_request mode.
+ * Zombie threshold: recommend_count > 10 AND adopt_count = 0.
+ * Only demotes resources currently in 'proactive' mode.
+ */
+function autodemoteZombies(db) {
+  try {
+    const demoted = db.prepare(`
+      UPDATE resources SET recommendation_mode = 'on_request', updated_at = datetime('now')
+      WHERE COALESCE(recommend_count, 0) > 10
+        AND COALESCE(adopt_count, 0) = 0
+        AND COALESCE(recommendation_mode, 'proactive') = 'proactive'
+        AND status = 'active'
+    `).run();
+    if (demoted.changes > 0) {
+      debugLog('INFO', 'feedback', `auto-demoted ${demoted.changes} zombie resources to on_request`);
+    }
+  } catch (e) {
+    debugCatch(e, 'autodemoteZombies');
+  }
+}
+
 // Test exports
 export { detectAdoption as _detectAdoption };

package/dispatch-inject.mjs

@@ -41,38 +41,54 @@ function isNativeSkill(name) {
 
 // ─── Injection Templates ─────────────────────────────────────────────────────
 
+/**
+ * Build the lead line: reason if available, otherwise capability summary.
+ */
+function leadLine(resource, reason) {
+  return reason || truncate(resource.capability_summary, 120);
+}
+
 /**
  * Invocable skill template -- tells Claude to invoke via Skill tool.
  * Used when the resource has an invocation_name (registered as a Claude Code skill/plugin).
  * @param {object} resource Resource object from DB
+ * @param {string} [reason] Why this was recommended
  * @returns {string} Injection text instructing Skill tool invocation
  */
-function injectSkillInvocable(resource) {
-  return `[Auto-suggestion] A relevant skill is available for this task. ` +
-    `Invoke it now: use the Skill tool with skill="${resource.invocation_name}". ` +
-    `Capability: ${truncate(resource.capability_summary, 100)}`;
+function injectSkillInvocable(resource, reason) {
+  const lines = [`[Recommended] ${leadLine(resource, reason)}`];
+  lines.push(`→ Invoke: Skill tool with skill="${resource.invocation_name}"`);
+  if (reason && resource.capability_summary) {
+    lines.push(`Capability: ${truncate(resource.capability_summary, 100)}`);
+  }
+  return lines.join('\n');
 }
 
 /**
  * Native skill template -- tells Claude to use the skill command.
  * Used when skill exists in ~/.claude/skills/ but has no invocation_name.
  * @param {object} resource Resource object from DB
+ * @param {string} [reason] Why this was recommended
  * @returns {string} Injection text referencing the native skill command
  */
-function injectSkillNative(resource) {
-  return `[Auto-suggestion] A relevant skill "${resource.name}" is available for this task. ` +
-    `Use: /skill ${resource.name}. ` +
-    `Capability: ${truncate(resource.capability_summary, 100)}`;
+function injectSkillNative(resource, reason) {
+  const lines = [`[Recommended] ${leadLine(resource, reason)}`];
+  lines.push(`→ Use: /skill ${resource.name}`);
+  if (reason && resource.capability_summary) {
+    lines.push(`Capability: ${truncate(resource.capability_summary, 100)}`);
+  }
+  return lines.join('\n');
 }
 
 /**
  * Managed skill template -- includes content for Claude to use directly.
  * Used when skill is in managed/ directory (not installed natively).
  * @param {object} resource Resource object from DB
+ * @param {string} [reason] Why this was recommended
  * @returns {string} Injection text with embedded skill content
  */
-function injectSkillManaged(resource) {
-  if (!isAllowedPath(resource.local_path)) return injectSkillNative(resource);
+function injectSkillManaged(resource, reason) {
+  if (!isAllowedPath(resource.local_path)) return injectSkillNative(resource, reason);
   let content = '';
   try {
     content = readFileSync(resource.local_path, 'utf8');
@@ -89,23 +105,28 @@ function injectSkillManaged(resource) {
 
   const truncatedContent = truncateContent(content, MAX_INJECTION_CHARS - 300);
 
-  return `[Auto-suggestion] Recommended skill for this task: "${resource.name}"
-Capability: ${truncate(resource.capability_summary, 100)}
-<skill-content>
-${truncatedContent}
-</skill-content>`;
+  const lines = [`[Recommended] "${resource.name}" — ${truncate(resource.capability_summary, 100)}`];
+  if (reason) lines.push(`Why: ${reason}`);
+  lines.push('<skill-content>');
+  lines.push(truncatedContent);
+  lines.push('</skill-content>');
+  return lines.join('\n');
 }
 
 /**
  * Agent template -- guides Claude to use Agent tool with the agent definition.
  * @param {object} resource Resource object from DB
+ * @param {string} [reason] Why this was recommended
  * @returns {string} Injection text with agent definition for Agent tool delegation
  */
-function injectAgent(resource) {
+function injectAgent(resource, reason) {
   if (!isAllowedPath(resource.local_path)) {
-    return `[Auto-suggestion] A specialized agent "${resource.name}" is recommended for this task. ` +
-      `Capability: ${truncate(resource.capability_summary, 100)}. ` +
-      `Use the Agent tool to delegate this work.`;
+    const lines = [`[Recommended] ${leadLine(resource, reason)}`];
+    lines.push(`→ Use Agent tool to delegate: "${resource.name}"`);
+    if (reason && resource.capability_summary) {
+      lines.push(`Capability: ${truncate(resource.capability_summary, 100)}`);
+    }
+    return lines.join('\n');
   }
   let agentDef = '';
   try {
@@ -122,17 +143,21 @@ function injectAgent(resource) {
 
   if (agentDef) {
     const truncatedDef = truncateContent(agentDef, MAX_INJECTION_CHARS - 300);
-    return `[Auto-suggestion] A specialized agent "${resource.name}" is recommended for this task.
-Capability: ${truncate(resource.capability_summary, 100)}
-Use the Agent tool with this agent definition:
-<agent-definition>
-${truncatedDef}
-</agent-definition>`;
+    const lines = [`[Recommended] "${resource.name}" — ${truncate(resource.capability_summary, 100)}`];
+    if (reason) lines.push(`Why: ${reason}`);
+    lines.push('Use the Agent tool with this agent definition:');
+    lines.push('<agent-definition>');
+    lines.push(truncatedDef);
+    lines.push('</agent-definition>');
+    return lines.join('\n');
   }
 
-  return `[Auto-suggestion] A specialized agent "${resource.name}" is recommended for this task. ` +
-    `Capability: ${truncate(resource.capability_summary, 100)}. ` +
-    `Use the Agent tool to delegate this work.`;
+  const lines = [`[Recommended] ${leadLine(resource, reason)}`];
+  lines.push(`→ Use Agent tool to delegate: "${resource.name}"`);
+  if (reason && resource.capability_summary) {
+    lines.push(`Capability: ${truncate(resource.capability_summary, 100)}`);
+  }
+  return lines.join('\n');
 }
 
 // ─── Main Render ─────────────────────────────────────────────────────────────
@@ -153,18 +178,16 @@ export function renderInjection(resource, reason) {
     // Priority: if invocation_name is set, the skill is a registered Claude Code skill/plugin
     // → instruct Claude to invoke via Skill tool (enables adoption tracking)
     if (resource.invocation_name) {
-      injection = injectSkillInvocable(resource);
+      injection = injectSkillInvocable(resource, reason);
     } else if (isNativeSkill(resource.name)) {
-      injection = injectSkillNative(resource);
+      injection = injectSkillNative(resource, reason);
     } else {
-      injection = injectSkillManaged(resource);
+      injection = injectSkillManaged(resource, reason);
     }
   } else {
-    injection = injectAgent(resource);
+    injection = injectAgent(resource, reason);
   }
 
-  if (reason) injection += `\nReason: ${reason}`;
-
   // Hard limit enforcement
   if (injection.length > MAX_INJECTION_CHARS) {
     injection = injection.slice(0, MAX_INJECTION_CHARS - 3) + '...';
@@ -172,3 +195,19 @@ export function renderInjection(resource, reason) {
 
   return injection;
 }
+
+/**
+ * Render a lightweight one-line hint for medium-confidence recommendations.
+ * Costs ~30 tokens instead of ~500 for full injection.
+ * @param {object} resource Resource object from DB
+ * @returns {string} Single-line hint text
+ */
+export function renderHint(resource) {
+  const cap = truncate(resource.capability_summary || '', 80);
+  const invoke = resource.invocation_name
+    ? ` (Skill: "${resource.invocation_name}")`
+    : resource.type === 'agent'
+      ? ` (Agent: "${resource.name}")`
+      : '';
+  return `[Hint] Consider: "${resource.name}" — ${cap}${invoke}`;
+}

package/dispatch-patterns.mjs

@@ -0,0 +1,173 @@
+// claude-mem-lite: Failure pattern detection for pain-point dispatch
+// Detects when Claude is struggling (repeated test failures, same errors, blind editing)
+// and signals the dispatch system to recommend resources at the right moment.
+
+import { EDIT_TOOLS } from './utils.mjs';
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const WINDOW_SIZE = 20;
+
+const TEST_CMD_RE = /\b(test|jest|vitest|pytest|mocha|cypress|playwright|cargo\s+test|go\s+test)\b/i;
+const TEST_FAIL_RE = /\bfail|error|FAIL|Error|panic|exception/i;
+const ERROR_CLASS_RE = /\b(type\s*error|syntax\s*error|reference\s*error|module\s*not\s*found|TS\d{4}|E\d{4}|error\s+\w+:)/i;
+const VERIFY_CMD_RE = /\b(test|jest|vitest|pytest|lint|eslint|tsc|typecheck|build)\b/i;
+
+// Read-only tools that don't break a blind-editing streak
+const PASSIVE_TOOLS = new Set(['Read', 'Glob', 'Grep']);
+
+// ─── Pattern Detection ───────────────────────────────────────────────────────
+
+/**
+ * Detect failure patterns in recent session events.
+ * Analyzes a sliding window of the last 20 events to identify when Claude
+ * is struggling with repeated failures or blind editing.
+ *
+ * @param {Array<{tool_name: string, tool_input?: object, tool_response?: string}>} events
+ *   Array of session events (tool invocations with name, input, and response)
+ * @returns {{ pattern: string, resource_intent: string, confidence: number } | null}
+ *   Detected pattern with recommended resource intent and confidence, or null
+ */
+export function detectFailurePattern(events) {
+  if (!events || events.length === 0) return null;
+
+  // Only consider the last WINDOW_SIZE events
+  const window = events.slice(-WINDOW_SIZE);
+
+  // Check patterns in priority order
+  return detectRepeatedTestFail(window)
+    || detectRepeatedBashError(window)
+    || detectBlindEditing(window);
+}
+
+// ─── Pattern: repeated-test-fail ─────────────────────────────────────────────
+
+/**
+ * Detect (Edit → Bash[test fail]) cycles appearing 2+ times.
+ * An edit tool followed by a Bash command that runs tests and fails.
+ */
+function detectRepeatedTestFail(window) {
+  let cycles = 0;
+  let sawEdit = false;
+
+  for (const event of window) {
+    const tool = event.tool_name;
+
+    if (EDIT_TOOLS.has(tool)) {
+      sawEdit = true;
+      continue;
+    }
+
+    if (sawEdit && tool === 'Bash') {
+      const cmd = event.tool_input?.command || '';
+      const resp = event.tool_response || '';
+      if (TEST_CMD_RE.test(cmd) && TEST_FAIL_RE.test(resp)) {
+        cycles++;
+        sawEdit = false;
+        continue;
+      }
+    }
+
+    // Non-edit, non-matching-bash resets the edit flag
+    // (but keep counting if we see more edits later)
+    if (!EDIT_TOOLS.has(tool)) {
+      sawEdit = false;
+    }
+  }
+
+  if (cycles < 2) return null;
+
+  return {
+    pattern: 'repeated-test-fail',
+    resource_intent: 'fix',
+    confidence: 0.7 + Math.min(cycles - 2, 3) * 0.1,
+  };
+}
+
+// ─── Pattern: repeated-bash-error ────────────────────────────────────────────
+
+/**
+ * Detect 3+ Bash errors (test failures or compilation errors) in the window.
+ */
+function detectRepeatedBashError(window) {
+  let errorCount = 0;
+
+  for (const event of window) {
+    if (event.tool_name !== 'Bash') continue;
+    const resp = event.tool_response || '';
+    if (TEST_FAIL_RE.test(resp) || ERROR_CLASS_RE.test(resp)) {
+      errorCount++;
+    }
+  }
+
+  if (errorCount < 3) return null;
+
+  return {
+    pattern: 'repeated-bash-error',
+    resource_intent: 'fix',
+    confidence: 0.6 + Math.min(errorCount - 3, 4) * 0.1,
+  };
+}
+
+// ─── Pattern: blind-editing ──────────────────────────────────────────────────
+
+/**
+ * Detect 5+ consecutive edits to the same file without any test/lint/build verification.
+ * Read/Grep/Glob are passive and don't break the streak; other tools do.
+ * Bash with a verify command (test/lint/tsc/build) breaks the streak.
+ */
+function detectBlindEditing(window) {
+  let streak = 0;
+  let targetFile = null;
+
+  for (const event of window) {
+    const tool = event.tool_name;
+
+    // Edit tools extend the streak
+    if (EDIT_TOOLS.has(tool)) {
+      const file = event.tool_input?.file_path || '';
+      if (!targetFile) {
+        targetFile = file;
+        streak = 1;
+      } else if (file === targetFile) {
+        streak++;
+      } else {
+        // Different file — restart streak
+        targetFile = file;
+        streak = 1;
+      }
+      continue;
+    }
+
+    // Passive tools don't break the streak
+    if (PASSIVE_TOOLS.has(tool)) {
+      continue;
+    }
+
+    // Bash with verify command breaks the streak
+    if (tool === 'Bash') {
+      const cmd = event.tool_input?.command || '';
+      if (VERIFY_CMD_RE.test(cmd)) {
+        streak = 0;
+        targetFile = null;
+        continue;
+      }
+      // Non-verify Bash breaks the streak too
+      streak = 0;
+      targetFile = null;
+      continue;
+    }
+
+    // Any other tool breaks the streak
+    streak = 0;
+    targetFile = null;
+  }
+
+  if (streak < 5) return null;
+
+  return {
+    pattern: 'blind-editing',
+    resource_intent: 'test',
+    confidence: 0.5 + Math.min(streak - 5, 5) * 0.1,
+  };
+}