Influencer re-study 2026-07-09: advisor ingest fix, hook-output validity, truncation + error-handling gates (#92–#95)

Rakefile

@@ -42,4 +42,50 @@ namespace :plugin do
   end
 end
 
-task default: %i[spec standard]
+namespace :audit do
+  desc "Scan lib/ for error-handling anti-patterns (swallowed errors); exits non-zero on unignored blocking findings"
+  task :error_handling do
+    require_relative "lib/claude_memory/audit/error_handling_scanner"
+
+    scanner = ClaudeMemory::Audit::ErrorHandlingScanner.new
+    offenses = Dir["lib/**/*.rb"].sort.flat_map do |path|
+      scanner.scan(File.read(path), path: path)
+    end
+
+    active = offenses.reject(&:overridden?)
+    overridden = offenses.select(&:overridden?)
+    blocking = active.select(&:blocking?)
+
+    puts "Error-handling anti-pattern scan (lib/)"
+    puts
+
+    if active.empty?
+      puts "  No active findings."
+    else
+      active.sort_by { |o| [o.path, o.line] }.each do |o|
+        puts format("  %-45s %-18s [%s] %s", "#{o.path}:#{o.line}", o.pattern, o.severity, o.message)
+      end
+    end
+
+    unless overridden.empty?
+      puts
+      puts "Documented swallows (overridden):"
+      overridden.sort_by { |o| [o.path, o.line] }.each do |o|
+        puts format("  %-45s %-18s — %s", "#{o.path}:#{o.line}", o.pattern, o.override_reason)
+      end
+    end
+
+    puts
+    puts format("Summary: %d blocking, %d advisory, %d overridden",
+      blocking.size, active.size - blocking.size, overridden.size)
+
+    if blocking.any?
+      puts
+      puts "Blocking findings must re-raise, log, return a real value, or be annotated with"
+      puts "  # [ANTI-PATTERN IGNORED]: <reason>"
+      abort "audit:error_handling failed with #{blocking.size} blocking finding(s)"
+    end
+  end
+end
+
+task default: %i[spec standard audit:error_handling]

docs/audit_runbook.md

@@ -245,6 +245,55 @@ Exit code is `0` when `ok: true`, `1` otherwise. `--no-exit` always returns `0`.
 - For a bad `corroboration_count`, re-derive sighting counts via the Reflector's dedup pass.
 - For an unknown status, find the writer that bypassed `insert_observation` (the only sanctioned insert path).
 
+### C015 — Truncated source content
+
+**Severity:** info
+
+**Scope:** both DBs.
+
+**Triggered when:** a `content_items` row's `raw_text` carries a host-truncation marker — e.g. `[Read output capped at N lines]`, `[Truncated: N chars]`, "output was truncated", or an "N lines omitted / N characters truncated" count form (see `Distill::TruncationDetector`).
+
+**Why it matters:** Claude Code caps large tool output (notably Read) and leaves a marker in the transcript. Facts the distiller extracts from such a fragment were drawn from incomplete content, not complete ground truth — the same false-positive class as documentation example text the distiller takes literally. The detector deliberately does not recover the full file from disk: ingest runs after the fact and the file may have changed since, so disk recovery at ingest would be temporally unsound.
+
+**Remediation:**
+- Trace facts back with `claude-memory explain <fact_id>`.
+- Reject any fact that asserts something the truncated fragment could not actually confirm.
+- If you need the full content, re-run the relevant tool without truncation so the complete text is re-ingested.
+
+## Source-level gate: `rake audit:error_handling`
+
+Separate from the `C###` checks above. Those inspect **memory-corpus state** (the DBs); this inspects **Ruby source** and enforces the "swallowed errors stay visible" convention as a deterministic, non-LLM gate. It runs as part of `rake default` and can be invoked directly:
+
+```bash
+bundle exec rake audit:error_handling
+```
+
+Backed by `ClaudeMemory::Audit::ErrorHandlingScanner` — a Prism AST walker (not regex), so the checks are structural facts, not pattern guesses.
+
+**What it flags:**
+
+| Pattern | Severity | Meaning |
+| --- | --- | --- |
+| `EMPTY_RESCUE` | error (blocking) | A **broad** rescue (bare, `StandardError`, or `Exception`) with an empty or comment-only body. |
+| `RESCUE_NIL` | error (blocking) | A **broad** rescue whose body is only `nil`, or a `expr rescue nil` modifier. |
+| `RESCUE_EXCEPTION` | warn | Rescues `Exception` — also catches signals and system errors. |
+| `ERROR_STRING_MATCH` | info | Control flow branches on the exception's `.message` text — brittle across library/Ruby versions. |
+
+**Breadth is the discriminator.** A *narrow, typed* rescue that returns `nil` — `rescue JSON::ParserError; nil` — is a documented "unparseable/unavailable → nil" contract, the idiom used throughout `lib/`, and is intentionally **not** flagged. Only broad swallows (which discard the whole `StandardError` hierarchy invisibly) block.
+
+**Override — documenting a deliberate swallow.** A genuine best-effort/background swallow stays green by annotating it inside or directly above the rescue:
+
+```ruby
+rescue
+  # [ANTI-PATTERN IGNORED]: background async process must never propagate errors to the caller
+  nil
+end
+```
+
+Overridden offenses are still reported (under "Documented swallows") but never block. The point is not to permit silent swallows but to convert them into *documented* ones. `lib/` currently carries three: the hook background-close, the stats FTS-metadata read, and the sweep FTS-GC removal.
+
+**Remediation for a new blocking finding:** re-raise, log, return a real value, narrow the rescue to a specific exception class, or — if the swallow is genuinely intended — add the `[ANTI-PATTERN IGNORED]: <reason>` marker.
+
 ## Adding a new check
 
 The audit is extensible by design.