@massu/core 1.15.3 → 1.15.4

package/dist/hooks/post-tool-use.js

@@ -1,28 +1,46 @@
 #!/usr/bin/env node
 import{createRequire as __cr}from"module";const require=__cr(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-
-// src/memory-db.ts
-import Database from "better-sqlite3";
-import { dirname as dirname2, basename } from "path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-
-// src/config.ts
-import { resolve as resolve2, dirname } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/memory-path.ts
 function encodeMemoryDirName(projectRoot) {
   return projectRoot.replace(/\//g, "-");
 }
+var init_memory_path = __esm({
+  "src/lib/memory-path.ts"() {
+    "use strict";
+  }
+});
 
 // src/credentials.ts
 import { homedir } from "os";
@@ -35,9 +53,6 @@ import {
   rmSync,
   chmodSync
 } from "fs";
-var MASSU_ENV_API_KEY = "MASSU_API_KEY";
-var MASSU_ENV_CLOUD_ENDPOINT = "MASSU_CLOUD_ENDPOINT";
-var DEFAULT_CLOUD_ENDPOINT = "https://api.massu.ai/v1";
 function credentialsDir(home = homedir()) {
   return resolve(home, ".massu");
 }
@@ -85,391 +100,160 @@ function resolveEndpoint(opts = {}) {
   if (envEp.length > 0) return envEp;
   return DEFAULT_CLOUD_ENDPOINT;
 }
-
-// src/config.ts
-var DomainConfigSchema = z.object({
-  name: z.string().default("Unknown"),
-  routers: z.array(z.string()).default([]),
-  pages: z.array(z.string()).default([]),
-  tables: z.array(z.string()).default([]),
-  allowedImportsFrom: z.array(z.string()).default([])
-});
-var PatternRuleConfigSchema = z.object({
-  pattern: z.string().default("**"),
-  rules: z.array(z.string()).default([]),
-  language: z.string().optional()
-});
-var CostModelSchema = z.object({
-  input_per_million: z.number(),
-  output_per_million: z.number(),
-  cache_read_per_million: z.number().optional(),
-  cache_write_per_million: z.number().optional()
-});
-var AnalyticsConfigSchema = z.object({
-  quality: z.object({
-    weights: z.record(z.string(), z.number()).default({
-      bug_found: -5,
-      vr_failure: -10,
-      incident: -20,
-      cr_violation: -3,
-      vr_pass: 2,
-      clean_commit: 5,
-      successful_verification: 3
-    }),
-    categories: z.array(z.string()).default(["security", "architecture", "coupling", "tests", "rule_compliance"])
-  }).optional(),
-  cost: z.object({
-    models: z.record(z.string(), CostModelSchema).default({}),
-    currency: z.string().default("USD")
-  }).optional(),
-  prompts: z.object({
-    success_indicators: z.array(z.string()).default(["committed", "approved", "looks good", "perfect", "great", "thanks"]),
-    failure_indicators: z.array(z.string()).default(["revert", "wrong", "that's not", "undo", "incorrect"]),
-    max_turns_for_success: z.number().default(2)
-  }).optional()
-}).optional();
-var CustomPatternSchema = z.object({
-  pattern: z.string(),
-  severity: z.string(),
-  message: z.string()
-});
-var GovernanceConfigSchema = z.object({
-  audit: z.object({
-    formats: z.array(z.string()).default(["summary", "detailed", "soc2"]),
-    retention_days: z.number().default(365),
-    auto_log: z.record(z.string(), z.boolean()).default({
-      code_changes: true,
-      rule_enforcement: true,
-      approvals: true,
-      commits: true
-    })
-  }).optional(),
-  validation: z.object({
-    realtime: z.boolean().default(true),
-    checks: z.record(z.string(), z.boolean()).default({
-      rule_compliance: true,
-      import_existence: true,
-      naming_conventions: true
-    }),
-    custom_patterns: z.array(CustomPatternSchema).default([])
-  }).optional(),
-  adr: z.object({
-    detection_phrases: z.array(z.string()).default(["chose", "decided", "switching to", "moving from", "going with"]),
-    template: z.string().default("default"),
-    storage: z.string().default("database"),
-    output_dir: z.string().default("docs/adr")
-  }).optional()
-}).optional();
-var SecurityPatternSchema = z.object({
-  pattern: z.string(),
-  severity: z.string(),
-  category: z.string(),
-  description: z.string()
-});
-var SecurityConfigSchema = z.object({
-  patterns: z.array(SecurityPatternSchema).default([]),
-  auto_score_on_edit: z.boolean().default(true),
-  score_threshold_alert: z.number().default(50),
-  severity_weights: z.record(z.string(), z.number()).optional(),
-  restrictive_licenses: z.array(z.string()).optional(),
-  dep_alternatives: z.record(z.string(), z.array(z.string())).optional(),
-  dependencies: z.object({
-    package_manager: z.string().default("npm"),
-    blocked_packages: z.array(z.string()).default([]),
-    preferred_packages: z.record(z.string(), z.string()).default({}),
-    max_bundle_size_kb: z.number().default(500)
-  }).optional()
-}).optional();
-var TeamConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  sync_backend: z.string().default("local"),
-  developer_id: z.string().default("auto"),
-  share_by_default: z.boolean().default(false),
-  expertise_weights: z.object({
-    session: z.number().default(20),
-    observation: z.number().default(10)
-  }).optional(),
-  privacy: z.object({
-    share_file_paths: z.boolean().default(true),
-    share_code_snippets: z.boolean().default(false),
-    share_observations: z.boolean().default(true)
-  }).optional()
-}).optional();
-var RegressionConfigSchema = z.object({
-  test_patterns: z.array(z.string()).default([
-    "{dir}/__tests__/{name}.test.{ext}",
-    "{dir}/{name}.spec.{ext}",
-    "tests/{path}.test.{ext}"
-  ]),
-  test_runner: z.string().default("npm test"),
-  health_thresholds: z.object({
-    healthy: z.number().default(80),
-    warning: z.number().default(50)
-  }).optional()
-}).optional();
-var AutoLearningConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  incidentDir: z.string().default("docs/incidents"),
-  memoryDir: z.string().default("memory"),
-  memoryIndexFile: z.string().default("MEMORY.md"),
-  enforcementHooksDir: z.string().default("scripts/hooks"),
-  fixDetection: z.object({
-    enabled: z.boolean().default(true),
-    lookbackDays: z.number().default(7),
-    signals: z.array(z.string()).default([
-      "removed_broken_code",
-      "added_error_handling",
-      "method_name_correction",
-      "auth_fix",
-      "nil_handling_fix",
-      "concurrency_fix",
-      "async_pattern_fix",
-      "added_missing_import"
-    ])
-  }).default({}),
-  failureClassification: z.object({
-    enabled: z.boolean().default(true),
-    thresholds: z.object({
-      known: z.number().default(5),
-      similar: z.number().default(3)
-    }).default({}),
-    scoring: z.object({
-      diffPatternWeight: z.number().default(3),
-      filePatternWeight: z.number().default(2),
-      promptKeywordWeight: z.number().default(2)
-    }).default({})
-  }).default({}),
-  pipeline: z.object({
-    requireIncidentReport: z.boolean().default(true),
-    requirePreventionRule: z.boolean().default(true),
-    requireEnforcement: z.boolean().default(true)
-  }).default({}),
-  // plan-v0.2-interactive-rule-approval P-D-008 / P-D-009: project-configured
-  // custom destinations for the rule-candidate funnel. The classifier matches
-  // a candidate to one of these entries when none of the framework
-  // destinations (pattern-scanner / claude-md-cr / corrections-md) apply.
-  customDestinations: z.array(z.object({
-    name: z.string(),
-    path: z.string(),
-    triggerKeywords: z.array(z.string()).default([]),
-    template: z.string()
-  })).default([])
-}).optional();
-var CloudConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  apiKey: z.string().optional(),
-  endpoint: z.string().optional(),
-  sync: z.object({
-    memory: z.boolean().default(true),
-    analytics: z.boolean().default(true),
-    audit: z.boolean().default(true)
-  }).default({ memory: true, analytics: true, audit: true })
-}).optional();
-var ConventionsConfigSchema = z.object({
-  claudeDirName: z.string().default(".claude").refine(
-    (s) => !s.includes("..") && !s.startsWith("/"),
-    { message: 'claudeDirName must not contain ".." or start with "/"' }
-  ),
-  sessionStatePath: z.string().default(".claude/session-state/CURRENT.md").refine(
-    (s) => !s.includes("..") && !s.startsWith("/"),
-    { message: 'sessionStatePath must not contain ".." or start with "/"' }
-  ),
-  sessionArchivePath: z.string().default(".claude/session-state/archive").refine(
-    (s) => !s.includes("..") && !s.startsWith("/"),
-    { message: 'sessionArchivePath must not contain ".." or start with "/"' }
-  ),
-  knowledgeCategories: z.array(z.string()).default([
-    "patterns",
-    "commands",
-    "incidents",
-    "reference",
-    "protocols",
-    "checklists",
-    "playbooks",
-    "critical",
-    "scripts",
-    "status",
-    "templates",
-    "loop-state",
-    "session-state",
-    "agents"
-  ]),
-  knowledgeSourceFiles: z.array(z.string()).default(["CLAUDE.md", "MEMORY.md", "corrections.md"]),
-  excludePatterns: z.array(z.string()).default(["/ARCHIVE/", "/SESSION-HISTORY/"])
-}).optional();
-var PythonDomainConfigSchema = z.object({
-  name: z.string(),
-  packages: z.array(z.string()),
-  allowed_imports_from: z.array(z.string()).default([])
+var MASSU_ENV_API_KEY, MASSU_ENV_CLOUD_ENDPOINT, DEFAULT_CLOUD_ENDPOINT;
+var init_credentials = __esm({
+  "src/credentials.ts"() {
+    "use strict";
+    MASSU_ENV_API_KEY = "MASSU_API_KEY";
+    MASSU_ENV_CLOUD_ENDPOINT = "MASSU_CLOUD_ENDPOINT";
+    DEFAULT_CLOUD_ENDPOINT = "https://api.massu.ai/v1";
+  }
 });
-var PythonConfigSchema = z.object({
-  root: z.string(),
-  alembic_dir: z.string().optional(),
-  domains: z.array(PythonDomainConfigSchema).default([]),
-  exclude_dirs: z.array(z.string()).default(["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"])
-}).optional();
-var PathsConfigSchema = z.object({
-  source: z.string().default("src"),
-  aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
-  monorepo_roots: z.array(z.string()).optional(),
-  routers: z.string().optional(),
-  routerRoot: z.string().optional(),
-  pages: z.string().optional(),
-  middleware: z.string().optional(),
-  schema: z.string().optional(),
-  components: z.string().optional(),
-  hooks: z.string().optional()
+
+// src/config-memory-schema.ts
+import { z } from "zod";
+var MemoryConfigSchema;
+var init_config_memory_schema = __esm({
+  "src/config-memory-schema.ts"() {
+    "use strict";
+    MemoryConfigSchema = z.object({
+      recall: z.object({
+        enabled: z.boolean().default(true),
+        maxTokens: z.number().int().positive().default(1200),
+        sources: z.array(
+          z.enum([
+            "observation",
+            "architecture_decision",
+            "knowledge_chunk",
+            "failure_class"
+          ])
+        ).default(["observation", "architecture_decision", "knowledge_chunk", "failure_class"]),
+        timeoutMs: z.number().int().positive().default(8e3),
+        limit: z.number().int().positive().default(8),
+        minScore: z.number().min(0).default(0),
+        // --- Semantic embedder (plan-living-memory-slice-2a-embedder, P3-001) ---
+        // embedEnabled: Tier-1 bundled WASM embedder on by default; false forces
+        //   Tier-2 (FTS keyword-only) recall.
+        // embedEndpoint: optional Tier-0 OpenAI-compatible /v1/embeddings provider
+        //   (Ollama, LM Studio, vLLM, or any hosted API). When set, embedding egresses ONLY to this
+        //   operator-chosen endpoint; unset means zero egress (bundled model).
+        // embedModel: optional Tier-0 model name sent to that endpoint.
+        embedEnabled: z.boolean().default(true),
+        embedEndpoint: z.string().url().refine((s) => /^https?:\/\//i.test(s), {
+          message: "memory.recall.embedEndpoint must be an http(s) URL"
+        }).optional(),
+        embedModel: z.string().min(1).optional()
+      }).default({}),
+      // --- Contradiction / supersede gate (plan-living-memory-slice-2-temporal-model, P5-001) ---
+      // When a new high-value memory (decision/correction) is written, find
+      // semantically-related existing records and, if the new one contradicts an
+      // old one, supersede-don't-delete the old row. Fully fail-open + gated to a
+      // small set of high-value types so the hot capture path is untouched.
+      contradiction: z.object({
+        // Master switch. false → every write is a plain insert (prior behavior).
+        enabled: z.boolean().default(true),
+        // Optional Tier-0 external judge (OpenAI-compatible). null/unset → local
+        // heuristic only, ZERO egress. When set, candidate + related records egress
+        // ONLY to this operator-chosen endpoint; any error falls back to heuristic.
+        judgeEndpoint: z.string().url().refine((s) => /^https?:\/\//i.test(s), {
+          message: "memory.contradiction.judgeEndpoint must be an http(s) URL"
+        }).optional(),
+        // Cosine similarity above which a correction-flavored new record is treated
+        // as superseding a related existing record. Calibrated to all-MiniLM-L6-v2
+        // (same-topic contradictions ≈0.65–0.86; related-but-complementary ≈0.47).
+        similarityThreshold: z.number().min(0).max(1).default(0.6),
+        // Cosine similarity above which a new record is a near-duplicate (NOOP).
+        dedupThreshold: z.number().min(0).max(1).default(0.93),
+        // Observation types the gate runs for. High-volume 'file_change' is
+        // deliberately excluded so the hot path never triggers a hybridSearch.
+        gatedTypes: z.array(z.string()).default(["decision", "cr_violation", "failed_attempt"]),
+        // When true, superseded rows may still surface in recall with a
+        // "(superseded on <date> by #<id>)" annotation instead of being excluded.
+        annotateSuperseded: z.boolean().default(false),
+        // Time budget (ms) for the contradiction check; exceeded → fail-open (ADD).
+        budgetMs: z.number().int().positive().default(800)
+      }).default({}),
+      // --- Background consolidation, the "sleep-time" pass
+      //     (plan-living-memory-slice-3-consolidation) ---
+      // Keeps memory sharp over years: dedupes, distills dying sessions into
+      // durable lessons, spots corrections you keep repeating, reweights by what
+      // actually gets used, and retires dead weight by EXPIRING it (never deleting).
+      //
+      // Runs with ZERO LLM and ZERO network by default — every stage is arithmetic
+      // plus the embedding model Massu already bundles. `llmEndpoint` is OPTIONAL
+      // and upgrades the prose of session summaries ONLY.
+      consolidation: z.object({
+        enabled: z.boolean().default(true),
+        // Bounded sweep at session end — the automatic path (no scheduler needed).
+        sessionSweepEnabled: z.boolean().default(true),
+        // OPTIONAL local/remote OpenAI-compatible chat endpoint. UNSET = zero egress.
+        // When set, session text egresses ONLY to this endpoint you chose.
+        // NOTE: the API key is NEVER configured here — it is read exclusively from
+        // the MASSU_MEMORY_LLM_API_KEY env var, so a key can never be committed.
+        llmEndpoint: z.string().url().refine((s) => /^https?:\/\//i.test(s), {
+          message: "memory.consolidation.llmEndpoint must be an http(s) URL"
+        }).optional(),
+        // Model NAME/ALIAS sent to llmEndpoint (e.g. "llama3.1:8b").
+        llmModel: z.string().optional(),
+        // Distill a session once its newest turn is older than this. Must stay
+        // INSIDE the 7-day conversation_turns prune window or the raw material is
+        // destroyed before it is ever summarized.
+        summarizeAfterDays: z.number().int().positive().default(5),
+        // Age past which an unprotected, never-retrieved, low-importance row may expire.
+        retentionDays: z.number().int().positive().default(90),
+        importanceFloor: z.number().int().min(1).max(5).default(2),
+        // Types that may NEVER expire, however old.
+        protectedTypes: z.array(z.string()).default(["decision", "cr_violation", "incident_near_miss"]),
+        // Days the retrieval counter must observe usage BEFORE any expiry is armed.
+        // The cold-start guard: on a fresh counter nothing has "ever been
+        // retrieved", so without this the first pass would gut the store.
+        usageWarmupDays: z.number().int().nonnegative().default(30),
+        // Per-pass decay on the windowed hit count, so usefulness must be sustained.
+        usageDecay: z.number().min(0).max(1).default(0.9),
+        // A record is reweighted at most once per this many days (idempotency).
+        reweightIntervalDays: z.number().int().positive().default(1),
+        // Recurrences (across >= 2 sessions) before a rule candidate is proposed.
+        promoteMinOccurrences: z.number().int().positive().default(3),
+        budgetMs: z.number().int().positive().default(3e3),
+        // Surface optional upgrades (e.g. "a local model was detected") in chat.
+        suggestUpgrades: z.boolean().default(true),
+        suggestIntervalDays: z.number().int().positive().default(30)
+      }).default({}),
+      // A-20 (Slice 4) — memory FILES: the mirror, and the one switch that decides whether
+      // Massu may ever WRITE into the user's memory directory.
+      //
+      // ⛔ `renderEnabled` DEFAULTS TO FALSE. 4B is the first capability in Massu's history
+      // that writes files into the place the user keeps their own hand-written prose. A new
+      // write capability that arrives switched-on in an `npm update` is a capability nobody
+      // consented to. The path is: the advisor OFFERS it in chat -> the user runs
+      // `massu memory render --dry-run` and sees exactly what WOULD be written -> the user
+      // turns it on. Three deliberate steps, none implicit. A drift-guard pins this default.
+      files: z.object({
+        // The lossless file<->store mirror (ingest side). Read-only; it writes nothing.
+        enabled: z.boolean().default(true),
+        // The ONLY flag here that grants a WRITE. Never auto-enable.
+        renderEnabled: z.boolean().default(false),
+        // Anti-spam: files Massu may render in ONE session.
+        renderMaxFilesPerSession: z.number().int().min(0).default(3),
+        // Only memories at/above this importance are worth a durable file.
+        renderMinImportance: z.number().int().min(1).max(5).default(4),
+        // The clearly-labelled MEMORY.md section Massu's pointers live under.
+        indexSection: z.string().default("Learned by Massu"),
+        // Hard bound on the managed MEMORY.md region. MEMORY.md is auto-loaded into EVERY
+        // turn of EVERY session, so an unbounded index is a permanent context tax — and the
+        // per-session cap bounds only the RATE, never the total.
+        indexMaxLines: z.number().int().min(1).default(50)
+      }).default({})
+    }).optional();
+  }
 });
-var LanguageFrameworkEntrySchema = z.object({
-  framework: z.string().optional(),
-  test_framework: z.string().optional(),
-  test: z.string().optional(),
-  runtime: z.string().optional(),
-  orm: z.string().optional(),
-  router: z.string().optional(),
-  ui: z.string().optional()
-}).passthrough();
-var FrameworkConfigSchema = z.object({
-  type: z.string().default("typescript"),
-  primary: z.string().optional(),
-  router: z.string().default("none"),
-  orm: z.string().default("none"),
-  ui: z.string().default("none"),
-  languages: z.record(z.string(), LanguageFrameworkEntrySchema).optional()
-}).passthrough();
-var DetectedConfigSchema = z.object({}).passthrough().optional();
-var VerificationEntrySchema = z.object({
-  type: z.string().optional(),
-  test: z.string().optional(),
-  syntax: z.string().optional(),
-  lint: z.string().optional(),
-  build: z.string().optional()
-}).passthrough();
-var VerificationConfigSchema = z.record(z.string(), VerificationEntrySchema).optional();
-var CanonicalPathsSchema = z.record(z.string(), z.string()).optional();
-var VerificationTypesSchema = z.record(z.string(), z.string()).optional();
-var DetectionRuleEntrySchema = z.object({
-  signals: z.array(z.string()).default([]),
-  priority: z.number().optional()
-}).passthrough();
-var DetectionConfigSchema = z.object({
-  rules: z.record(
-    z.string(),
-    // language
-    z.record(z.string(), DetectionRuleEntrySchema)
-    // framework -> rule entry
-  ).optional(),
-  signal_weights: z.record(z.string(), z.number()).optional(),
-  disable_builtin: z.boolean().optional()
-}).passthrough().optional();
-var WatchConfigSchema = z.object({
-  debounce_ms: z.number().int().positive().default(3e3),
-  storm_threshold: z.number().int().positive().default(50),
-  deep_storm_threshold: z.number().int().positive().default(500),
-  hard_timeout_ms: z.number().int().positive().default(3e5),
-  scope: z.enum(["paths", "full"]).default("paths"),
-  // Plan 3a hotfix 2026-05-02: refuse to start if the watch surface
-  // exceeds this many files. Prevents the misconfig pattern where
-  // `paths.source_dirs` includes `.` or otherwise expands to a 60K+
-  // file tree, producing 30-100% steady CPU. Override via
-  // `paths_full_root_opt_in: true` for users on small repos who genuinely
-  // need root-level watching.
-  max_watched_files: z.number().int().positive().default(1e4),
-  paths_full_root_opt_in: z.boolean().default(false)
-}).passthrough().optional();
-var AdapterLocalPathSchema = z.string().refine((s) => !/^([A-Za-z]:[\\/]|[\\/])/.test(s), {
-  message: "absolute paths are rejected; adapters.local entries must be relative to the massu.config.yaml directory"
-}).refine((s) => !s.split(/[\\/]/).includes(".."), {
-  message: "parent-directory traversal (`..`) is rejected; adapters.local entries must stay inside the project tree"
-}).transform((s) => s.split(/[\\/]/).filter((part) => part !== "" && part !== ".").join("/"));
-var AdaptersConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  local: z.array(AdapterLocalPathSchema).default([])
-}).passthrough().optional();
-var TelemetryConfigSchema = z.object({
-  adapters: z.boolean().default(false)
-}).passthrough().optional();
-var LSPConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  servers: z.array(z.object({
-    language: z.string(),
-    command: z.string(),
-    // F-014 (closed 2026-05-06): explicit opt-in to spawn SUID/SGID
-    // binaries. Default false — argv[0] with the SUID bit is rejected
-    // unless this is true. Decision is auditable in the YAML.
-    allow_setuid: z.boolean().default(false),
-    // F-015 (closed 2026-05-06): per-server RSS budget (MB). Watchdog
-    // SIGKILLs the server after sustained breach. Default 1024 MB.
-    // Set to 0 to disable the watchdog for this server.
-    max_rss_mb: z.number().int().nonnegative().default(1024)
-  })).default([]),
-  autoDetect: z.object({
-    viaPortScan: z.boolean().default(false)
-  }).optional()
-}).passthrough();
-var RawConfigSchema = z.object({
-  schema_version: z.union([z.literal(1), z.literal(2)]).default(1),
-  project: z.object({
-    name: z.string().default("my-project"),
-    root: z.string().default("auto")
-  }).default({ name: "my-project", root: "auto" }),
-  framework: FrameworkConfigSchema.default({
-    type: "typescript",
-    router: "none",
-    orm: "none",
-    ui: "none"
-  }),
-  paths: PathsConfigSchema.default({ source: "src", aliases: { "@": "src" } }),
-  toolPrefix: z.string().default("massu"),
-  dbAccessPattern: z.string().optional(),
-  knownMismatches: z.record(z.string(), z.record(z.string(), z.string())).optional(),
-  accessScopes: z.array(z.string()).optional(),
-  domains: z.array(DomainConfigSchema).default([]),
-  rules: z.array(PatternRuleConfigSchema).default([]),
-  // P-M-036 (plan-stage-d-medium-sweep): customer-authored CR-style
-  // governance rules. DISTINCT from `rules:` above (path-scoped lint hints
-  // used by pattern-scanner). At config-refresh time these entries are
-  // loaded into the `knowledge_rules` SQLite table with
-  // `source = 'customer-config'` so `massu_knowledge_rule` and the
-  // governance docs surface customer-defined rules alongside framework CRs.
-  governance_rules: z.array(
-    z.object({
-      id: z.string().min(1, "governance_rules[].id is required"),
-      title: z.string().min(1, "governance_rules[].title is required"),
-      description: z.string().min(1, "governance_rules[].description is required"),
-      vr_type: z.string().default("VR-CUSTOM"),
-      reference_path: z.string().optional(),
-      severity: z.enum(["critical", "high", "medium", "low", "info"]).default("medium")
-    }).passthrough()
-  ).default([]),
-  analytics: AnalyticsConfigSchema,
-  governance: GovernanceConfigSchema,
-  security: SecurityConfigSchema,
-  team: TeamConfigSchema,
-  regression: RegressionConfigSchema,
-  cloud: CloudConfigSchema,
-  conventions: ConventionsConfigSchema,
-  autoLearning: AutoLearningConfigSchema,
-  python: PythonConfigSchema,
-  // P2-004 / P2-005 / P2-006 / P2-008: v2 extensions (all optional)
-  verification: VerificationConfigSchema,
-  canonical_paths: CanonicalPathsSchema,
-  verification_types: VerificationTypesSchema,
-  detection: DetectionConfigSchema,
-  // Plan #2: detector-owned per-language conventions (free-form passthrough)
-  detected: DetectedConfigSchema,
-  // Plan 3a: file-watcher daemon tunables
-  watch: WatchConfigSchema,
-  // Plan 3c: third-party adapter registry kill-switch + signing override + local-path opt-in.
-  adapters: AdaptersConfigSchema,
-  // Plan 3c: anonymous adapter-discovery telemetry opt-in (default off).
-  telemetry: TelemetryConfigSchema,
-  // Plan 3b Phase 4: optional LSP enrichment of AST adapter results.
-  lsp: LSPConfigSchema.optional()
-}).passthrough();
-var _config = null;
-var _resolvedApiKeySource = "none";
-var _projectRoot = null;
+
+// src/config.ts
+import { resolve as resolve2, dirname } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { parse as parseYaml } from "yaml";
+import { z as z2 } from "zod";
 function findProjectRoot() {
   const cwd = process.cwd();
   let dir = cwd;
@@ -569,6 +353,7 @@ Hint: run \`massu config refresh\` to regenerate a valid config or fix the liste
     team: parsed.team,
     regression: parsed.regression,
     cloud: parsed.cloud,
+    memory: parsed.memory,
     conventions: parsed.conventions,
     autoLearning: parsed.autoLearning,
     python: parsed.python,
@@ -633,20 +418,1246 @@ function getResolvedPaths() {
     settingsLocalPath: resolve2(root, claudeDirName, "settings.local.json")
   };
 }
+var DomainConfigSchema, PatternRuleConfigSchema, CostModelSchema, AnalyticsConfigSchema, CustomPatternSchema, GovernanceConfigSchema, SecurityPatternSchema, SecurityConfigSchema, TeamConfigSchema, RegressionConfigSchema, AutoLearningConfigSchema, CloudConfigSchema, ConventionsConfigSchema, PythonDomainConfigSchema, PythonConfigSchema, PathsConfigSchema, LanguageFrameworkEntrySchema, FrameworkConfigSchema, DetectedConfigSchema, VerificationEntrySchema, VerificationConfigSchema, CanonicalPathsSchema, VerificationTypesSchema, DetectionRuleEntrySchema, DetectionConfigSchema, WatchConfigSchema, AdapterLocalPathSchema, AdaptersConfigSchema, TelemetryConfigSchema, LSPConfigSchema, RawConfigSchema, _config, _resolvedApiKeySource, _projectRoot;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_memory_path();
+    init_credentials();
+    init_config_memory_schema();
+    DomainConfigSchema = z2.object({
+      name: z2.string().default("Unknown"),
+      routers: z2.array(z2.string()).default([]),
+      pages: z2.array(z2.string()).default([]),
+      tables: z2.array(z2.string()).default([]),
+      allowedImportsFrom: z2.array(z2.string()).default([])
+    });
+    PatternRuleConfigSchema = z2.object({
+      pattern: z2.string().default("**"),
+      rules: z2.array(z2.string()).default([]),
+      language: z2.string().optional()
+    });
+    CostModelSchema = z2.object({
+      input_per_million: z2.number(),
+      output_per_million: z2.number(),
+      cache_read_per_million: z2.number().optional(),
+      cache_write_per_million: z2.number().optional()
+    });
+    AnalyticsConfigSchema = z2.object({
+      quality: z2.object({
+        weights: z2.record(z2.string(), z2.number()).default({
+          bug_found: -5,
+          vr_failure: -10,
+          incident: -20,
+          cr_violation: -3,
+          vr_pass: 2,
+          clean_commit: 5,
+          successful_verification: 3
+        }),
+        categories: z2.array(z2.string()).default(["security", "architecture", "coupling", "tests", "rule_compliance"])
+      }).optional(),
+      cost: z2.object({
+        models: z2.record(z2.string(), CostModelSchema).default({}),
+        currency: z2.string().default("USD")
+      }).optional(),
+      prompts: z2.object({
+        success_indicators: z2.array(z2.string()).default(["committed", "approved", "looks good", "perfect", "great", "thanks"]),
+        failure_indicators: z2.array(z2.string()).default(["revert", "wrong", "that's not", "undo", "incorrect"]),
+        max_turns_for_success: z2.number().default(2)
+      }).optional()
+    }).optional();
+    CustomPatternSchema = z2.object({
+      pattern: z2.string(),
+      severity: z2.string(),
+      message: z2.string()
+    });
+    GovernanceConfigSchema = z2.object({
+      audit: z2.object({
+        formats: z2.array(z2.string()).default(["summary", "detailed", "soc2"]),
+        retention_days: z2.number().default(365),
+        auto_log: z2.record(z2.string(), z2.boolean()).default({
+          code_changes: true,
+          rule_enforcement: true,
+          approvals: true,
+          commits: true
+        })
+      }).optional(),
+      validation: z2.object({
+        realtime: z2.boolean().default(true),
+        checks: z2.record(z2.string(), z2.boolean()).default({
+          rule_compliance: true,
+          import_existence: true,
+          naming_conventions: true
+        }),
+        custom_patterns: z2.array(CustomPatternSchema).default([])
+      }).optional(),
+      adr: z2.object({
+        detection_phrases: z2.array(z2.string()).default(["chose", "decided", "switching to", "moving from", "going with"]),
+        template: z2.string().default("default"),
+        storage: z2.string().default("database"),
+        output_dir: z2.string().default("docs/adr")
+      }).optional()
+    }).optional();
+    SecurityPatternSchema = z2.object({
+      pattern: z2.string(),
+      severity: z2.string(),
+      category: z2.string(),
+      description: z2.string()
+    });
+    SecurityConfigSchema = z2.object({
+      patterns: z2.array(SecurityPatternSchema).default([]),
+      auto_score_on_edit: z2.boolean().default(true),
+      score_threshold_alert: z2.number().default(50),
+      severity_weights: z2.record(z2.string(), z2.number()).optional(),
+      restrictive_licenses: z2.array(z2.string()).optional(),
+      dep_alternatives: z2.record(z2.string(), z2.array(z2.string())).optional(),
+      dependencies: z2.object({
+        package_manager: z2.string().default("npm"),
+        blocked_packages: z2.array(z2.string()).default([]),
+        preferred_packages: z2.record(z2.string(), z2.string()).default({}),
+        max_bundle_size_kb: z2.number().default(500)
+      }).optional()
+    }).optional();
+    TeamConfigSchema = z2.object({
+      enabled: z2.boolean().default(false),
+      sync_backend: z2.string().default("local"),
+      developer_id: z2.string().default("auto"),
+      share_by_default: z2.boolean().default(false),
+      expertise_weights: z2.object({
+        session: z2.number().default(20),
+        observation: z2.number().default(10)
+      }).optional(),
+      privacy: z2.object({
+        share_file_paths: z2.boolean().default(true),
+        share_code_snippets: z2.boolean().default(false),
+        share_observations: z2.boolean().default(true)
+      }).optional()
+    }).optional();
+    RegressionConfigSchema = z2.object({
+      test_patterns: z2.array(z2.string()).default([
+        "{dir}/__tests__/{name}.test.{ext}",
+        "{dir}/{name}.spec.{ext}",
+        "tests/{path}.test.{ext}"
+      ]),
+      test_runner: z2.string().default("npm test"),
+      health_thresholds: z2.object({
+        healthy: z2.number().default(80),
+        warning: z2.number().default(50)
+      }).optional()
+    }).optional();
+    AutoLearningConfigSchema = z2.object({
+      enabled: z2.boolean().default(true),
+      incidentDir: z2.string().default("docs/incidents"),
+      memoryDir: z2.string().default("memory"),
+      memoryIndexFile: z2.string().default("MEMORY.md"),
+      enforcementHooksDir: z2.string().default("scripts/hooks"),
+      fixDetection: z2.object({
+        enabled: z2.boolean().default(true),
+        lookbackDays: z2.number().default(7),
+        signals: z2.array(z2.string()).default([
+          "removed_broken_code",
+          "added_error_handling",
+          "method_name_correction",
+          "auth_fix",
+          "nil_handling_fix",
+          "concurrency_fix",
+          "async_pattern_fix",
+          "added_missing_import"
+        ])
+      }).default({}),
+      failureClassification: z2.object({
+        enabled: z2.boolean().default(true),
+        thresholds: z2.object({
+          known: z2.number().default(5),
+          similar: z2.number().default(3)
+        }).default({}),
+        scoring: z2.object({
+          diffPatternWeight: z2.number().default(3),
+          filePatternWeight: z2.number().default(2),
+          promptKeywordWeight: z2.number().default(2)
+        }).default({})
+      }).default({}),
+      pipeline: z2.object({
+        requireIncidentReport: z2.boolean().default(true),
+        requirePreventionRule: z2.boolean().default(true),
+        requireEnforcement: z2.boolean().default(true)
+      }).default({}),
+      // plan-v0.2-interactive-rule-approval P-D-008 / P-D-009: project-configured
+      // custom destinations for the rule-candidate funnel. The classifier matches
+      // a candidate to one of these entries when none of the framework
+      // destinations (pattern-scanner / claude-md-cr / corrections-md) apply.
+      customDestinations: z2.array(z2.object({
+        name: z2.string(),
+        path: z2.string(),
+        triggerKeywords: z2.array(z2.string()).default([]),
+        template: z2.string()
+      })).default([])
+    }).optional();
+    CloudConfigSchema = z2.object({
+      enabled: z2.boolean().default(false),
+      apiKey: z2.string().optional(),
+      endpoint: z2.string().optional(),
+      sync: z2.object({
+        memory: z2.boolean().default(true),
+        analytics: z2.boolean().default(true),
+        audit: z2.boolean().default(true)
+      }).default({ memory: true, analytics: true, audit: true })
+    }).optional();
+    ConventionsConfigSchema = z2.object({
+      claudeDirName: z2.string().default(".claude").refine(
+        (s) => !s.includes("..") && !s.startsWith("/"),
+        { message: 'claudeDirName must not contain ".." or start with "/"' }
+      ),
+      sessionStatePath: z2.string().default(".claude/session-state/CURRENT.md").refine(
+        (s) => !s.includes("..") && !s.startsWith("/"),
+        { message: 'sessionStatePath must not contain ".." or start with "/"' }
+      ),
+      sessionArchivePath: z2.string().default(".claude/session-state/archive").refine(
+        (s) => !s.includes("..") && !s.startsWith("/"),
+        { message: 'sessionArchivePath must not contain ".." or start with "/"' }
+      ),
+      knowledgeCategories: z2.array(z2.string()).default([
+        "patterns",
+        "commands",
+        "incidents",
+        "reference",
+        "protocols",
+        "checklists",
+        "playbooks",
+        "critical",
+        "scripts",
+        "status",
+        "templates",
+        "loop-state",
+        "session-state",
+        "agents"
+      ]),
+      knowledgeSourceFiles: z2.array(z2.string()).default(["CLAUDE.md", "MEMORY.md", "corrections.md"]),
+      excludePatterns: z2.array(z2.string()).default(["/ARCHIVE/", "/SESSION-HISTORY/"])
+    }).optional();
+    PythonDomainConfigSchema = z2.object({
+      name: z2.string(),
+      packages: z2.array(z2.string()),
+      allowed_imports_from: z2.array(z2.string()).default([])
+    });
+    PythonConfigSchema = z2.object({
+      root: z2.string(),
+      alembic_dir: z2.string().optional(),
+      domains: z2.array(PythonDomainConfigSchema).default([]),
+      exclude_dirs: z2.array(z2.string()).default(["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"])
+    }).optional();
+    PathsConfigSchema = z2.object({
+      source: z2.string().default("src"),
+      aliases: z2.record(z2.string(), z2.string()).default({ "@": "src" }),
+      monorepo_roots: z2.array(z2.string()).optional(),
+      routers: z2.string().optional(),
+      routerRoot: z2.string().optional(),
+      pages: z2.string().optional(),
+      middleware: z2.string().optional(),
+      schema: z2.string().optional(),
+      components: z2.string().optional(),
+      hooks: z2.string().optional()
+    });
+    LanguageFrameworkEntrySchema = z2.object({
+      framework: z2.string().optional(),
+      test_framework: z2.string().optional(),
+      test: z2.string().optional(),
+      runtime: z2.string().optional(),
+      orm: z2.string().optional(),
+      router: z2.string().optional(),
+      ui: z2.string().optional()
+    }).passthrough();
+    FrameworkConfigSchema = z2.object({
+      type: z2.string().default("typescript"),
+      primary: z2.string().optional(),
+      router: z2.string().default("none"),
+      orm: z2.string().default("none"),
+      ui: z2.string().default("none"),
+      languages: z2.record(z2.string(), LanguageFrameworkEntrySchema).optional()
+    }).passthrough();
+    DetectedConfigSchema = z2.object({}).passthrough().optional();
+    VerificationEntrySchema = z2.object({
+      type: z2.string().optional(),
+      test: z2.string().optional(),
+      syntax: z2.string().optional(),
+      lint: z2.string().optional(),
+      build: z2.string().optional()
+    }).passthrough();
+    VerificationConfigSchema = z2.record(z2.string(), VerificationEntrySchema).optional();
+    CanonicalPathsSchema = z2.record(z2.string(), z2.string()).optional();
+    VerificationTypesSchema = z2.record(z2.string(), z2.string()).optional();
+    DetectionRuleEntrySchema = z2.object({
+      signals: z2.array(z2.string()).default([]),
+      priority: z2.number().optional()
+    }).passthrough();
+    DetectionConfigSchema = z2.object({
+      rules: z2.record(
+        z2.string(),
+        // language
+        z2.record(z2.string(), DetectionRuleEntrySchema)
+        // framework -> rule entry
+      ).optional(),
+      signal_weights: z2.record(z2.string(), z2.number()).optional(),
+      disable_builtin: z2.boolean().optional()
+    }).passthrough().optional();
+    WatchConfigSchema = z2.object({
+      debounce_ms: z2.number().int().positive().default(3e3),
+      storm_threshold: z2.number().int().positive().default(50),
+      deep_storm_threshold: z2.number().int().positive().default(500),
+      hard_timeout_ms: z2.number().int().positive().default(3e5),
+      scope: z2.enum(["paths", "full"]).default("paths"),
+      // Plan 3a hotfix 2026-05-02: refuse to start if the watch surface
+      // exceeds this many files. Prevents the misconfig pattern where
+      // `paths.source_dirs` includes `.` or otherwise expands to a 60K+
+      // file tree, producing 30-100% steady CPU. Override via
+      // `paths_full_root_opt_in: true` for users on small repos who genuinely
+      // need root-level watching.
+      max_watched_files: z2.number().int().positive().default(1e4),
+      paths_full_root_opt_in: z2.boolean().default(false)
+    }).passthrough().optional();
+    AdapterLocalPathSchema = z2.string().refine((s) => !/^([A-Za-z]:[\\/]|[\\/])/.test(s), {
+      message: "absolute paths are rejected; adapters.local entries must be relative to the massu.config.yaml directory"
+    }).refine((s) => !s.split(/[\\/]/).includes(".."), {
+      message: "parent-directory traversal (`..`) is rejected; adapters.local entries must stay inside the project tree"
+    }).transform((s) => s.split(/[\\/]/).filter((part) => part !== "" && part !== ".").join("/"));
+    AdaptersConfigSchema = z2.object({
+      enabled: z2.boolean().default(false),
+      local: z2.array(AdapterLocalPathSchema).default([])
+    }).passthrough().optional();
+    TelemetryConfigSchema = z2.object({
+      adapters: z2.boolean().default(false)
+    }).passthrough().optional();
+    LSPConfigSchema = z2.object({
+      enabled: z2.boolean().default(false),
+      servers: z2.array(z2.object({
+        language: z2.string(),
+        command: z2.string(),
+        // F-014 (closed 2026-05-06): explicit opt-in to spawn SUID/SGID
+        // binaries. Default false — argv[0] with the SUID bit is rejected
+        // unless this is true. Decision is auditable in the YAML.
+        allow_setuid: z2.boolean().default(false),
+        // F-015 (closed 2026-05-06): per-server RSS budget (MB). Watchdog
+        // SIGKILLs the server after sustained breach. Default 1024 MB.
+        // Set to 0 to disable the watchdog for this server.
+        max_rss_mb: z2.number().int().nonnegative().default(1024)
+      })).default([]),
+      autoDetect: z2.object({
+        viaPortScan: z2.boolean().default(false)
+      }).optional()
+    }).passthrough();
+    RawConfigSchema = z2.object({
+      schema_version: z2.union([z2.literal(1), z2.literal(2)]).default(1),
+      project: z2.object({
+        name: z2.string().default("my-project"),
+        root: z2.string().default("auto")
+      }).default({ name: "my-project", root: "auto" }),
+      framework: FrameworkConfigSchema.default({
+        type: "typescript",
+        router: "none",
+        orm: "none",
+        ui: "none"
+      }),
+      paths: PathsConfigSchema.default({ source: "src", aliases: { "@": "src" } }),
+      toolPrefix: z2.string().default("massu"),
+      dbAccessPattern: z2.string().optional(),
+      knownMismatches: z2.record(z2.string(), z2.record(z2.string(), z2.string())).optional(),
+      accessScopes: z2.array(z2.string()).optional(),
+      domains: z2.array(DomainConfigSchema).default([]),
+      rules: z2.array(PatternRuleConfigSchema).default([]),
+      // P-M-036 (plan-stage-d-medium-sweep): customer-authored CR-style
+      // governance rules. DISTINCT from `rules:` above (path-scoped lint hints
+      // used by pattern-scanner). At config-refresh time these entries are
+      // loaded into the `knowledge_rules` SQLite table with
+      // `source = 'customer-config'` so `massu_knowledge_rule` and the
+      // governance docs surface customer-defined rules alongside framework CRs.
+      governance_rules: z2.array(
+        z2.object({
+          id: z2.string().min(1, "governance_rules[].id is required"),
+          title: z2.string().min(1, "governance_rules[].title is required"),
+          description: z2.string().min(1, "governance_rules[].description is required"),
+          vr_type: z2.string().default("VR-CUSTOM"),
+          reference_path: z2.string().optional(),
+          severity: z2.enum(["critical", "high", "medium", "low", "info"]).default("medium")
+        }).passthrough()
+      ).default([]),
+      analytics: AnalyticsConfigSchema,
+      governance: GovernanceConfigSchema,
+      security: SecurityConfigSchema,
+      team: TeamConfigSchema,
+      regression: RegressionConfigSchema,
+      cloud: CloudConfigSchema,
+      // plan-living-memory-slice-1 P6-002: automatic-recall tunables.
+      memory: MemoryConfigSchema,
+      conventions: ConventionsConfigSchema,
+      autoLearning: AutoLearningConfigSchema,
+      python: PythonConfigSchema,
+      // P2-004 / P2-005 / P2-006 / P2-008: v2 extensions (all optional)
+      verification: VerificationConfigSchema,
+      canonical_paths: CanonicalPathsSchema,
+      verification_types: VerificationTypesSchema,
+      detection: DetectionConfigSchema,
+      // Plan #2: detector-owned per-language conventions (free-form passthrough)
+      detected: DetectedConfigSchema,
+      // Plan 3a: file-watcher daemon tunables
+      watch: WatchConfigSchema,
+      // Plan 3c: third-party adapter registry kill-switch + signing override + local-path opt-in.
+      adapters: AdaptersConfigSchema,
+      // Plan 3c: anonymous adapter-discovery telemetry opt-in (default off).
+      telemetry: TelemetryConfigSchema,
+      // Plan 3b Phase 4: optional LSP enrichment of AST adapter results.
+      lsp: LSPConfigSchema.optional()
+    }).passthrough();
+    _config = null;
+    _resolvedApiKeySource = "none";
+    _projectRoot = null;
+  }
+});
+
+// src/memory-vector.ts
+function float32ToBlob(vec) {
+  return Buffer.from(new Uint8Array(vec.buffer, vec.byteOffset, vec.byteLength));
+}
+function l2normalize(vec) {
+  let sumSq = 0;
+  for (let i = 0; i < vec.length; i++) sumSq += vec[i] * vec[i];
+  const norm = Math.sqrt(sumSq);
+  if (norm === 0 || !Number.isFinite(norm)) return vec;
+  const out = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) out[i] = vec[i] / norm;
+  return out;
+}
+var init_memory_vector = __esm({
+  "src/memory-vector.ts"() {
+    "use strict";
+  }
+});
+
+// src/db-backup.ts
+import Database from "better-sqlite3";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, statSync, unlinkSync, copyFileSync, rmSync as rmSync2 } from "fs";
+import { resolve as resolve3, join, basename, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
+function dbBackupsRoot(home = homedir3()) {
+  return resolve3(home, ".massu", "db-backups");
+}
+function projectBackupDir(projectRoot, home = homedir3()) {
+  const slug = basename(projectRoot).replace(/[^A-Za-z0-9._-]/g, "_") || "project";
+  return join(dbBackupsRoot(home), slug);
+}
+function backupStamp(nowMs) {
+  return new Date(nowMs).toISOString().replace(/[:.]/g, "-");
+}
+function listDbBackups(projectRoot, home = homedir3()) {
+  const dir = projectBackupDir(projectRoot, home);
+  if (!existsSync3(dir)) return [];
+  const out = [];
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".db")) continue;
+    const p = join(dir, f);
+    const st = statSync(p);
+    const db = f.replace(/-\d{4}-\d{2}-\d{2}T.*$/, "");
+    out.push({ db, path: p, bytes: st.size, mtimeMs: st.mtimeMs });
+  }
+  return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function hasFreshDbBackup(projectRoot, dbPath, nowMs = Date.now(), home = homedir3()) {
+  const name = basename(dbPath, ".db");
+  const backups = listDbBackups(projectRoot, home).filter((b) => b.db === name);
+  if (backups.length === 0) return false;
+  const newest = backups[0];
+  if (nowMs - newest.mtimeMs > FRESH_WINDOW_MS) return false;
+  if (existsSync3(dbPath) && statSync(dbPath).mtimeMs > newest.mtimeMs) return false;
+  return true;
+}
+function integrityOk(dbPath) {
+  let db = null;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const rows = db.pragma("integrity_check");
+    return rows.length === 1 && rows[0].integrity_check === "ok";
+  } catch {
+    return false;
+  } finally {
+    try {
+      db?.close();
+    } catch {
+    }
+  }
+}
+function backupDb(projectRoot, dbPath, nowMs = Date.now(), home = homedir3()) {
+  if (!existsSync3(dbPath)) {
+    throw new DbBackupError(`cannot back up a database that does not exist: ${dbPath}`);
+  }
+  const dir = projectBackupDir(projectRoot, home);
+  mkdirSync2(dir, { recursive: true });
+  const name = basename(dbPath, ".db");
+  const dest = join(dir, `${name}-${backupStamp(nowMs)}.db`);
+  let src = null;
+  try {
+    src = new Database(dbPath, { readonly: true });
+    src.exec(`VACUUM INTO '${dest.replace(/'/g, "''")}'`);
+  } catch (err) {
+    throw new DbBackupError(
+      `VACUUM INTO failed for ${dbPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  } finally {
+    try {
+      src?.close();
+    } catch {
+    }
+  }
+  if (!integrityOk(dest)) {
+    try {
+      unlinkSync(dest);
+    } catch {
+    }
+    throw new DbBackupError(
+      `the backup of ${dbPath} FAILED its own integrity check and was deleted. A corrupt backup is worse than none \u2014 you only discover it when you need it.`
+    );
+  }
+  pruneDbBackups(projectRoot, name, DEFAULT_RETENTION, home);
+  const st = statSync(dest);
+  return { db: name, path: dest, bytes: st.size, mtimeMs: st.mtimeMs };
+}
+function pruneDbBackups(projectRoot, dbName, keep = DEFAULT_RETENTION, home = homedir3()) {
+  const mine = listDbBackups(projectRoot, home).filter((b) => b.db === dbName);
+  let removed = 0;
+  for (const old of mine.slice(keep)) {
+    try {
+      unlinkSync(old.path);
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+function backupBeforeSchemaChange(projectRoot, dbPath, onError, nowMs = Date.now(), home = homedir3()) {
+  try {
+    if (!existsSync3(dbPath)) return null;
+    if (hasFreshDbBackup(projectRoot, dbPath, nowMs, home)) return null;
+    return backupDb(projectRoot, dbPath, nowMs, home);
+  } catch (err) {
+    onError(err);
+    return null;
+  }
+}
+var DEFAULT_RETENTION, FRESH_WINDOW_MS, DbBackupError;
+var init_db_backup = __esm({
+  "src/db-backup.ts"() {
+    "use strict";
+    DEFAULT_RETENTION = 5;
+    FRESH_WINDOW_MS = 24 * 60 * 60 * 1e3;
+    DbBackupError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DbBackupError";
+      }
+    };
+  }
+});
+
+// src/hooks/lib/hook-failure-signal.ts
+import { appendFileSync, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
+import { join as join2, dirname as dirname3 } from "path";
+function resolveFailureLogPath() {
+  const explicit = process.env.MASSU_HOOK_FAILURE_LOG;
+  if (explicit) return explicit;
+  let dir = process.cwd();
+  for (let i = 0; i < 12; i++) {
+    if (existsSync4(join2(dir, ".massu")) || existsSync4(join2(dir, "massu.config.yaml"))) {
+      return join2(dir, ".massu", "hook-failures.jsonl");
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join2(process.cwd(), ".massu", "hook-failures.jsonl");
+}
+function recordHookFailure(hook, error, context) {
+  const record = {
+    hook,
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack?.split("\n").slice(0, 6).join("\n") : void 0,
+    context,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let wroteSomething = false;
+  try {
+    const path = resolveFailureLogPath();
+    mkdirSync3(dirname3(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(record) + "\n", "utf-8");
+    wroteSomething = true;
+  } catch {
+  }
+  try {
+    process.stderr.write(
+      `[massu] HOOK FAILURE in ${hook}: ${record.error}
+[massu]   This is a bug in Massu, not in your code. See .massu/hook-failures.jsonl
+`
+    );
+    wroteSomething = true;
+  } catch {
+  }
+  try {
+    recordHookHealthRow(record);
+  } catch {
+  }
+  return wroteSomething;
+}
+function recordHookHealthRow(record) {
+  const { getMemoryDb: getMemoryDb2 } = (init_memory_db(), __toCommonJS(memory_db_exports));
+  const db = getMemoryDb2();
+  try {
+    db.prepare(
+      `INSERT INTO hook_health (hook, error, context_json, occurred_at)
+       VALUES (?, ?, ?, ?)`
+    ).run(
+      record.hook,
+      record.error,
+      record.context ? JSON.stringify(record.context) : null,
+      record.timestamp
+    );
+  } finally {
+    db.close();
+  }
+}
+var init_hook_failure_signal = __esm({
+  "src/hooks/lib/hook-failure-signal.ts"() {
+    "use strict";
+  }
+});
+
+// src/memory-embedder-tokenizer.ts
+import { readFileSync as readFileSync3 } from "fs";
+function loadVocab(vocabPath) {
+  const lines = readFileSync3(vocabPath, "utf-8").split("\n");
+  const vocab = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const tok = lines[i].replace(/\r$/, "");
+    if (tok.length === 0 && i === lines.length - 1) continue;
+    vocab.set(tok, i);
+  }
+  return vocab;
+}
+function isWhitespace(ch) {
+  if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") return true;
+  const cp = ch.codePointAt(0);
+  return cp === 160 || cp >= 8192 && cp <= 8202 || cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287 || cp === 12288 || cp === 65279;
+}
+function isControl(ch) {
+  if (ch === "	" || ch === "\n" || ch === "\r") return false;
+  const cp = ch.codePointAt(0);
+  return cp <= 31 || cp >= 127 && cp <= 159;
+}
+function isPunctuation(ch) {
+  const cp = ch.codePointAt(0);
+  if (cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126)
+    return true;
+  return /\p{P}|\p{S}/u.test(ch);
+}
+function isCJK(cp) {
+  return cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+}
+function stripAccents(text) {
+  return text.normalize("NFD").replace(/\p{Mn}/gu, "");
+}
+function basicTokenize(text) {
+  let cleaned = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    if (cp === 0 || cp === 65533 || isControl(ch)) continue;
+    if (isWhitespace(ch)) {
+      cleaned += " ";
+      continue;
+    }
+    if (isCJK(cp)) {
+      cleaned += " " + ch + " ";
+      continue;
+    }
+    cleaned += ch;
+  }
+  const rawTokens = cleaned.split(/\s+/).filter(Boolean);
+  const out = [];
+  for (let tok of rawTokens) {
+    tok = stripAccents(tok.toLowerCase());
+    let cur = "";
+    for (const ch of tok) {
+      if (isPunctuation(ch)) {
+        if (cur) {
+          out.push(cur);
+          cur = "";
+        }
+        out.push(ch);
+      } else {
+        cur += ch;
+      }
+    }
+    if (cur) out.push(cur);
+  }
+  return out;
+}
+function wordpieceTokenize(token, vocab, maxChars = 100) {
+  if (token.length > maxChars) return [UNK];
+  const chars = Array.from(token);
+  const subTokens = [];
+  let start = 0;
+  let bad = false;
+  while (start < chars.length) {
+    let end = chars.length;
+    let curSub = null;
+    while (start < end) {
+      let substr = chars.slice(start, end).join("");
+      if (start > 0) substr = "##" + substr;
+      if (vocab.has(substr)) {
+        curSub = substr;
+        break;
+      }
+      end -= 1;
+    }
+    if (curSub === null) {
+      bad = true;
+      break;
+    }
+    subTokens.push(curSub);
+    start = end;
+  }
+  return bad ? [UNK] : subTokens;
+}
+function encode(text, vocab, opts = {}) {
+  const maxLen = opts.maxLen ?? 256;
+  const basic = basicTokenize(text);
+  const wpTokens = [];
+  for (const t2 of basic) {
+    for (const sub of wordpieceTokenize(t2, vocab)) wpTokens.push(sub);
+  }
+  const truncated = wpTokens.slice(0, maxLen - 2);
+  const tokens = [CLS, ...truncated, SEP];
+  const unkId = vocab.get(UNK) ?? 100;
+  const input_ids = tokens.map((t2) => vocab.get(t2) ?? unkId);
+  const attention_mask = tokens.map(() => 1);
+  const token_type_ids = tokens.map(() => 0);
+  return { tokens, input_ids, attention_mask, token_type_ids };
+}
+var UNK, CLS, SEP;
+var init_memory_embedder_tokenizer = __esm({
+  "src/memory-embedder-tokenizer.ts"() {
+    "use strict";
+    UNK = "[UNK]";
+    CLS = "[CLS]";
+    SEP = "[SEP]";
+  }
+});
+
+// src/memory-embedder.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname4, join as join3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { createRequire } from "module";
+function getActiveEmbedModel() {
+  return _activeModel;
+}
+function loadEmbedSettings() {
+  try {
+    const r = getConfig().memory?.recall;
+    return {
+      enabled: r?.embedEnabled ?? true,
+      endpoint: r?.embedEndpoint,
+      model: r?.embedModel
+    };
+  } catch {
+    return { enabled: true };
+  }
+}
+function embeddingsDisabled() {
+  return process.env.MASSU_DISABLE_EMBEDDINGS === "1";
+}
+function resolveModelDir() {
+  try {
+    let dir = dirname4(fileURLToPath(import.meta.url));
+    let root = null;
+    for (let i = 0; i < 8; i++) {
+      if (existsSync5(join3(dir, "package.json"))) {
+        root = dir;
+        break;
+      }
+      const parent = dirname4(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    if (!root) return null;
+    for (const rel of ["dist/embedder", "assets/embedder"]) {
+      const candidate = join3(root, rel);
+      if (existsSync5(join3(candidate, "model_quantized.onnx"))) return candidate;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveWasmDir() {
+  try {
+    const req = createRequire(import.meta.url);
+    const main2 = req.resolve(ORT_PKG);
+    return dirname4(main2);
+  } catch {
+    return null;
+  }
+}
+async function getSession() {
+  if (_sessionPromise) return _sessionPromise;
+  _sessionPromise = (async () => {
+    try {
+      const modelDir = resolveModelDir();
+      const wasmDir = resolveWasmDir();
+      if (!modelDir || !wasmDir) return null;
+      const ort = await import(
+        /* @vite-ignore */
+        ORT_PKG
+      );
+      ort.env.wasm.numThreads = 1;
+      ort.env.wasm.proxy = false;
+      ort.env.wasm.wasmPaths = wasmDir.endsWith("/") ? wasmDir : wasmDir + "/";
+      _ortTensor = ort.Tensor;
+      const modelPath = join3(modelDir, "model_quantized.onnx");
+      const vocabPath = join3(modelDir, "vocab.txt");
+      _vocab = loadVocab(vocabPath);
+      const session = await ort.InferenceSession.create(modelPath, {
+        executionProviders: ["wasm"],
+        graphOptimizationLevel: "all"
+      });
+      return session;
+    } catch {
+      return null;
+    }
+  })();
+  return _sessionPromise;
+}
+function meanPool(hidden, mask, seqLen, hiddenSize) {
+  const out = new Float32Array(hiddenSize);
+  let maskSum = 0;
+  for (let t2 = 0; t2 < seqLen; t2++) {
+    const m = mask[t2];
+    if (m === 0) continue;
+    maskSum += m;
+    const base = t2 * hiddenSize;
+    for (let h = 0; h < hiddenSize; h++) out[h] += hidden[base + h] * m;
+  }
+  const denom = Math.max(maskSum, 1e-9);
+  for (let h = 0; h < hiddenSize; h++) out[h] /= denom;
+  return out;
+}
+function chunkForEmbedding(text) {
+  const t2 = text.trim();
+  if (!t2) return [];
+  if (t2.length <= CHUNK_TARGET_CHARS) return [t2];
+  const chunks = [];
+  let start = 0;
+  while (start < t2.length && chunks.length < MAX_CHUNKS_PER_RECORD) {
+    let end = Math.min(start + CHUNK_TARGET_CHARS, t2.length);
+    if (end < t2.length) {
+      const floor = start + Math.floor(CHUNK_TARGET_CHARS / 2);
+      const slice = t2.slice(start, end);
+      const para = slice.lastIndexOf("\n\n");
+      const sent = Math.max(slice.lastIndexOf(". "), slice.lastIndexOf(".\n"));
+      const space = slice.lastIndexOf(" ");
+      for (const rel of [para, sent, space]) {
+        const abs = start + rel;
+        if (rel > 0 && abs > floor) {
+          end = abs + 1;
+          break;
+        }
+      }
+    }
+    const chunk = t2.slice(start, end).trim();
+    if (chunk) chunks.push(chunk);
+    if (end >= t2.length) break;
+    start = Math.max(end - CHUNK_OVERLAP_CHARS, start + 1);
+  }
+  return chunks;
+}
+async function embedTier1(text) {
+  try {
+    const session = await getSession();
+    if (!session || !_vocab || !_ortTensor) return null;
+    const { input_ids, attention_mask, token_type_ids } = encode(text, _vocab);
+    const seqLen = input_ids.length;
+    const ids = BigInt64Array.from(input_ids.map((x) => BigInt(x)));
+    const mask = BigInt64Array.from(attention_mask.map((x) => BigInt(x)));
+    const types = BigInt64Array.from(token_type_ids.map((x) => BigInt(x)));
+    const dims = [1, seqLen];
+    const Tensor = _ortTensor;
+    const feeds = {
+      input_ids: new Tensor("int64", ids, dims),
+      attention_mask: new Tensor("int64", mask, dims)
+    };
+    if (session.inputNames.includes("token_type_ids")) {
+      feeds.token_type_ids = new Tensor("int64", types, dims);
+    }
+    const results = await session.run(feeds);
+    const outName = session.outputNames.find((n) => results[n].dims.length === 3) ?? session.outputNames[0];
+    const outTensor = results[outName];
+    const hiddenSize = outTensor.dims[2];
+    const pooled = meanPool(outTensor.data, attention_mask, seqLen, hiddenSize);
+    const vec = l2normalize(pooled);
+    if (vec.length !== EMBED_DIM) return null;
+    _activeModel = { modelId: EMBED_MODEL_ID, dim: EMBED_DIM };
+    return vec;
+  } catch {
+    return null;
+  }
+}
+async function embedTier0(text, settings) {
+  const endpoint = settings.endpoint;
+  if (!endpoint) return null;
+  const requestModel = settings.model || EMBED_MODEL_ID;
+  const base = endpoint.replace(/\/+$/, "");
+  const url = `${base}/v1/embeddings`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIER0_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model: requestModel, input: text }),
+      signal: controller.signal
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    const raw = body?.data?.[0]?.embedding;
+    if (!Array.isArray(raw) || raw.length === 0) return null;
+    const vec = l2normalize(Float32Array.from(raw));
+    _activeModel = { modelId: requestModel, dim: vec.length };
+    return vec;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function embedBatch(texts) {
+  if (!texts || texts.length === 0) return [];
+  if (embeddingsDisabled()) return texts.map(() => null);
+  const settings = loadEmbedSettings();
+  if (!settings.enabled) return texts.map(() => null);
+  const results = [];
+  for (const t2 of texts) {
+    if (!t2 || !t2.trim()) {
+      results.push(null);
+      continue;
+    }
+    try {
+      let vec = null;
+      if (settings.endpoint) {
+        vec = await embedTier0(t2, settings);
+      }
+      if (!vec) vec = await embedTier1(t2);
+      results.push(vec);
+    } catch {
+      results.push(null);
+    }
+  }
+  return results;
+}
+var EMBED_MODEL_ID, EMBED_DIM, ORT_PKG, _activeModel, _sessionPromise, _vocab, _ortTensor, CHUNK_TARGET_CHARS, CHUNK_OVERLAP_CHARS, MAX_CHUNKS_PER_RECORD, TIER0_TIMEOUT_MS;
+var init_memory_embedder = __esm({
+  "src/memory-embedder.ts"() {
+    "use strict";
+    init_memory_vector();
+    init_memory_embedder_tokenizer();
+    init_config();
+    EMBED_MODEL_ID = "all-MiniLM-L6-v2";
+    EMBED_DIM = 384;
+    ORT_PKG = "onnxruntime-web";
+    _activeModel = null;
+    _sessionPromise = null;
+    _vocab = null;
+    _ortTensor = null;
+    CHUNK_TARGET_CHARS = 900;
+    CHUNK_OVERLAP_CHARS = 120;
+    MAX_CHUNKS_PER_RECORD = 24;
+    TIER0_TIMEOUT_MS = 2e3;
+  }
+});
+
+// src/memory-embed-sweep.ts
+function readCursor(db, metaTable, key) {
+  if (!KNOWN_META_TABLES.has(metaTable)) return 0;
+  try {
+    const row = db.prepare(`SELECT value FROM ${metaTable} WHERE key = ?`).get(key);
+    const n = row ? Number(row.value) : 0;
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+function writeCursor(db, metaTable, key, value) {
+  if (!KNOWN_META_TABLES.has(metaTable)) return;
+  try {
+    db.prepare(`INSERT OR REPLACE INTO ${metaTable} (key, value) VALUES (?, ?)`).run(
+      key,
+      String(value)
+    );
+  } catch {
+  }
+}
+async function runEmbedSweep(db, cfg, opts = {}) {
+  const batchSize = Math.max(1, opts.batchSize ?? 16);
+  const limit = opts.limit ?? Infinity;
+  const budgetMs = opts.budgetMs;
+  const start = Date.now();
+  const cursorKey = `embed_sweep_cursor_${cfg.sourceLabel}`;
+  let embedded = 0;
+  let scanned = 0;
+  let active = getActiveEmbedModel();
+  let cursor = readCursor(db, cfg.metaTable, cursorKey);
+  try {
+    while (true) {
+      if (embedded >= limit) break;
+      if (budgetMs !== void 0 && Date.now() - start >= budgetMs) break;
+      const remaining = limit === Infinity ? batchSize : Math.min(batchSize, limit - embedded);
+      const rows = cfg.selectMissing(db, cursor, active, Math.max(1, remaining));
+      if (rows.length === 0) {
+        writeCursor(db, cfg.metaTable, cursorKey, 0);
+        break;
+      }
+      const units = [];
+      for (const r of rows) {
+        if (cfg.chunked) {
+          const parts = chunkForEmbedding(r.text);
+          if (parts.length === 0) continue;
+          parts.forEach((text, chunkIx) => units.push({ id: r.id, chunkIx, text }));
+        } else {
+          units.push({ id: r.id, chunkIx: 0, text: r.text });
+        }
+      }
+      const vecs = await embedBatch(units.map((u) => u.text));
+      if (!active) active = getActiveEmbedModel();
+      if (!active) {
+        break;
+      }
+      const tx = db.transaction(() => {
+        const del = cfg.chunked ? db.prepare(
+          `DELETE FROM ${cfg.embeddingTable}
+                WHERE ${cfg.idCol} = ? AND model_id = ? AND dim = ?`
+        ) : null;
+        const stmt = cfg.chunked ? db.prepare(
+          `INSERT OR REPLACE INTO ${cfg.embeddingTable}
+                 (${cfg.idCol}, chunk_ix, model_id, dim, vec, created_at)
+               VALUES (?, ?, ?, ?, ?, datetime('now'))`
+        ) : db.prepare(
+          `INSERT OR REPLACE INTO ${cfg.embeddingTable}
+                 (${cfg.idCol}, model_id, dim, vec, created_at)
+               VALUES (?, ?, ?, ?, datetime('now'))`
+        );
+        const cleared = /* @__PURE__ */ new Set();
+        const embeddedIds = /* @__PURE__ */ new Set();
+        for (let i = 0; i < units.length; i++) {
+          const v = vecs[i];
+          if (!v) continue;
+          const u = units[i];
+          if (del && !cleared.has(u.id)) {
+            del.run(u.id, active.modelId, active.dim);
+            cleared.add(u.id);
+          }
+          if (cfg.chunked) {
+            stmt.run(u.id, u.chunkIx, active.modelId, active.dim, float32ToBlob(v));
+          } else {
+            stmt.run(u.id, active.modelId, active.dim, float32ToBlob(v));
+          }
+          embeddedIds.add(u.id);
+        }
+        embedded += embeddedIds.size;
+      });
+      tx();
+      scanned += rows.length;
+      cursor = rows[rows.length - 1].id;
+      writeCursor(db, cfg.metaTable, cursorKey, cursor);
+    }
+  } catch {
+  }
+  return { embedded, scanned };
+}
+var KNOWN_META_TABLES;
+var init_memory_embed_sweep = __esm({
+  "src/memory-embed-sweep.ts"() {
+    "use strict";
+    init_memory_embedder();
+    init_memory_vector();
+    KNOWN_META_TABLES = /* @__PURE__ */ new Set(["memory_meta", "knowledge_meta"]);
+  }
+});
 
 // src/memory-db.ts
+var memory_db_exports = {};
+__export(memory_db_exports, {
+  CONSOLIDATION_LESSON_EVIDENCE: () => CONSOLIDATION_LESSON_EVIDENCE,
+  MEMORY_FILE_TITLE_LIKE: () => MEMORY_FILE_TITLE_LIKE,
+  MEMORY_FILE_TITLE_PREFIX: () => MEMORY_FILE_TITLE_PREFIX,
+  MEMORY_SCHEMA_VERSION: () => MEMORY_SCHEMA_VERSION,
+  TOOL_COST_EVENTS_RETENTION_DAYS: () => TOOL_COST_EVENTS_RETENTION_DAYS,
+  USAGE_COUNTER_ARMED_KEY: () => USAGE_COUNTER_ARMED_KEY,
+  addConversationTurn: () => addConversationTurn,
+  addFailureClass: () => addFailureClass,
+  addObservation: () => addObservation,
+  addSummary: () => addSummary,
+  addToolCallDetail: () => addToolCallDetail,
+  addUserPrompt: () => addUserPrompt,
+  appendIncidentToFailureClass: () => appendIncidentToFailureClass,
+  armUsageCounter: () => armUsageCounter,
+  assignImportance: () => assignImportance,
+  autoDetectTaskId: () => autoDetectTaskId,
+  createSession: () => createSession,
+  deduplicateFailedAttempt: () => deduplicateFailedAttempt,
+  dequeuePendingSync: () => dequeuePendingSync,
+  drainRulePromotionEvents: () => drainRulePromotionEvents,
+  drainTeamPromotions: () => drainTeamPromotions,
+  drainTeamRevocations: () => drainTeamRevocations,
+  embedMissingObservations: () => embedMissingObservations,
+  endSession: () => endSession,
+  enqueueRulePromotionEvent: () => enqueueRulePromotionEvent,
+  enqueueSyncPayload: () => enqueueSyncPayload,
+  enqueueTeamPromotion: () => enqueueTeamPromotion,
+  enqueueTeamRevocation: () => enqueueTeamRevocation,
+  expireOldLowValueObservations: () => expireOldLowValueObservations,
+  getConversationTurns: () => getConversationTurns,
+  getCrossTaskProgress: () => getCrossTaskProgress,
+  getDecisionsAbout: () => getDecisionsAbout,
+  getFailedAttempts: () => getFailedAttempts,
+  getFailureClasses: () => getFailureClasses,
+  getLastProcessedLine: () => getLastProcessedLine,
+  getMemoryDb: () => getMemoryDb,
+  getMemoryMeta: () => getMemoryMeta,
+  getObservabilityDbSize: () => getObservabilityDbSize,
+  getRecentObservations: () => getRecentObservations,
+  getRecurrenceCountForPromptHash: () => getRecurrenceCountForPromptHash,
+  getSessionStats: () => getSessionStats,
+  getSessionSummaries: () => getSessionSummaries,
+  getSessionTimeline: () => getSessionTimeline,
+  getSessionsByTask: () => getSessionsByTask,
+  getToolPatterns: () => getToolPatterns,
+  incrementRetryCount: () => incrementRetryCount,
+  initMemorySchema: () => initMemorySchema,
+  linkSessionToTask: () => linkSessionToTask,
+  markRecordSuperseded: () => markRecordSuperseded,
+  memoryTableHasTemporal: () => memoryTableHasTemporal,
+  migrateAuditLogCheckExtension: () => migrateAuditLogCheckExtension,
+  migrateMemoryFilesFor4B: () => migrateMemoryFilesFor4B,
+  migrateObservationEmbeddingChunks: () => migrateObservationEmbeddingChunks,
+  pruneOldConversationTurns: () => pruneOldConversationTurns,
+  pruneOldObservations: () => pruneOldObservations,
+  pruneToolCostEvents: () => pruneToolCostEvents,
+  recordRecallHits: () => recordRecallHits,
+  recordTelemetry: () => recordTelemetry,
+  removePendingSync: () => removePendingSync,
+  sanitizeFts5Query: () => sanitizeFts5Query,
+  sanitizeFts5QueryOr: () => sanitizeFts5QueryOr,
+  scoreFailureClasses: () => scoreFailureClasses,
+  searchConversationTurns: () => searchConversationTurns,
+  searchObservations: () => searchObservations,
+  setLastProcessedLine: () => setLastProcessedLine,
+  setMemoryMeta: () => setMemoryMeta,
+  upsertObservationEmbedding: () => upsertObservationEmbedding,
+  usageWarmupElapsed: () => usageWarmupElapsed
+});
+import Database2 from "better-sqlite3";
+import { dirname as dirname5, basename as basename2 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+function sanitizeFts5Query(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return '""';
+  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter(Boolean);
+  return tokens.map((t2) => `"${t2}"`).join(" ");
+}
+function sanitizeFts5QueryOr(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return '""';
+  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter((t2) => t2.replace(/[^a-zA-Z0-9]/g, "").length >= 3);
+  if (tokens.length === 0) return '""';
+  return tokens.map((t2) => `"${t2}"`).join(" OR ");
+}
 function getMemoryDb() {
   const dbPath = getResolvedPaths().memoryDbPath;
-  const dir = dirname2(dbPath);
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname5(dbPath);
+  if (!existsSync6(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  const db = new Database(dbPath);
+  const preExisting = existsSync6(dbPath);
+  const db = new Database2(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
+  const onDisk = db.pragma("user_version", { simple: true });
+  if (preExisting && onDisk !== MEMORY_SCHEMA_VERSION) {
+    backupBeforeSchemaChange(
+      getProjectRoot(),
+      dbPath,
+      (err) => recordHookFailure("memory-db:pre-ddl-backup", err, { dbPath, onDisk })
+    );
+  }
   initMemorySchema(db);
+  if (onDisk !== MEMORY_SCHEMA_VERSION) {
+    db.pragma(`user_version = ${MEMORY_SCHEMA_VERSION}`);
+  }
   return db;
 }
+function pruneToolCostEvents(db) {
+  const result = db.prepare(
+    `DELETE FROM tool_cost_events WHERE created_at < datetime('now', '-' || ? || ' days')`
+  ).run(TOOL_COST_EVENTS_RETENTION_DAYS);
+  return result.changes;
+}
+function migrateObservationEmbeddingChunks(db) {
+  const cols = db.pragma("table_info(observation_embeddings)");
+  if (cols.length === 0) return;
+  if (cols.some((c) => c.name === "chunk_ix")) return;
+  db.pragma("foreign_keys = OFF");
+  try {
+    db.exec("BEGIN TRANSACTION");
+    db.exec(`
+      CREATE TABLE observation_embeddings_new (
+        observation_id INTEGER NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+        chunk_ix INTEGER NOT NULL DEFAULT 0,
+        model_id TEXT NOT NULL,
+        dim INTEGER NOT NULL,
+        vec BLOB NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (observation_id, model_id, dim, chunk_ix)
+      );
+      INSERT INTO observation_embeddings_new
+        (observation_id, chunk_ix, model_id, dim, vec, created_at)
+        SELECT observation_id, 0, model_id, dim, vec, created_at FROM observation_embeddings;
+      DROP TABLE observation_embeddings;
+      ALTER TABLE observation_embeddings_new RENAME TO observation_embeddings;
+      CREATE INDEX IF NOT EXISTS idx_obs_emb_model ON observation_embeddings(model_id);
+    `);
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  } finally {
+    db.pragma("foreign_keys = ON");
+  }
+}
+function migrateMemoryFilesFor4B(db) {
+  const ADDITIONS = [
+    // The renderer's authorship credential (OD-1). NULL on every pre-existing row,
+    // which is the safe direction: no MAC ⇒ unverifiable ⇒ the file is HUMAN.
+    { table: "memory_files", name: "massu_render_mac", decl: "TEXT" },
+    // F-15 stickiness: once a file is human, only `massu memory adopt` reverses it.
+    { table: "memory_files", name: "adopted_human_at_epoch", decl: "INTEGER" },
+    // OD-2: a CACHE of `.massu-tombstones.jsonl`. The ledger is the source of truth.
+    { table: "memory_files", name: "tombstoned_at_epoch", decl: "INTEGER" },
+    { table: "memory_files", name: "origin", decl: "TEXT NOT NULL DEFAULT 'local'" },
+    { table: "memory_files", name: "render_suppressed", decl: "INTEGER NOT NULL DEFAULT 0" },
+    // N-03 — the SOURCE row. This is the one F-08 actually requires.
+    { table: "observations", name: "origin", decl: "TEXT NOT NULL DEFAULT 'local'" }
+  ];
+  for (const add of ADDITIONS) {
+    const cols = db.prepare(`PRAGMA table_info(${add.table})`).all();
+    if (cols.length === 0) continue;
+    if (cols.some((c) => c.name === add.name)) continue;
+    db.exec(`ALTER TABLE ${add.table} ADD COLUMN ${add.name} ${add.decl}`);
+  }
+}
 function migrateAuditLogCheckExtension(db) {
   const row = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='audit_log'").get();
   if (!row) return;
@@ -659,7 +1670,17 @@ function migrateAuditLogCheckExtension(db) {
     "compaction",
     "rule_candidate_emitted",
     "rule_promoted",
-    "rule_dismissed"
+    "rule_dismissed",
+    // A-19/N-02 — without these the memory-file events throw a CHECK violation.
+    // In the ingest path the throw is swallowed by a bare catch, so observability
+    // silently produces NOTHING; in the renderer's transaction it ROLLS BACK a
+    // legitimate render. This migration is what lets an EXISTING db accept them.
+    "memory_file_ingested",
+    "memory_file_expired",
+    "memory_file_adopted_human",
+    "memory_file_rendered",
+    "memory_file_render_refused",
+    "memory_file_tombstoned"
   ];
   const checkClauseMatch = row.sql.match(/event_type\s+TEXT\s+NOT\s+NULL\s+CHECK\s*\(\s*event_type\s+IN\s*\(([\s\S]*?)\)\s*\)/i);
   if (checkClauseMatch) {
@@ -676,7 +1697,9 @@ function migrateAuditLogCheckExtension(db) {
         timestamp TEXT DEFAULT (datetime('now')),
         event_type TEXT NOT NULL CHECK(event_type IN (
           'code_change', 'rule_enforced', 'approval', 'review', 'commit', 'compaction',
-          'rule_candidate_emitted', 'rule_promoted', 'rule_dismissed'
+          'rule_candidate_emitted', 'rule_promoted', 'rule_dismissed',
+          'memory_file_ingested', 'memory_file_expired', 'memory_file_adopted_human',
+          'memory_file_rendered', 'memory_file_render_refused', 'memory_file_tombstoned'
         )),
         actor TEXT NOT NULL DEFAULT 'ai' CHECK(actor IN ('ai', 'human', 'hook', 'agent')),
         model_id TEXT,
@@ -748,6 +1771,11 @@ function initMemorySchema(db) {
       importance INTEGER NOT NULL DEFAULT 3 CHECK(importance BETWEEN 1 AND 5),
       recurrence_count INTEGER NOT NULL DEFAULT 1,
       original_tokens INTEGER DEFAULT 0,
+      -- B-10/F-08/N-03: the SOURCE-row provenance flag. The renderer refuses any
+      -- row whose origin is not 'local' BEFORE it computes a path, mints a
+      -- credential, or takes a snapshot. A Slice-5 synced memory arrives here with
+      -- origin='team' and must never reach disk without CR-55's gates.
+      origin TEXT NOT NULL DEFAULT 'local',
       created_at TEXT NOT NULL,
       created_at_epoch INTEGER NOT NULL,
       FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE CASCADE
@@ -846,6 +1874,27 @@ function initMemorySchema(db) {
       value TEXT NOT NULL
     );
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_usage (
+      source TEXT NOT NULL,
+      record_id INTEGER NOT NULL,
+      hit_count INTEGER NOT NULL DEFAULT 0,
+      hits_windowed REAL NOT NULL DEFAULT 0,
+      last_hit_epoch INTEGER,
+      last_reweight_epoch INTEGER,
+      PRIMARY KEY (source, record_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS memory_usage_sessions (
+      source TEXT NOT NULL,
+      record_id INTEGER NOT NULL,
+      session_id TEXT NOT NULL,
+      PRIMARY KEY (source, record_id, session_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memory_usage_hits
+      ON memory_usage(source, hits_windowed DESC);
+  `);
   db.exec(`
     CREATE TABLE IF NOT EXISTS conversation_turns (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -998,7 +2047,9 @@ function initMemorySchema(db) {
       timestamp TEXT DEFAULT (datetime('now')),
       event_type TEXT NOT NULL CHECK(event_type IN (
         'code_change', 'rule_enforced', 'approval', 'review', 'commit', 'compaction',
-        'rule_candidate_emitted', 'rule_promoted', 'rule_dismissed'
+        'rule_candidate_emitted', 'rule_promoted', 'rule_dismissed',
+        'memory_file_ingested', 'memory_file_expired', 'memory_file_adopted_human',
+        'memory_file_rendered', 'memory_file_render_refused', 'memory_file_tombstoned'
       )),
       actor TEXT NOT NULL DEFAULT 'ai' CHECK(actor IN ('ai', 'human', 'hook', 'agent')),
       model_id TEXT,
@@ -1018,6 +2069,17 @@ function initMemorySchema(db) {
       ON audit_log (event_type, json_extract(metadata, '$.prompt_hash'))
       WHERE event_type = 'rule_promoted';
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS hook_health (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      hook TEXT NOT NULL,
+      error TEXT NOT NULL,
+      context_json TEXT,
+      occurred_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_hook_health_hook ON hook_health(hook);
+    CREATE INDEX IF NOT EXISTS idx_hook_health_time ON hook_health(occurred_at DESC);
+  `);
   db.exec(`
     CREATE TABLE IF NOT EXISTS prompt_outcomes_signal_blacklist (
       signal TEXT PRIMARY KEY,
@@ -1029,6 +2091,30 @@ function initMemorySchema(db) {
       ON prompt_outcomes_signal_blacklist(dismissal_count DESC);
   `);
   migrateAuditLogCheckExtension(db);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_files (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      rel_path TEXT NOT NULL UNIQUE COLLATE NOCASE,
+      name TEXT,
+      raw TEXT NOT NULL,
+      frontmatter_json TEXT,
+      body TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      ingest_schema_version INTEGER NOT NULL DEFAULT 1,
+      massu_authored INTEGER NOT NULL DEFAULT 0,
+      massu_render_mac TEXT,
+      adopted_human_at_epoch INTEGER,
+      tombstoned_at_epoch INTEGER,
+      origin TEXT NOT NULL DEFAULT 'local',
+      render_suppressed INTEGER NOT NULL DEFAULT 0,
+      observation_id INTEGER,
+      synced_at_epoch INTEGER,
+      expired_at_epoch INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_mf_hash ON memory_files(content_hash);
+    CREATE INDEX IF NOT EXISTS idx_mf_expired ON memory_files(expired_at_epoch);
+    CREATE INDEX IF NOT EXISTS idx_mf_obs ON memory_files(observation_id);
+  `);
   db.exec(`
     CREATE TABLE IF NOT EXISTS validation_results (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1247,28 +2333,309 @@ function initMemorySchema(db) {
   if (!outboundCols.some((c) => c.name === "hardened")) {
     db.exec(`ALTER TABLE team_promotion_outbound ADD COLUMN hardened INTEGER NOT NULL DEFAULT 0`);
   }
-  if (!outboundCols.some((c) => c.name === "review_attestation_json")) {
-    db.exec(`ALTER TABLE team_promotion_outbound ADD COLUMN review_attestation_json TEXT`);
+  if (!outboundCols.some((c) => c.name === "review_attestation_json")) {
+    db.exec(`ALTER TABLE team_promotion_outbound ADD COLUMN review_attestation_json TEXT`);
+  }
+  const sessionCols = db.prepare(`PRAGMA table_info(sessions)`).all();
+  if (!sessionCols.some((c) => c.name === "consolidated_at")) {
+    db.exec(`ALTER TABLE sessions ADD COLUMN consolidated_at TEXT`);
+  }
+  if (!sessionCols.some((c) => c.name === "consolidated_at_epoch")) {
+    db.exec(`ALTER TABLE sessions ADD COLUMN consolidated_at_epoch INTEGER`);
+  }
+  if (!sessionCols.some((c) => c.name === "consolidated_status")) {
+    db.exec(`ALTER TABLE sessions ADD COLUMN consolidated_status TEXT`);
+  }
+  const BITEMPORAL_COLUMNS = [
+    { name: "valid_from", type: "TEXT" },
+    { name: "valid_to", type: "TEXT" },
+    { name: "ingested_at", type: "TEXT" },
+    { name: "expired_at", type: "TEXT" },
+    { name: "valid_from_epoch", type: "INTEGER" },
+    { name: "valid_to_epoch", type: "INTEGER" },
+    { name: "ingested_at_epoch", type: "INTEGER" },
+    { name: "expired_at_epoch", type: "INTEGER" },
+    { name: "superseded_by", type: "INTEGER" }
+  ];
+  for (const table of ["observations", "architecture_decisions"]) {
+    const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+    for (const col of BITEMPORAL_COLUMNS) {
+      if (!cols.some((c) => c.name === col.name)) {
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${col.name} ${col.type}`);
+      }
+    }
+  }
+  db.exec(`
+    UPDATE observations
+       SET valid_from = created_at,
+           ingested_at = created_at,
+           valid_from_epoch = created_at_epoch,
+           ingested_at_epoch = created_at_epoch
+     WHERE valid_from_epoch IS NULL;
+  `);
+  db.exec(`
+    UPDATE architecture_decisions
+       SET valid_from = created_at,
+           ingested_at = created_at,
+           valid_from_epoch = CAST(strftime('%s', created_at) AS INTEGER),
+           ingested_at_epoch = CAST(strftime('%s', created_at) AS INTEGER)
+     WHERE valid_from_epoch IS NULL AND created_at IS NOT NULL;
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_observations_expired ON observations(expired_at_epoch);
+    CREATE INDEX IF NOT EXISTS idx_ad_expired ON architecture_decisions(expired_at_epoch);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS failure_classes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT NOT NULL,
+      diff_patterns TEXT NOT NULL DEFAULT '[]',
+      file_patterns TEXT NOT NULL DEFAULT '[]',
+      prompt_keywords TEXT NOT NULL DEFAULT '[]',
+      incidents TEXT NOT NULL DEFAULT '[]',
+      rules TEXT NOT NULL DEFAULT '[]',
+      scanner_checks TEXT NOT NULL DEFAULT '[]',
+      known_message TEXT NOT NULL DEFAULT '',
+      needs_review INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_fc_name ON failure_classes(name);
+    CREATE INDEX IF NOT EXISTS idx_fc_needs_review ON failure_classes(needs_review);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS observation_embeddings (
+      observation_id INTEGER NOT NULL REFERENCES observations(id) ON DELETE CASCADE,
+      chunk_ix INTEGER NOT NULL DEFAULT 0,
+      model_id TEXT NOT NULL,
+      dim INTEGER NOT NULL,
+      vec BLOB NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (observation_id, model_id, dim, chunk_ix)
+    );
+    CREATE INDEX IF NOT EXISTS idx_obs_emb_model ON observation_embeddings(model_id);
+  `);
+  migrateObservationEmbeddingChunks(db);
+  migrateMemoryFilesFor4B(db);
+}
+function enqueueSyncPayload(db, payload) {
+  db.prepare("INSERT INTO pending_sync (payload) VALUES (?)").run(payload);
+}
+function getMemoryMeta(db, key) {
+  const row = db.prepare("SELECT value FROM memory_meta WHERE key = ?").get(key);
+  return row ? row.value : null;
+}
+function setMemoryMeta(db, key, value) {
+  db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES (?, ?)").run(key, value);
+}
+function upsertObservationEmbedding(db, observationId, vec, modelId, dim) {
+  db.prepare(
+    `INSERT OR REPLACE INTO observation_embeddings (observation_id, model_id, dim, vec, created_at)
+     VALUES (?, ?, ?, ?, datetime('now'))`
+  ).run(observationId, modelId, dim, float32ToBlob(vec));
+}
+function observationEmbedText(title, detail) {
+  const t2 = (title ?? "").trim();
+  const d = (detail ?? "").trim();
+  return d ? `${t2}. ${d}` : t2;
+}
+async function embedMissingObservations(db, opts = {}) {
+  return runEmbedSweep(
+    db,
+    {
+      embeddingTable: "observation_embeddings",
+      idCol: "observation_id",
+      metaTable: "memory_meta",
+      sourceLabel: "observation",
+      // A-04: memory bodies are now stored WHOLE (up to ~14K chars). One vector per
+      // memory would cover only its first ~1,000 chars.
+      chunked: true,
+      selectMissing: (d, cursor, model, batchSize) => {
+        const rows = model ? d.prepare(
+          `SELECT o.id AS id, o.title AS title, o.detail AS detail
+                 FROM observations o
+                 WHERE o.id > ?
+                   AND NOT EXISTS (
+                     SELECT 1 FROM observation_embeddings e
+                     WHERE e.observation_id = o.id AND e.model_id = ? AND e.dim = ?
+                   )
+                 ORDER BY o.id LIMIT ?`
+        ).all(cursor, model.modelId, model.dim, batchSize) : d.prepare(
+          `SELECT o.id AS id, o.title AS title, o.detail AS detail
+                 FROM observations o
+                 WHERE o.id > ?
+                   AND NOT EXISTS (
+                     SELECT 1 FROM observation_embeddings e WHERE e.observation_id = o.id
+                   )
+                 ORDER BY o.id LIMIT ?`
+        ).all(cursor, batchSize);
+        return rows.map((r) => ({ id: r.id, text: observationEmbedText(r.title, r.detail) }));
+      }
+    },
+    opts
+  );
+}
+function enqueueTeamPromotion(db, promo) {
+  db.prepare(`
+    INSERT OR REPLACE INTO team_promotion_outbound
+      (prompt_hash, destination, draft_text, score, signals_json, content_hash, hardened, review_attestation_json, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+  `).run(
+    promo.prompt_hash,
+    promo.destination,
+    promo.draft_text.slice(0, MAX_DRAFT_TEXT_LEN),
+    promo.score ?? null,
+    JSON.stringify(promo.signals ?? []),
+    promo.content_hash,
+    promo.hardened ? 1 : 0,
+    promo.review_attestation !== void 0 ? JSON.stringify(promo.review_attestation) : null
+  );
+}
+function drainTeamPromotions(db) {
+  const rows = db.prepare(`
+    SELECT prompt_hash, destination, draft_text, score, signals_json, content_hash, hardened, review_attestation_json
+    FROM team_promotion_outbound ORDER BY created_at ASC LIMIT 1000
+  `).all();
+  if (rows.length === 0) return [];
+  db.prepare("DELETE FROM team_promotion_outbound").run();
+  return rows.map((r) => ({
+    prompt_hash: r.prompt_hash,
+    destination: r.destination,
+    draft_text: r.draft_text,
+    score: r.score ?? void 0,
+    signals: safeJsonArray(r.signals_json),
+    content_hash: r.content_hash,
+    hardened: r.hardened === 1,
+    review_attestation: r.review_attestation_json ? safeJsonParse(r.review_attestation_json) : void 0
+  }));
+}
+function enqueueTeamRevocation(db, promptHash) {
+  db.prepare(`
+    INSERT OR REPLACE INTO team_revocation_outbound (prompt_hash, created_at)
+    VALUES (?, datetime('now'))
+  `).run(promptHash);
+}
+function drainTeamRevocations(db) {
+  const rows = db.prepare(
+    `SELECT prompt_hash FROM team_revocation_outbound ORDER BY created_at ASC LIMIT 1000`
+  ).all();
+  if (rows.length === 0) return [];
+  db.prepare("DELETE FROM team_revocation_outbound").run();
+  return rows.map((r) => r.prompt_hash);
+}
+function getRecurrenceCountForPromptHash(db, promptHash) {
+  try {
+    const row = db.prepare(`
+      SELECT json_extract(metadata, '$.recurrence_count') AS rc
+      FROM audit_log
+      WHERE event_type = 'rule_promoted'
+        AND json_extract(metadata, '$.prompt_hash') = ?
+      LIMIT 1
+    `).get(promptHash);
+    if (!row || row.rc === null || row.rc === void 0) return null;
+    return Number(row.rc);
+  } catch {
+    return null;
+  }
+}
+function enqueueRulePromotionEvent(db, ev) {
+  try {
+    db.prepare(`
+      INSERT INTO rule_promotion_events_outbound
+        (prompt_hash, event_type, metadata_json, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(
+      ev.prompt_hash,
+      ev.event_type,
+      JSON.stringify(ev.metadata ?? {}),
+      ev.created_at
+    );
+    db.prepare(`
+      DELETE FROM rule_promotion_events_outbound
+      WHERE id NOT IN (
+        SELECT id FROM rule_promotion_events_outbound ORDER BY id DESC LIMIT ?
+      )
+    `).run(FUNNEL_EVENT_OUTBOX_CAP);
+  } catch {
+  }
+}
+function drainRulePromotionEvents(db) {
+  const rows = db.prepare(`
+    SELECT id, prompt_hash, event_type, metadata_json, created_at
+    FROM rule_promotion_events_outbound ORDER BY id ASC LIMIT ?
+  `).all(FUNNEL_EVENT_DRAIN_LIMIT);
+  if (rows.length === 0) return [];
+  const maxId = rows[rows.length - 1].id;
+  db.prepare("DELETE FROM rule_promotion_events_outbound WHERE id <= ?").run(maxId);
+  return rows.map((r) => ({
+    prompt_hash: r.prompt_hash,
+    event_type: r.event_type,
+    created_at: r.created_at,
+    metadata: safeJsonParse(r.metadata_json) ?? {}
+  }));
+}
+function recordTelemetry(db, eventType, data) {
+  try {
+    db.prepare(`
+      INSERT INTO analytics_events (event_type, event_data, created_at)
+      VALUES (?, ?, datetime('now'))
+    `).run(eventType, JSON.stringify(data));
+  } catch {
+  }
+}
+function safeJsonArray(json) {
+  try {
+    const v = JSON.parse(json);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+function safeJsonParse(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
   }
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS failure_classes (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      name TEXT NOT NULL UNIQUE,
-      description TEXT NOT NULL,
-      diff_patterns TEXT NOT NULL DEFAULT '[]',
-      file_patterns TEXT NOT NULL DEFAULT '[]',
-      prompt_keywords TEXT NOT NULL DEFAULT '[]',
-      incidents TEXT NOT NULL DEFAULT '[]',
-      rules TEXT NOT NULL DEFAULT '[]',
-      scanner_checks TEXT NOT NULL DEFAULT '[]',
-      known_message TEXT NOT NULL DEFAULT '',
-      needs_review INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now')),
-      updated_at TEXT DEFAULT (datetime('now'))
+}
+function dequeuePendingSync(db, limit = 10) {
+  const stale = db.prepare(
+    "SELECT id, retry_count, last_error FROM pending_sync WHERE retry_count >= 10 LIMIT 10000"
+  ).all();
+  if (stale.length > 0) {
+    const ids = stale.map((s) => s.id);
+    db.prepare(`DELETE FROM pending_sync WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
+    const lastErrors = [...new Set(stale.map((s) => s.last_error).filter(Boolean))];
+    process.stderr.write(
+      `[massu] WARNING: ${stale.length} cloud-sync queue item(s) discarded after 10+ retries. Likely cause: invalid API key or unreachable endpoint. Recent errors: ${lastErrors.slice(0, 3).join("; ") || "(none recorded)"}
+`
     );
-    CREATE INDEX IF NOT EXISTS idx_fc_name ON failure_classes(name);
-    CREATE INDEX IF NOT EXISTS idx_fc_needs_review ON failure_classes(needs_review);
-  `);
+    try {
+      db.prepare(`
+        INSERT INTO analytics_events (event_type, event_data, created_at)
+        VALUES (?, ?, datetime('now'))
+      `).run(
+        "cloud_sync_giveup",
+        JSON.stringify({
+          discarded_count: stale.length,
+          recent_errors: lastErrors.slice(0, 3)
+        })
+      );
+    } catch {
+    }
+  }
+  return db.prepare(
+    "SELECT id, payload, retry_count FROM pending_sync ORDER BY created_at ASC LIMIT ?"
+  ).all(limit);
+}
+function removePendingSync(db, id) {
+  db.prepare("DELETE FROM pending_sync WHERE id = ?").run(id);
+}
+function incrementRetryCount(db, id, error) {
+  db.prepare(
+    "UPDATE pending_sync SET retry_count = retry_count + 1, last_error = ? WHERE id = ?"
+  ).run(error, id);
 }
 function assignImportance(type, vrResult) {
   switch (type) {
@@ -1296,7 +2663,7 @@ function assignImportance(type, vrResult) {
 }
 function autoDetectTaskId(planFile) {
   if (!planFile) return null;
-  const base = basename(planFile);
+  const base = basename2(planFile);
   return base.replace(/\.md$/, "");
 }
 function createSession(db, sessionId, opts) {
@@ -1307,29 +2674,91 @@ function createSession(db, sessionId, opts) {
     VALUES (?, ?, ?, ?, ?, ?)
   `).run(sessionId, opts?.branch ?? null, opts?.planFile ?? null, taskId, now.toISOString(), Math.floor(now.getTime() / 1e3));
 }
+function endSession(db, sessionId, status = "completed") {
+  const now = /* @__PURE__ */ new Date();
+  db.prepare(`
+    UPDATE sessions SET status = ?, ended_at = ?, ended_at_epoch = ? WHERE session_id = ?
+  `).run(status, now.toISOString(), Math.floor(now.getTime() / 1e3), sessionId);
+}
+function memoryTableHasTemporal(db, table) {
+  let perDb = _temporalColCache.get(db);
+  if (!perDb) {
+    perDb = /* @__PURE__ */ new Map();
+    _temporalColCache.set(db, perDb);
+  }
+  let has = perDb.get(table);
+  if (has === void 0) {
+    try {
+      const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+      has = cols.some((c) => c.name === "valid_from_epoch");
+    } catch {
+      has = false;
+    }
+    perDb.set(table, has);
+  }
+  return has;
+}
 function addObservation(db, sessionId, type, title, detail, opts) {
   const now = /* @__PURE__ */ new Date();
   const importance = opts?.importance ?? assignImportance(type, opts?.evidence?.includes("PASS") ? "PASS" : void 0);
-  const result = db.prepare(`
-    INSERT INTO observations (session_id, type, title, detail, files_involved, plan_item, cr_rule, vr_type, evidence, importance, original_tokens, created_at, created_at_epoch)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    sessionId,
-    type,
-    title,
-    detail,
-    JSON.stringify(opts?.filesInvolved ?? []),
-    opts?.planItem ?? null,
-    opts?.crRule ?? null,
-    opts?.vrType ?? null,
-    opts?.evidence ?? null,
-    importance,
-    opts?.originalTokens ?? 0,
-    now.toISOString(),
-    Math.floor(now.getTime() / 1e3)
-  );
+  const iso = now.toISOString();
+  const epochSec = Math.floor(now.getTime() / 1e3);
+  let result;
+  if (memoryTableHasTemporal(db, "observations")) {
+    result = db.prepare(`
+      INSERT INTO observations (session_id, type, title, detail, files_involved, plan_item, cr_rule, vr_type, evidence, importance, original_tokens, created_at, created_at_epoch, valid_from, ingested_at, valid_from_epoch, ingested_at_epoch)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      sessionId,
+      type,
+      title,
+      detail,
+      JSON.stringify(opts?.filesInvolved ?? []),
+      opts?.planItem ?? null,
+      opts?.crRule ?? null,
+      opts?.vrType ?? null,
+      opts?.evidence ?? null,
+      importance,
+      opts?.originalTokens ?? 0,
+      iso,
+      epochSec,
+      iso,
+      iso,
+      epochSec,
+      epochSec
+    );
+  } else {
+    result = db.prepare(`
+      INSERT INTO observations (session_id, type, title, detail, files_involved, plan_item, cr_rule, vr_type, evidence, importance, original_tokens, created_at, created_at_epoch)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      sessionId,
+      type,
+      title,
+      detail,
+      JSON.stringify(opts?.filesInvolved ?? []),
+      opts?.planItem ?? null,
+      opts?.crRule ?? null,
+      opts?.vrType ?? null,
+      opts?.evidence ?? null,
+      importance,
+      opts?.originalTokens ?? 0,
+      iso,
+      epochSec
+    );
+  }
   return Number(result.lastInsertRowid);
 }
+function markRecordSuperseded(db, table, recordId, successorId, nowEpochSec = Math.floor(Date.now() / 1e3)) {
+  const iso = new Date(nowEpochSec * 1e3).toISOString();
+  const statusClause = table === "architecture_decisions" ? `, status = 'superseded'` : "";
+  const res = db.prepare(
+    `UPDATE ${table}
+          SET valid_to = ?, expired_at = ?, valid_to_epoch = ?, expired_at_epoch = ?, superseded_by = ?${statusClause}
+        WHERE id = ? AND expired_at IS NULL AND id != ?`
+  ).run(iso, iso, nowEpochSec, nowEpochSec, successorId, recordId, successorId);
+  return res.changes > 0;
+}
 function addSummary(db, sessionId, summary) {
   const now = /* @__PURE__ */ new Date();
   db.prepare(`
@@ -1351,6 +2780,194 @@ function addSummary(db, sessionId, summary) {
     Math.floor(now.getTime() / 1e3)
   );
 }
+function addUserPrompt(db, sessionId, text, promptNumber) {
+  const now = /* @__PURE__ */ new Date();
+  db.prepare(`
+    INSERT INTO user_prompts (session_id, prompt_text, prompt_number, created_at, created_at_epoch)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(sessionId, text, promptNumber, now.toISOString(), Math.floor(now.getTime() / 1e3));
+}
+function searchObservations(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  let sql = `
+    SELECT o.id, o.type, o.title, o.created_at, o.session_id, o.importance,
+           rank
+    FROM observations_fts
+    JOIN observations o ON observations_fts.rowid = o.id
+    WHERE observations_fts MATCH ?
+  `;
+  const params = [sanitizeFts5Query(query)];
+  if (opts?.type) {
+    sql += " AND o.type = ?";
+    params.push(opts.type);
+  }
+  if (opts?.crRule) {
+    sql += " AND o.cr_rule = ?";
+    params.push(opts.crRule);
+  }
+  if (opts?.dateFrom) {
+    sql += " AND o.created_at >= ?";
+    params.push(opts.dateFrom);
+  }
+  sql += " ORDER BY rank LIMIT ?";
+  params.push(limit);
+  return db.prepare(sql).all(...params);
+}
+function getRecentObservations(db, limit = 20, sessionId) {
+  if (sessionId) {
+    return db.prepare(`
+      SELECT id, type, title, detail, importance, created_at, session_id
+      FROM observations WHERE session_id = ?
+      ORDER BY created_at_epoch DESC LIMIT ?
+    `).all(sessionId, limit);
+  }
+  return db.prepare(`
+    SELECT id, type, title, detail, importance, created_at, session_id
+    FROM observations
+    ORDER BY created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getSessionSummaries(db, limit = 10) {
+  return db.prepare(`
+    SELECT session_id, request, completed, failed_attempts, plan_progress, created_at
+    FROM session_summaries
+    ORDER BY created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getSessionTimeline(db, sessionId) {
+  const session = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+  const observations = db.prepare("SELECT * FROM observations WHERE session_id = ? ORDER BY created_at_epoch ASC").all(sessionId);
+  const summary = db.prepare("SELECT * FROM session_summaries WHERE session_id = ? ORDER BY created_at_epoch DESC LIMIT 1").get(sessionId);
+  const prompts = db.prepare("SELECT * FROM user_prompts WHERE session_id = ? ORDER BY prompt_number ASC").all(sessionId);
+  return {
+    session: session ?? null,
+    observations,
+    summary: summary ?? null,
+    prompts
+  };
+}
+function getFailedAttempts(db, query, limit = 20) {
+  if (query) {
+    return db.prepare(`
+      SELECT o.id, o.title, o.detail, o.session_id, o.recurrence_count, o.created_at
+      FROM observations_fts
+      JOIN observations o ON observations_fts.rowid = o.id
+      WHERE observations_fts MATCH ? AND o.type = 'failed_attempt'
+      ORDER BY o.recurrence_count DESC, rank LIMIT ?
+    `).all(sanitizeFts5Query(query), limit);
+  }
+  return db.prepare(`
+    SELECT id, title, detail, session_id, recurrence_count, created_at
+    FROM observations WHERE type = 'failed_attempt'
+    ORDER BY recurrence_count DESC, created_at_epoch DESC LIMIT ?
+  `).all(limit);
+}
+function getDecisionsAbout(db, query, limit = 20) {
+  return db.prepare(`
+    SELECT o.id, o.title, o.detail, o.session_id, o.created_at
+    FROM observations_fts
+    JOIN observations o ON observations_fts.rowid = o.id
+    WHERE observations_fts MATCH ? AND o.type = 'decision'
+    ORDER BY rank LIMIT ?
+  `).all(sanitizeFts5Query(query), limit);
+}
+function armUsageCounter(db, nowEpochSec) {
+  const existing = getMemoryMeta(db, USAGE_COUNTER_ARMED_KEY);
+  if (existing) {
+    const n = Number(existing);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const now = nowEpochSec ?? Math.floor(Date.now() / 1e3);
+  setMemoryMeta(db, USAGE_COUNTER_ARMED_KEY, String(now));
+  return now;
+}
+function usageWarmupElapsed(db, warmupDays, nowEpochSec) {
+  const armed = getMemoryMeta(db, USAGE_COUNTER_ARMED_KEY);
+  if (!armed) return false;
+  const armedEpoch = Number(armed);
+  if (!Number.isFinite(armedEpoch) || armedEpoch <= 0) return false;
+  const now = nowEpochSec ?? Math.floor(Date.now() / 1e3);
+  return now - armedEpoch >= warmupDays * 86400;
+}
+function expireOldLowValueObservations(db, opts) {
+  const now = opts.nowEpochSec ?? Math.floor(Date.now() / 1e3);
+  if (!usageWarmupElapsed(db, opts.usageWarmupDays, now)) return 0;
+  const cutoffEpoch = now - opts.retentionDays * 86400;
+  const typePlaceholders = opts.protectedTypes.length ? opts.protectedTypes.map(() => "?").join(",") : "''";
+  const iso = new Date(now * 1e3).toISOString();
+  const result = db.prepare(
+    `UPDATE observations
+          SET expired_at = ?,
+              expired_at_epoch = ?,
+              valid_to = ?,
+              valid_to_epoch = ?
+        WHERE expired_at IS NULL
+          AND created_at_epoch < ?
+          AND importance <= ?
+          AND type NOT IN (${typePlaceholders})
+          AND COALESCE(evidence, '') != ?
+          -- A file-backed row mirrors a file the human still keeps on disk.
+          -- Value-decay may never retire it; only the file's removal can.
+          AND title NOT LIKE ?
+          AND NOT EXISTS (
+                SELECT 1 FROM memory_usage u
+                 WHERE u.source = 'observation'
+                   AND u.record_id = observations.id
+                   AND u.hit_count > 0
+              )
+          AND NOT EXISTS (
+                -- The grace period: a row demoted within the last cadence
+                -- window is NOT yet expirable, so being pushed to the floor can
+                -- never be immediately fatal.
+                SELECT 1 FROM memory_usage u
+                 WHERE u.source = 'observation'
+                   AND u.record_id = observations.id
+                   AND u.last_reweight_epoch IS NOT NULL
+                   AND u.last_reweight_epoch > ?
+              )`
+  ).run(
+    iso,
+    now,
+    iso,
+    now,
+    cutoffEpoch,
+    opts.importanceFloor,
+    ...opts.protectedTypes,
+    CONSOLIDATION_LESSON_EVIDENCE,
+    MEMORY_FILE_TITLE_LIKE,
+    now - (opts.reweightIntervalDays ?? 1) * 86400
+  );
+  return result.changes;
+}
+function pruneOldObservations(db, opts) {
+  return expireOldLowValueObservations(db, opts);
+}
+function recordRecallHits(db, sessionId, hits, nowEpochSec) {
+  if (!hits.length) return 0;
+  const now = nowEpochSec ?? Math.floor(Date.now() / 1e3);
+  let recorded = 0;
+  const claim = db.prepare(
+    `INSERT OR IGNORE INTO memory_usage_sessions (source, record_id, session_id)
+     VALUES (?, ?, ?)`
+  );
+  const bump = db.prepare(
+    `INSERT INTO memory_usage (source, record_id, hit_count, hits_windowed, last_hit_epoch)
+     VALUES (?, ?, 1, 1, ?)
+     ON CONFLICT(source, record_id) DO UPDATE SET
+       hit_count     = hit_count + 1,
+       hits_windowed = hits_windowed + 1,
+       last_hit_epoch = excluded.last_hit_epoch`
+  );
+  const tx = db.transaction(() => {
+    for (const h of hits) {
+      if (claim.run(h.source, h.id, sessionId).changes === 0) continue;
+      bump.run(h.source, h.id, now);
+      recorded++;
+    }
+  });
+  tx();
+  return recorded;
+}
 function deduplicateFailedAttempt(db, sessionId, title, detail, opts) {
   const existing = db.prepare(`
     SELECT id, recurrence_count FROM observations
@@ -1366,13 +2983,355 @@ function deduplicateFailedAttempt(db, sessionId, title, detail, opts) {
     importance: 5
   });
 }
+function getSessionsByTask(db, taskId) {
+  return db.prepare(`
+    SELECT session_id, status, started_at, ended_at, plan_phase
+    FROM sessions WHERE task_id = ?
+    ORDER BY started_at_epoch DESC
+    LIMIT 10000
+  `).all(taskId);
+}
+function getCrossTaskProgress(db, taskId) {
+  const sessions = db.prepare(`
+    SELECT session_id FROM sessions WHERE task_id = ? LIMIT 10000
+  `).all(taskId);
+  const merged = {};
+  for (const session of sessions) {
+    const summaries = db.prepare(`
+      SELECT plan_progress FROM session_summaries WHERE session_id = ? LIMIT 10000
+    `).all(session.session_id);
+    for (const summary of summaries) {
+      try {
+        const progress = JSON.parse(summary.plan_progress);
+        for (const [key, value] of Object.entries(progress)) {
+          if (!merged[key] || value === "complete" || value === "in_progress" && merged[key] === "pending") {
+            merged[key] = value;
+          }
+        }
+      } catch (_e) {
+      }
+    }
+  }
+  return merged;
+}
+function linkSessionToTask(db, sessionId, taskId) {
+  db.prepare("UPDATE sessions SET task_id = ? WHERE session_id = ?").run(taskId, sessionId);
+}
+function addConversationTurn(db, sessionId, turnNumber, userPrompt, assistantResponse, toolCallsJson, toolCallCount, promptTokens, responseTokens) {
+  const result = db.prepare(`
+    INSERT INTO conversation_turns (session_id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    turnNumber,
+    userPrompt,
+    assistantResponse ? assistantResponse.slice(0, 1e4) : null,
+    toolCallsJson,
+    toolCallCount,
+    promptTokens,
+    responseTokens
+  );
+  return Number(result.lastInsertRowid);
+}
+function addToolCallDetail(db, sessionId, turnNumber, toolName, inputSummary, inputSize, outputSize, success, filesInvolved) {
+  db.prepare(`
+    INSERT INTO tool_call_details (session_id, turn_number, tool_name, tool_input_summary, tool_input_size, tool_output_size, tool_success, files_involved)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    sessionId,
+    turnNumber,
+    toolName,
+    inputSummary ? inputSummary.slice(0, 500) : null,
+    inputSize,
+    outputSize,
+    success ? 1 : 0,
+    filesInvolved ? JSON.stringify(filesInvolved) : null
+  );
+}
+function getLastProcessedLine(db, sessionId) {
+  const row = db.prepare("SELECT value FROM memory_meta WHERE key = ?").get(`last_processed_line:${sessionId}`);
+  return row ? parseInt(row.value, 10) : 0;
+}
+function setLastProcessedLine(db, sessionId, lineNumber) {
+  db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES (?, ?)").run(`last_processed_line:${sessionId}`, String(lineNumber));
+}
+function pruneOldConversationTurns(db, retentionDays = 90) {
+  const cutoffEpoch = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+  const turnsResult = db.prepare("DELETE FROM conversation_turns WHERE created_at_epoch < ?").run(cutoffEpoch);
+  const detailsResult = db.prepare("DELETE FROM tool_call_details WHERE created_at_epoch < ?").run(cutoffEpoch);
+  return { turnsDeleted: turnsResult.changes, detailsDeleted: detailsResult.changes };
+}
+function getConversationTurns(db, sessionId, opts) {
+  let sql = "SELECT id, turn_number, user_prompt, assistant_response, tool_calls_json, tool_call_count, prompt_tokens, response_tokens, created_at FROM conversation_turns WHERE session_id = ?";
+  const params = [sessionId];
+  if (opts?.turnFrom !== void 0) {
+    sql += " AND turn_number >= ?";
+    params.push(opts.turnFrom);
+  }
+  if (opts?.turnTo !== void 0) {
+    sql += " AND turn_number <= ?";
+    params.push(opts.turnTo);
+  }
+  sql += " ORDER BY turn_number ASC";
+  return db.prepare(sql).all(...params);
+}
+function searchConversationTurns(db, query, opts) {
+  const limit = opts?.limit ?? 20;
+  let sql = `
+    SELECT ct.id, ct.session_id, ct.turn_number, ct.user_prompt, ct.tool_call_count, ct.response_tokens, ct.created_at, rank
+    FROM conversation_turns_fts
+    JOIN conversation_turns ct ON conversation_turns_fts.rowid = ct.id
+    WHERE conversation_turns_fts MATCH ?
+  `;
+  const params = [sanitizeFts5Query(query)];
+  if (opts?.sessionId) {
+    sql += " AND ct.session_id = ?";
+    params.push(opts.sessionId);
+  }
+  if (opts?.dateFrom) {
+    sql += " AND ct.created_at >= ?";
+    params.push(opts.dateFrom);
+  }
+  if (opts?.dateTo) {
+    sql += " AND ct.created_at <= ?";
+    params.push(opts.dateTo);
+  }
+  if (opts?.minToolCalls !== void 0) {
+    sql += " AND ct.tool_call_count >= ?";
+    params.push(opts.minToolCalls);
+  }
+  sql += " ORDER BY rank LIMIT ?";
+  params.push(limit);
+  return db.prepare(sql).all(...params);
+}
+function getToolPatterns(db, opts) {
+  const groupBy = opts?.groupBy ?? "tool";
+  const params = [];
+  let whereClause = "";
+  const conditions = [];
+  if (opts?.sessionId) {
+    conditions.push("session_id = ?");
+    params.push(opts.sessionId);
+  }
+  if (opts?.toolName) {
+    conditions.push("tool_name = ?");
+    params.push(opts.toolName);
+  }
+  if (opts?.dateFrom) {
+    conditions.push("created_at >= ?");
+    params.push(opts.dateFrom);
+  }
+  if (conditions.length > 0) {
+    whereClause = "WHERE " + conditions.join(" AND ");
+  }
+  let sql;
+  switch (groupBy) {
+    case "session":
+      sql = `SELECT session_id, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
+             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
+             AVG(tool_output_size) as avg_output_size
+             FROM tool_call_details ${whereClause}
+             GROUP BY session_id ORDER BY call_count DESC`;
+      break;
+    case "day":
+      sql = `SELECT date(created_at) as day, COUNT(*) as call_count, COUNT(DISTINCT tool_name) as unique_tools,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes
+             FROM tool_call_details ${whereClause}
+             GROUP BY date(created_at) ORDER BY day DESC`;
+      break;
+    default:
+      sql = `SELECT tool_name, COUNT(*) as call_count,
+             SUM(CASE WHEN tool_success = 1 THEN 1 ELSE 0 END) as successes,
+             SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) as failures,
+             AVG(tool_output_size) as avg_output_size,
+             AVG(tool_input_size) as avg_input_size
+             FROM tool_call_details ${whereClause}
+             GROUP BY tool_name ORDER BY call_count DESC`;
+      break;
+  }
+  return db.prepare(sql).all(...params);
+}
+function getSessionStats(db, opts) {
+  if (opts?.sessionId) {
+    const turns = db.prepare("SELECT COUNT(*) as turn_count, SUM(tool_call_count) as total_tool_calls, SUM(prompt_tokens) as total_prompt_tokens, SUM(response_tokens) as total_response_tokens FROM conversation_turns WHERE session_id = ?").get(opts.sessionId);
+    const toolBreakdown = db.prepare("SELECT tool_name, COUNT(*) as count FROM tool_call_details WHERE session_id = ? GROUP BY tool_name ORDER BY count DESC").all(opts.sessionId);
+    const session = db.prepare("SELECT * FROM sessions WHERE session_id = ?").get(opts.sessionId);
+    return [{
+      session_id: opts.sessionId,
+      status: session?.status ?? "unknown",
+      started_at: session?.started_at ?? null,
+      ended_at: session?.ended_at ?? null,
+      ...turns,
+      tool_breakdown: toolBreakdown
+    }];
+  }
+  const limit = opts?.limit ?? 10;
+  return db.prepare(`
+    SELECT s.session_id, s.status, s.started_at, s.ended_at,
+           COUNT(ct.id) as turn_count,
+           COALESCE(SUM(ct.tool_call_count), 0) as total_tool_calls,
+           COALESCE(SUM(ct.prompt_tokens), 0) as total_prompt_tokens,
+           COALESCE(SUM(ct.response_tokens), 0) as total_response_tokens
+    FROM sessions s
+    LEFT JOIN conversation_turns ct ON s.session_id = ct.session_id
+    GROUP BY s.session_id
+    ORDER BY s.started_at_epoch DESC
+    LIMIT ?
+  `).all(limit);
+}
+function getObservabilityDbSize(db) {
+  const turnsCount = db.prepare("SELECT COUNT(*) as c FROM conversation_turns").get().c;
+  const detailsCount = db.prepare("SELECT COUNT(*) as c FROM tool_call_details").get().c;
+  const obsCount = db.prepare("SELECT COUNT(*) as c FROM observations").get().c;
+  const pageCount = db.pragma("page_count")[0]?.page_count ?? 0;
+  const pageSize = db.pragma("page_size")[0]?.page_size ?? 4096;
+  return {
+    conversation_turns_count: turnsCount,
+    tool_call_details_count: detailsCount,
+    observations_count: obsCount,
+    db_page_count: pageCount,
+    db_page_size: pageSize,
+    estimated_size_mb: Math.round(pageCount * pageSize / (1024 * 1024) * 100) / 100
+  };
+}
+function addFailureClass(db, opts) {
+  const result = db.prepare(`
+    INSERT OR IGNORE INTO failure_classes (name, description, diff_patterns, file_patterns, prompt_keywords, incidents, rules, scanner_checks, known_message, needs_review)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    opts.name,
+    opts.description,
+    JSON.stringify(opts.diffPatterns ?? []),
+    JSON.stringify(opts.filePatterns ?? []),
+    JSON.stringify(opts.promptKeywords ?? []),
+    JSON.stringify(opts.incidents ?? []),
+    JSON.stringify(opts.rules ?? []),
+    JSON.stringify(opts.scannerChecks ?? []),
+    opts.knownMessage ?? "",
+    opts.needsReview ? 1 : 0
+  );
+  return Number(result.lastInsertRowid);
+}
+function getFailureClasses(db) {
+  const rows = db.prepare("SELECT * FROM failure_classes ORDER BY name LIMIT 10000").all();
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    diff_patterns: JSON.parse(row.diff_patterns || "[]"),
+    file_patterns: JSON.parse(row.file_patterns || "[]"),
+    prompt_keywords: JSON.parse(row.prompt_keywords || "[]"),
+    incidents: JSON.parse(row.incidents || "[]"),
+    rules: JSON.parse(row.rules || "[]"),
+    scanner_checks: JSON.parse(row.scanner_checks || "[]"),
+    known_message: row.known_message,
+    needs_review: !!row.needs_review
+  }));
+}
+function appendIncidentToFailureClass(db, className, incidentId) {
+  const row = db.prepare("SELECT incidents FROM failure_classes WHERE name = ?").get(className);
+  if (!row) return;
+  const incidents = JSON.parse(row.incidents || "[]");
+  if (!incidents.includes(incidentId)) {
+    incidents.push(incidentId);
+    db.prepare("UPDATE failure_classes SET incidents = ?, updated_at = datetime('now') WHERE name = ?").run(JSON.stringify(incidents), className);
+  }
+}
+function scoreFailureClasses(db, matchText, filePath, promptContext, weights) {
+  const classes = getFailureClasses(db);
+  if (classes.length === 0) return null;
+  const diffWeight = weights?.diffPatternWeight ?? 3;
+  const fileWeight = weights?.filePatternWeight ?? 2;
+  const promptWeight = weights?.promptKeywordWeight ?? 2;
+  let bestMatch = null;
+  for (const fc of classes) {
+    let score = 0;
+    for (const pattern of fc.diff_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern, "i").test(matchText)) {
+          score += diffWeight;
+        }
+      } catch {
+        if (matchText.toLowerCase().includes(pattern.toLowerCase())) {
+          score += diffWeight;
+        }
+      }
+    }
+    for (const pattern of fc.file_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern).test(filePath)) {
+          score += fileWeight;
+        }
+      } catch {
+        if (filePath.includes(pattern)) {
+          score += fileWeight;
+        }
+      }
+    }
+    if (promptContext) {
+      for (const keyword of fc.prompt_keywords) {
+        if (!keyword) continue;
+        try {
+          if (new RegExp(keyword, "i").test(promptContext)) {
+            score += promptWeight;
+          }
+        } catch {
+          if (promptContext.toLowerCase().includes(keyword.toLowerCase())) {
+            score += promptWeight;
+          }
+        }
+      }
+    }
+    if (!bestMatch || score > bestMatch.score) {
+      bestMatch = {
+        name: fc.name,
+        score,
+        incidentCount: fc.incidents.length,
+        rules: fc.rules,
+        knownMessage: fc.known_message
+      };
+    }
+  }
+  return bestMatch;
+}
+var MEMORY_SCHEMA_VERSION, TOOL_COST_EVENTS_RETENTION_DAYS, MAX_DRAFT_TEXT_LEN, FUNNEL_EVENT_DRAIN_LIMIT, FUNNEL_EVENT_OUTBOX_CAP, _temporalColCache, CONSOLIDATION_LESSON_EVIDENCE, MEMORY_FILE_TITLE_PREFIX, MEMORY_FILE_TITLE_LIKE, USAGE_COUNTER_ARMED_KEY;
+var init_memory_db = __esm({
+  "src/memory-db.ts"() {
+    "use strict";
+    init_config();
+    init_memory_vector();
+    init_db_backup();
+    init_hook_failure_signal();
+    init_memory_embed_sweep();
+    MEMORY_SCHEMA_VERSION = 1;
+    TOOL_COST_EVENTS_RETENTION_DAYS = 90;
+    MAX_DRAFT_TEXT_LEN = 16384;
+    FUNNEL_EVENT_DRAIN_LIMIT = 5e3;
+    FUNNEL_EVENT_OUTBOX_CAP = 2e4;
+    _temporalColCache = /* @__PURE__ */ new WeakMap();
+    CONSOLIDATION_LESSON_EVIDENCE = "consolidation:session-summary";
+    MEMORY_FILE_TITLE_PREFIX = "[memory-file] ";
+    MEMORY_FILE_TITLE_LIKE = `${MEMORY_FILE_TITLE_PREFIX}%`;
+    USAGE_COUNTER_ARMED_KEY = "usage_counter_armed_epoch";
+  }
+});
+
+// src/hooks/post-tool-use.ts
+init_memory_db();
 
 // src/transcript-parser.ts
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 
+// src/observation-extractor.ts
+init_memory_db();
+
 // src/adr-generator.ts
+init_config();
 var DEFAULT_DETECTION_PHRASES = ["chose", "decided", "switching to", "moving from", "going with"];
 function getDetectionPhrases() {
   return getConfig().governance?.adr?.detection_phrases ?? DEFAULT_DETECTION_PHRASES;
@@ -1382,9 +3341,152 @@ function detectDecisionPatterns(text) {
   const lower = text.toLowerCase();
   return phrases.some((phrase) => lower.includes(phrase));
 }
+function extractAlternatives(description) {
+  const alternatives = [];
+  const overMatch = description.match(/(\w[\w\s-]+)\s+over\s+(\w[\w\s-]+)/i);
+  if (overMatch) {
+    alternatives.push(overMatch[1].trim());
+    alternatives.push(overMatch[2].trim());
+  }
+  const insteadMatch = description.match(/(\w[\w\s-]+)\s+instead\s+of\s+(\w[\w\s-]+)/i);
+  if (insteadMatch) {
+    alternatives.push(insteadMatch[1].trim());
+    alternatives.push(insteadMatch[2].trim());
+  }
+  const switchMatch = description.match(/switching\s+from\s+(\w[\w\s-]+)\s+to\s+(\w[\w\s-]+)/i);
+  if (switchMatch) {
+    alternatives.push(switchMatch[2].trim());
+    alternatives.push(switchMatch[1].trim());
+  }
+  return [...new Set(alternatives)];
+}
+function storeDecision(db, decision) {
+  const existing = new Set(
+    db.prepare(`PRAGMA table_info(architecture_decisions)`).all().map(
+      (c) => c.name
+    )
+  );
+  const cols = ["title", "context", "decision", "alternatives", "consequences", "session_id", "status"];
+  const vals = [
+    decision.title,
+    decision.context,
+    decision.decision,
+    JSON.stringify(decision.alternatives),
+    decision.consequences,
+    decision.sessionId ?? null,
+    decision.status ?? "accepted"
+  ];
+  if (existing.has("affected_files")) {
+    cols.push("affected_files");
+    vals.push(decision.affectedFiles ? JSON.stringify(decision.affectedFiles) : null);
+  }
+  const hasTemporal = existing.has("valid_from_epoch");
+  const extraSql = hasTemporal ? `, valid_from, ingested_at, valid_from_epoch, ingested_at_epoch` : "";
+  const extraVals = hasTemporal ? `, datetime('now'), datetime('now'), CAST(strftime('%s','now') AS INTEGER), CAST(strftime('%s','now') AS INTEGER)` : "";
+  const result = db.prepare(
+    `INSERT INTO architecture_decisions (${cols.join(", ")}${extraSql})
+       VALUES (${cols.map(() => "?").join(", ")}${extraVals})`
+  ).run(...vals);
+  return Number(result.lastInsertRowid);
+}
+
+// src/observation-extractor.ts
+init_config();
+import { homedir as homedir4 } from "os";
+
+// src/hooks/lib/tool-response.ts
+function asString(v) {
+  return typeof v === "string" ? v : "";
+}
+function fromContentBlocks(arr) {
+  const parts = [];
+  for (const block of arr) {
+    if (typeof block === "string") {
+      parts.push(block);
+    } else if (block && typeof block === "object") {
+      const t2 = asString(block.text);
+      if (t2) parts.push(t2);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function textFromObject(o) {
+  if ("stdout" in o || "stderr" in o) {
+    const out = asString(o.stdout);
+    const err = asString(o.stderr);
+    return err ? out ? `${out}
+${err}` : err : out;
+  }
+  const file = o.file;
+  if (file && typeof file === "object") {
+    const c = asString(file.content);
+    if (c) return c;
+  }
+  const content = o.content;
+  if (typeof content === "string" && content) return content;
+  if (Array.isArray(content)) {
+    const blocks = fromContentBlocks(content);
+    if (blocks) return blocks;
+  }
+  if ("structuredPatch" in o || "oldString" in o || "newString" in o) {
+    const path = asString(o.filePath);
+    const newStr = asString(o.newString);
+    return [path, newStr].filter(Boolean).join("\n");
+  }
+  for (const k of ["text", "message", "output", "result", "stdout"]) {
+    const v = asString(o[k]);
+    if (v) return v;
+  }
+  try {
+    return JSON.stringify(o);
+  } catch {
+    return "";
+  }
+}
+function detectError(raw, text) {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const o = raw;
+    if (o.is_error === true || o.isError === true) return true;
+    if (o.interrupted === true) return true;
+  }
+  return /^Error: (Exit code \d+|.*failed)/i.test(text.trimStart());
+}
+function normalizeToolResponse(raw) {
+  if (raw === null || raw === void 0 || raw === "") {
+    return { text: "", isError: false, shape: "empty" };
+  }
+  let text;
+  let shape;
+  if (typeof raw === "string") {
+    text = raw;
+    shape = "string";
+  } else if (Array.isArray(raw)) {
+    shape = "array";
+    const blocks = fromContentBlocks(raw);
+    if (blocks !== null) {
+      text = blocks;
+    } else {
+      try {
+        text = JSON.stringify(raw);
+      } catch {
+        text = "";
+      }
+    }
+  } else if (typeof raw === "object") {
+    shape = "object";
+    try {
+      text = textFromObject(raw);
+    } catch {
+      text = "";
+    }
+  } else {
+    shape = "string";
+    text = String(raw);
+  }
+  return { text, isError: detectError(raw, text), shape };
+}
 
 // src/observation-extractor.ts
-import { homedir as homedir3 } from "os";
 var PRIVATE_PATTERNS = [
   /\/Users\/\w+/,
   // Absolute macOS paths
@@ -1423,7 +3525,7 @@ function isNoisyToolCall(tc, seenReads2) {
     const trivialPatterns = /^(ls|pwd|echo|cat\s|head\s|tail\s|wc\s)/;
     if (trivialPatterns.test(cmd)) return true;
   }
-  if (!tc.result || tc.result.trim() === "") return true;
+  if (!tc.result || typeof tc.result !== "string" || tc.result.trim() === "") return true;
   return false;
 }
 function classifyToolCall(tc) {
@@ -1575,25 +3677,27 @@ function shortenPath(filePath) {
   if (filePath.startsWith(root + "/")) {
     return filePath.slice(root.length + 1);
   }
-  const home = homedir3();
+  const home = homedir4();
   if (filePath.startsWith(home + "/")) {
     return "~/" + filePath.slice(home.length + 1);
   }
   return filePath;
 }
-function classifyRealTimeToolCall(toolName, toolInput, toolResponse, seenReads2) {
+function classifyRealTimeToolCall(toolName, toolInput, toolResponse, seenReads2, isError) {
+  const normalized = normalizeToolResponse(toolResponse);
   const tc = {
     toolName,
     toolUseId: "",
     input: toolInput,
-    result: toolResponse,
-    isError: false
+    result: normalized.text,
+    isError: isError ?? normalized.isError
   };
   if (isNoisyToolCall(tc, seenReads2)) return null;
-  if (toolResponse && detectDecisionPatterns(toolResponse)) {
-    const firstLine = toolResponse.split("\n")[0].slice(0, 200);
+  const responseText = normalized.text;
+  if (responseText && detectDecisionPatterns(responseText)) {
+    const firstLine = responseText.split("\n")[0].slice(0, 200);
     const title = `Architecture decision: ${firstLine}`;
-    const detail = toolResponse.slice(0, 1e3);
+    const detail = responseText.slice(0, 1e3);
     return {
       type: "decision",
       title,
@@ -1601,14 +3705,15 @@ function classifyRealTimeToolCall(toolName, toolInput, toolResponse, seenReads2)
       visibility: classifyVisibility(title, detail),
       opts: {
         importance: assignImportance("decision"),
-        originalTokens: estimateTokens(toolResponse),
-        ...extractLinkedReferences(toolResponse)
+        originalTokens: estimateTokens(responseText),
+        ...extractLinkedReferences(responseText)
       }
     };
   }
   return classifyToolCall(tc);
 }
-function detectPlanProgress(toolResponse) {
+function detectPlanProgress(rawToolResponse) {
+  const toolResponse = normalizeToolResponse(rawToolResponse).text;
   const results = [];
   const progressPattern = /(P\d+-\d+)\s*[:\-]?\s*(COMPLETE|PASS|DONE|complete|pass|done)/g;
   let match;
@@ -1619,6 +3724,7 @@ function detectPlanProgress(toolResponse) {
 }
 
 // src/audit-trail.ts
+init_config();
 function logAuditEntry(db, entry) {
   db.prepare(`
     INSERT INTO audit_log (session_id, event_type, actor, model_id, file_path, change_type, rules_in_effect, approval_status, evidence, metadata)
@@ -1638,6 +3744,7 @@ function logAuditEntry(db, entry) {
 }
 
 // src/regression-detector.ts
+init_config();
 function calculateHealthScore(testsPassing, testsFailing, modificationsSinceTest, lastTested, lastModified) {
   let score = 100;
   if (testsFailing > 0) {
@@ -1714,15 +3821,19 @@ function recordTestResult(db, featureKey, passing, failing) {
   );
 }
 
+// src/validation-engine.ts
+init_config();
+
 // src/import-resolver.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, statSync } from "fs";
-import { resolve as resolve5, dirname as dirname3, join } from "path";
+init_config();
+import { readFileSync as readFileSync4, existsSync as existsSync7, statSync as statSync2 } from "fs";
+import { resolve as resolve6, dirname as dirname6, join as join4 } from "path";
 
 // src/security-utils.ts
-import { resolve as resolve4, normalize } from "path";
+import { resolve as resolve5, normalize } from "path";
 function ensureWithinRoot(filePath, projectRoot) {
-  const resolvedRoot = resolve4(projectRoot);
-  const resolvedPath = resolve4(resolvedRoot, filePath);
+  const resolvedRoot = resolve5(projectRoot);
+  const resolvedPath = resolve5(resolvedRoot, filePath);
   const normalizedPath = normalize(resolvedPath);
   const normalizedRoot = normalize(resolvedRoot);
   if (!normalizedPath.startsWith(normalizedRoot + "/") && normalizedPath !== normalizedRoot) {
@@ -1764,6 +3875,9 @@ function enforceSeverityFloors(configWeights, defaults) {
   return result;
 }
 
+// src/lib/sql-table-names.ts
+init_config();
+
 // src/import-resolver.ts
 function resolveImportPath(specifier, fromFile) {
   if (!specifier.startsWith(".") && !specifier.startsWith("@/")) {
@@ -1772,23 +3886,23 @@ function resolveImportPath(specifier, fromFile) {
   let basePath;
   if (specifier.startsWith("@/")) {
     const paths = getResolvedPaths();
-    basePath = resolve5(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
+    basePath = resolve6(paths.pathAlias["@"] ?? paths.srcDir, specifier.slice(2));
   } else {
-    basePath = resolve5(dirname3(fromFile), specifier);
+    basePath = resolve6(dirname6(fromFile), specifier);
   }
-  if (existsSync4(basePath) && !isDirectory(basePath)) {
+  if (existsSync7(basePath) && !isDirectory(basePath)) {
     return toRelative(basePath);
   }
   const resolvedPaths = getResolvedPaths();
   for (const ext of resolvedPaths.extensions) {
     const withExt = basePath + ext;
-    if (existsSync4(withExt)) {
+    if (existsSync7(withExt)) {
       return toRelative(withExt);
     }
   }
   for (const indexFile of resolvedPaths.indexFiles) {
-    const indexPath = join(basePath, indexFile);
-    if (existsSync4(indexPath)) {
+    const indexPath = join4(basePath, indexFile);
+    if (existsSync7(indexPath)) {
       return toRelative(indexPath);
     }
   }
@@ -1796,7 +3910,7 @@ function resolveImportPath(specifier, fromFile) {
 }
 function isDirectory(path) {
   try {
-    return statSync(path).isDirectory();
+    return statSync2(path).isDirectory();
   } catch {
     return false;
   }
@@ -1810,7 +3924,7 @@ function toRelative(absPath) {
 }
 
 // src/validation-engine.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 function getValidationChecks() {
   return getConfig().governance?.validation?.checks ?? {
     rule_compliance: true,
@@ -1838,7 +3952,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  if (!existsSync5(absPath)) {
+  if (!existsSync8(absPath)) {
     checks.push({
       name: "file_exists",
       severity: "error",
@@ -1847,7 +3961,7 @@ function validateFile(filePath, projectRoot) {
     });
     return checks;
   }
-  const source = readFileSync4(absPath, "utf-8");
+  const source = readFileSync5(absPath, "utf-8");
   const lines = source.split("\n");
   if (activeChecks.rule_compliance !== false) {
     for (const ruleSet of config.rules) {
@@ -1945,7 +4059,8 @@ function storeValidationResult(db, filePath, checks, sessionId, validationType =
 }
 
 // src/security-scorer.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+init_config();
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 var DEFAULT_SECURITY_PATTERNS = [
   {
     regex: /\bexec\s*\(\s*[`"'].*\$\{/,
@@ -2036,12 +4151,12 @@ function scoreFileSecurity(filePath, projectRoot) {
       }]
     };
   }
-  if (!existsSync6(absPath)) {
+  if (!existsSync9(absPath)) {
     return { riskScore: 0, findings: [] };
   }
   let source;
   try {
-    source = readFileSync5(absPath, "utf-8");
+    source = readFileSync6(absPath, "utf-8");
   } catch {
     return { riskScore: 0, findings: [] };
   }
@@ -2080,8 +4195,9 @@ function storeSecurityScore(db, sessionId, filePath, riskScore, findings) {
 }
 
 // src/hooks/post-tool-use.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+init_config();
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync5, statSync as statSync3 } from "fs";
+import { join as join5, basename as pathBasename2, dirname as pathDirname, resolve as pathResolve } from "path";
 
 // src/lib/recurrence-incrementer.ts
 var ANSI = /\x1b\[[0-9;]*m/g;
@@ -2141,44 +4257,185 @@ function incrementRecurrenceCountsForScannerFailures(db, sessionId, scannerStdou
   return updates;
 }
 
+// src/hooks/post-tool-use.ts
+init_hook_failure_signal();
+
 // src/memory-file-ingest.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7, readdirSync } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
+init_memory_db();
 import { parse as parseYaml2 } from "yaml";
+import { basename as pathBasename } from "path";
+import { createHash } from "crypto";
+function stripMdExtension(filePathOrName) {
+  return pathBasename(filePathOrName).replace(/\.md$/, "");
+}
+function parseFrontmatterLoosely(raw) {
+  const out = {};
+  const metadata = {};
+  const WANTED = /* @__PURE__ */ new Set(["name", "description", "type", "confidence"]);
+  let inMetadata = false;
+  for (const line of raw.split("\n")) {
+    if (/^metadata:\s*$/.test(line)) {
+      inMetadata = true;
+      continue;
+    }
+    if (/^[A-Za-z_][\w-]*:/.test(line)) inMetadata = false;
+    const m = line.match(/^(\s*)([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (!m) continue;
+    const [, indent, key, rawValue] = m;
+    if (!WANTED.has(key)) continue;
+    let value = rawValue.trim();
+    if (value.startsWith('"') && value.endsWith('"') && value.length > 1 || value.startsWith("'") && value.endsWith("'") && value.length > 1) {
+      value = value.slice(1, -1);
+    }
+    if (!value) continue;
+    if (indent.length > 0 && inMetadata) metadata[key] = value;
+    else if (indent.length === 0) out[key] = value;
+  }
+  if (Object.keys(metadata).length > 0) out.metadata = metadata;
+  return out;
+}
+function readMemoryFileFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return void 0;
+  try {
+    return parseYaml2(match[1]) ?? void 0;
+  } catch {
+    return parseFrontmatterLoosely(match[1]);
+  }
+}
+function readMemoryKey(fm, key) {
+  const metadata = fm.metadata;
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+    const nested = metadata[key];
+    if (nested != null) return String(nested);
+  }
+  const top = fm[key];
+  if (top != null) return String(top);
+  return void 0;
+}
+var INGEST_SCHEMA_VERSION = 1;
+var MAX_MEMORY_FILE_BYTES = 1e6;
+function auditMemoryFileEvent(db, sessionId, eventType, detail) {
+  if (!sessionId) return;
+  try {
+    db.prepare(
+      `INSERT INTO audit_log (session_id, event_type, actor, evidence)
+       VALUES (?, ?, 'hook', ?)`
+    ).run(sessionId, eventType, detail);
+  } catch {
+  }
+}
+function upsertMemoryFileMirror(db, f) {
+  const now = Math.floor(Date.now() / 1e3);
+  const existing = db.prepare(
+    `SELECT id, content_hash, ingest_schema_version FROM memory_files WHERE rel_path = ?`
+  ).get(f.relPath);
+  if (existing && existing.content_hash === f.contentHash && existing.ingest_schema_version === INGEST_SCHEMA_VERSION) {
+    return "unchanged";
+  }
+  if (existing) {
+    db.prepare(
+      `UPDATE memory_files
+          SET name = ?, raw = ?, frontmatter_json = ?, body = ?, content_hash = ?,
+              ingest_schema_version = ?, synced_at_epoch = ?,
+              expired_at_epoch = NULL
+        WHERE id = ?`
+    ).run(
+      f.name,
+      f.raw,
+      f.frontmatterJson,
+      f.body,
+      f.contentHash,
+      INGEST_SCHEMA_VERSION,
+      now,
+      existing.id
+    );
+    return "updated";
+  }
+  db.prepare(
+    `INSERT INTO memory_files
+       (rel_path, name, raw, frontmatter_json, body, content_hash, ingest_schema_version, synced_at_epoch)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    f.relPath,
+    f.name,
+    f.raw,
+    f.frontmatterJson,
+    f.body,
+    f.contentHash,
+    INGEST_SCHEMA_VERSION,
+    now
+  );
+  return "inserted";
+}
 function ingestMemoryFile(db, sessionId, filePath) {
-  if (!existsSync7(filePath)) return "skipped";
-  const content = readFileSync6(filePath, "utf-8");
-  const basename2 = (filePath.split("/").pop() ?? "").replace(".md", "");
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  let name = basename2;
+  if (!existsSync10(filePath)) return "skipped";
+  const content = readFileSync7(filePath, "utf-8");
+  if (Buffer.byteLength(content, "utf-8") > MAX_MEMORY_FILE_BYTES) {
+    process.stderr.write(
+      `[massu] memory file exceeds ${MAX_MEMORY_FILE_BYTES} bytes, not ingested: ${filePath}
+`
+    );
+    return "skipped";
+  }
+  const basename3 = stripMdExtension(filePath);
+  const fm = readMemoryFileFrontmatter(content);
+  let name = basename3;
   let description = "";
   let type = "discovery";
   let confidence;
-  if (frontmatterMatch) {
-    try {
-      const fm = parseYaml2(frontmatterMatch[1]);
-      name = fm.name ?? basename2;
-      description = fm.description ?? "";
-      type = fm.type ?? "discovery";
-      confidence = fm.confidence != null ? Number(fm.confidence) : void 0;
-    } catch {
-    }
+  if (fm) {
+    name = fm.name ?? basename3;
+    description = fm.description ?? "";
+    type = readMemoryKey(fm, "type") ?? "discovery";
+    const rawConfidence = readMemoryKey(fm, "confidence");
+    confidence = rawConfidence != null ? Number(rawConfidence) : void 0;
   }
   const obsType = mapMemoryTypeToObservationType(type);
   const importance = confidence != null ? Math.max(1, Math.min(5, Math.round(confidence * 4 + 1))) : 4;
   const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
-  const body = bodyMatch ? bodyMatch[1].trim().slice(0, 500) : "";
-  const title = `[memory-file] ${name}`;
+  const body = bodyMatch ? bodyMatch[1] : "";
+  const title = `${MEMORY_FILE_TITLE_PREFIX}${name}`;
   const detail = description ? `${description}
 
 ${body}` : body;
+  const relPath = pathBasename(filePath);
+  const contentHash = createHash("sha256").update(content, "utf-8").digest("hex");
+  const mirror = upsertMemoryFileMirror(db, {
+    relPath,
+    name,
+    raw: content,
+    frontmatterJson: fm ? JSON.stringify(fm) : null,
+    body,
+    contentHash
+  });
   const existing = db.prepare(
-    "SELECT id FROM observations WHERE title = ? LIMIT 1"
+    "SELECT id, type FROM observations WHERE title = ? LIMIT 1"
   ).get(title);
+  const projectionCurrent = existing !== void 0 && existing.type === obsType;
+  if (mirror === "unchanged" && projectionCurrent) {
+    db.prepare(
+      `UPDATE observations
+          SET expired_at = NULL, expired_at_epoch = NULL,
+              valid_to = NULL, valid_to_epoch = NULL
+        WHERE title = ? AND expired_at IS NOT NULL`
+    ).run(title);
+    return "skipped";
+  }
   if (existing) {
-    db.prepare("UPDATE observations SET detail = ?, importance = ? WHERE id = ?").run(detail, importance, existing.id);
+    db.prepare(
+      `UPDATE observations
+          SET type = ?, detail = ?, importance = ?,
+              expired_at = NULL, expired_at_epoch = NULL,
+              valid_to = NULL, valid_to_epoch = NULL
+        WHERE id = ?`
+    ).run(obsType, detail, importance, existing.id);
+    auditMemoryFileEvent(db, sessionId, "memory_file_ingested", relPath);
     return "updated";
   } else {
     addObservation(db, sessionId, obsType, title, detail, { importance });
+    auditMemoryFileEvent(db, sessionId, "memory_file_ingested", relPath);
     return "inserted";
   }
 }
@@ -2210,7 +4467,10 @@ async function main() {
   try {
     const input = await readStdin();
     const hookInput = JSON.parse(input);
-    const { session_id, tool_name, tool_input, tool_response } = hookInput;
+    const { session_id, tool_name, tool_input } = hookInput;
+    const { text: tool_response, isError: toolErrored } = normalizeToolResponse(
+      hookInput.tool_response
+    );
     if (currentSessionId !== session_id) {
       seenReads.clear();
       currentSessionId = session_id;
@@ -2228,6 +4488,27 @@ async function main() {
       } else {
         addObservation(db, session_id, observation.type, observation.title, observation.detail, observation.opts);
       }
+      if (observation.type === "decision") {
+        try {
+          const decisionText = observation.detail ?? observation.title;
+          const alternatives = extractAlternatives(decisionText);
+          const existing = db.prepare(
+            `SELECT id FROM architecture_decisions WHERE session_id = ? AND title = ? LIMIT 1`
+          ).get(session_id, observation.title);
+          if (!existing) {
+            storeDecision(db, {
+              title: observation.title,
+              context: "",
+              decision: decisionText,
+              alternatives,
+              consequences: "",
+              sessionId: session_id,
+              affectedFiles: observation.opts?.filesInvolved
+            });
+          }
+        } catch {
+        }
+      }
       if (tool_response) {
         const progress = detectPlanProgress(tool_response);
         if (progress.length > 0) {
@@ -2323,9 +4604,14 @@ async function main() {
       try {
         if (tool_name === "Edit" || tool_name === "Write") {
           const filePath = tool_input.file_path ?? "";
-          if (filePath && filePath.includes("/memory/") && filePath.endsWith(".md")) {
-            const basename2 = filePath.split("/").pop() ?? "";
-            if (basename2 !== "MEMORY.md") {
+          if (filePath && filePath.endsWith(".md") && pathBasename2(filePath) !== "MEMORY.md") {
+            let memoryDir = "";
+            try {
+              memoryDir = getResolvedPaths().memoryDir;
+            } catch {
+              memoryDir = "";
+            }
+            if (memoryDir && pathResolve(pathDirname(filePath)) === pathResolve(memoryDir)) {
               ingestMemoryFile(db, session_id, filePath);
             }
           }
@@ -2359,10 +4645,10 @@ async function main() {
       } catch (err) {
         try {
           const projectRoot = process.cwd();
-          const dir = join2(projectRoot, ".massu", "rule-candidates");
-          if (!existsSync8(dir)) mkdirSync3(dir, { recursive: true });
-          const logPath = join2(dir, ".cr53-increment-failures.jsonl");
-          const pre = existsSync8(logPath) ? readFileSync7(logPath, "utf-8") : "";
+          const dir = join5(projectRoot, ".massu", "rule-candidates");
+          if (!existsSync11(dir)) mkdirSync5(dir, { recursive: true });
+          const logPath = join5(dir, ".cr53-increment-failures.jsonl");
+          const pre = existsSync11(logPath) ? readFileSync8(logPath, "utf-8") : "";
           const sep = pre && !pre.endsWith("\n") ? "\n" : "";
           writeFileSync2(logPath, pre + sep + JSON.stringify({
             session_id,
@@ -2376,7 +4662,8 @@ async function main() {
     } finally {
       db.close();
     }
-  } catch (_e) {
+  } catch (err) {
+    recordHookFailure("post-tool-use", err);
   }
   process.exit(0);
 }
@@ -2446,14 +4733,14 @@ function parseTestRunOutput(output) {
   return null;
 }
 function readStdin() {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve6(data));
-    setTimeout(() => resolve6(data), 3e3);
+    process.stdin.on("end", () => resolve7(data));
+    setTimeout(() => resolve7(data), 3e3);
   });
 }
 var _cachedConventions = null;
@@ -2466,13 +4753,13 @@ var _conventionDefaults = {
 function readConventions(cwd) {
   try {
     const projectRoot = cwd ?? process.cwd();
-    const configPath = join2(projectRoot, "massu.config.yaml");
-    if (!existsSync8(configPath)) return _conventionDefaults;
-    const mtimeMs = statSync2(configPath).mtimeMs;
+    const configPath = join5(projectRoot, "massu.config.yaml");
+    if (!existsSync11(configPath)) return _conventionDefaults;
+    const mtimeMs = statSync3(configPath).mtimeMs;
     if (_cachedConventions !== null && _cachedConventionsPath === configPath && _cachedConventionsMtimeMs === mtimeMs) {
       return _cachedConventions;
     }
-    const content = readFileSync7(configPath, "utf-8");
+    const content = readFileSync8(configPath, "utf-8");
     const parsed = parseYaml3(content);
     if (!parsed || typeof parsed !== "object") return _conventionDefaults;
     const conventions = parsed.conventions;
@@ -2490,7 +4777,7 @@ function readConventions(cwd) {
   }
 }
 function isKnowledgeSourceFile(filePath) {
-  const basename2 = filePath.split("/").pop() ?? "";
+  const basename3 = filePath.split("/").pop() ?? "";
   const conventions = readConventions();
   const knowledgeSourcePatterns = [
     ...conventions.knowledgeSourceFiles,
@@ -2499,16 +4786,16 @@ function isKnowledgeSourceFile(filePath) {
     "knowledge-indexer.ts",
     "knowledge-tools.ts"
   ];
-  return knowledgeSourcePatterns.some((p) => basename2 === p) || filePath.includes("/memory/") || filePath.includes(conventions.claudeDirName + "/");
+  return knowledgeSourcePatterns.some((p) => basename3 === p) || filePath.includes("/memory/") || filePath.includes(conventions.claudeDirName + "/");
 }
 function checkMemoryFileIntegrity(filePath) {
   const issues = [];
   try {
-    if (!existsSync8(filePath)) {
+    if (!existsSync11(filePath)) {
       issues.push("MEMORY.md file does not exist after write");
       return issues;
     }
-    const content = readFileSync7(filePath, "utf-8");
+    const content = readFileSync8(filePath, "utf-8");
     const lines = content.split("\n");
     const MAX_LINES = 200;
     if (lines.length > MAX_LINES) {