hippo-memory 0.39.0 → 0.40.0

package/README.md

@@ -85,6 +85,11 @@ hippo recall "data pipeline issues" --budget 2000
 
 ---
 
+### What's new in v0.40.0
+
+- **Company Brain measurement gates.** Two new diagnostic commands close the last blocked rows of the Company Brain scorecard. `hippo provenance [--json] [--strict]` audits every `kind='raw'` row for `owner` + `artifact_ref`; `--strict` exits non-zero so CI can block on coverage regressions. `hippo correction-latency [--json]` reports p50 / p95 / max wall-clock lag from receipt to supersession across `superseded_by` chains. Both helpers (`buildProvenanceCoverage`, `buildCorrectionLatency`) are importable from `src/`.
+- **No behavioral change to remember / recall.** Additive only: schema unchanged, retrieval untouched.
+
 ### What's new in v0.39.0
 
 - Security hardening release: 5 CRITICAL cross-tenant fixes (CVE candidates), GDPR Path A on archive (true RTBF), MCP per-client isolation, Slack ingestion race + idempotency hardening, auth timing leak reduction.

package/dist/cli.js

@@ -53,6 +53,8 @@ import { importChatGPT, importClaude, importCursor, importGenericFile, importMar
 import { cmdCapture } from './capture.js';
 import { auditMemories, appendAuditEvent, } from './audit.js';
 import { listApiKeys, revokeApiKey } from './auth.js';
+import { buildProvenanceCoverage } from './provenance-coverage.js';
+import { buildCorrectionLatency } from './correction-latency.js';
 import * as api from './api.js';
 import * as client from './client.js';
 import { detectServer, removePidfile } from './server-detect.js';
@@ -4621,6 +4623,11 @@ Commands:
     --threshold <n>        Overlap threshold 0-1 (default: 0.7)
   status                   Show memory health stats
   audit [--fix]            Check memory quality (--fix removes junk)
+  provenance               Provenance coverage gate for kind='raw' rows
+    --json                 Output as JSON
+    --strict               Exit non-zero when coverage < 100%
+  correction-latency       Wall-clock lag from receipt to supersession (p50/p95/max)
+    --json                 Output as JSON
   outcome                  Apply feedback to last recall
     --good                 Memories were helpful
     --bad                  Memories were irrelevant
@@ -5008,6 +5015,62 @@ async function main() {
             }
             break;
         }
+        case 'correction-latency': {
+            requireInit(hippoRoot);
+            const entries = loadAllEntries(hippoRoot);
+            const report = buildCorrectionLatency(entries);
+            if (flags['json']) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else if (report.count === 0) {
+                console.log('No supersessions found. Correction latency is undefined.');
+            }
+            else {
+                const fmt = (ms) => {
+                    if (ms === null)
+                        return 'n/a';
+                    if (ms < 1000)
+                        return `${ms}ms`;
+                    if (ms < 60_000)
+                        return `${(ms / 1000).toFixed(1)}s`;
+                    if (ms < 3_600_000)
+                        return `${(ms / 60_000).toFixed(1)}m`;
+                    return `${(ms / 3_600_000).toFixed(1)}h`;
+                };
+                console.log(`Corrections: ${report.count} total (${report.extractionCount} extraction-driven, ${report.manualCount} manual)`);
+                console.log(`Latency p50: ${fmt(report.p50Ms)}, p95: ${fmt(report.p95Ms)}, max: ${fmt(report.maxMs)}`);
+                if (report.extractionCount === 0 && report.manualCount > 0) {
+                    console.log(`\nAll ${report.manualCount} corrections were manual supersedes: no measurable observation lag.`);
+                    console.log(`To measure latency, route corrections through extraction (set new.extracted_from to the raw receipt).`);
+                }
+            }
+            break;
+        }
+        case 'provenance': {
+            requireInit(hippoRoot);
+            const entries = loadAllEntries(hippoRoot);
+            const coverage = buildProvenanceCoverage(entries);
+            if (flags['json']) {
+                console.log(JSON.stringify(coverage, null, 2));
+            }
+            else if (coverage.rawTotal === 0) {
+                console.log('No kind=raw memories present. Coverage gate trivially satisfied.');
+            }
+            else {
+                const pct = (coverage.coverage * 100).toFixed(1);
+                console.log(`Provenance coverage: ${coverage.rawWithEnvelope}/${coverage.rawTotal} raw rows envelope-complete (${pct}%)`);
+                if (coverage.gaps.length > 0) {
+                    console.log(`\nGaps:`);
+                    for (const g of coverage.gaps) {
+                        console.log(`  ${g.id}: missing ${g.missing.join(', ')}`);
+                    }
+                }
+            }
+            if (flags['strict'] && coverage.coverage < 1) {
+                process.exit(1);
+            }
+            break;
+        }
         case 'status':
             cmdStatus(hippoRoot);
             break;