@massu/core 2.5.5 → 2.5.7

package/dist/hooks/session-end.js

@@ -1648,9 +1648,9 @@ function nackLearning(db, lease, error) {
   return snap;
 }
 function undeliveredSnapshot(db) {
-  const count = (t) => {
-    if (!tableExists(db, t)) return 0;
-    const r2 = db.prepare(`SELECT COUNT(*) AS n FROM ${t}`).get();
+  const count = (t2) => {
+    if (!tableExists(db, t2)) return 0;
+    const r2 = db.prepare(`SELECT COUNT(*) AS n FROM ${t2}`).get();
     return r2.n;
   };
   const promotions = count("team_promotion_outbound");
@@ -1658,10 +1658,10 @@ function undeliveredSnapshot(db) {
   const events = count(TELEMETRY_OUTBOUND_TABLE);
   let maxAttempts = 0;
   let oldest = null;
-  for (const t of RULE_OUTBOUND_TABLES) {
-    if (!tableExists(db, t)) continue;
-    if (!columns(db, t).has("attempts")) continue;
-    const r2 = db.prepare(`SELECT MAX(attempts) AS a, MIN(created_at) AS c FROM ${t}`).get();
+  for (const t2 of RULE_OUTBOUND_TABLES) {
+    if (!tableExists(db, t2)) continue;
+    if (!columns(db, t2).has("attempts")) continue;
+    const r2 = db.prepare(`SELECT MAX(attempts) AS a, MIN(created_at) AS c FROM ${t2}`).get();
     if (r2.a !== null && r2.a > maxAttempts) maxAttempts = r2.a;
     if (r2.c !== null && (oldest === null || r2.c < oldest)) oldest = r2.c;
   }
@@ -1958,13 +1958,13 @@ function encode(text, vocab, opts = {}) {
   const maxLen = opts.maxLen ?? 256;
   const basic = basicTokenize(text);
   const wpTokens = [];
-  for (const t of basic) {
-    for (const sub of wordpieceTokenize(t, vocab)) wpTokens.push(sub);
+  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((t) => vocab.get(t) ?? unkId);
+  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 };
@@ -2066,11 +2066,11 @@ async function getSession() {
 function meanPool(hidden, mask, seqLen, hiddenSize) {
   const out = new Float32Array(hiddenSize);
   let maskSum = 0;
-  for (let t = 0; t < seqLen; t++) {
-    const m = mask[t];
+  for (let t2 = 0; t2 < seqLen; t2++) {
+    const m = mask[t2];
     if (m === 0) continue;
     maskSum += m;
-    const base = t * hiddenSize;
+    const base = t2 * hiddenSize;
     for (let h = 0; h < hiddenSize; h++) out[h] += hidden[base + h] * m;
   }
   const denom = Math.max(maskSum, 1e-9);
@@ -2078,16 +2078,16 @@ function meanPool(hidden, mask, seqLen, hiddenSize) {
   return out;
 }
 function chunkForEmbedding(text) {
-  const t = text.trim();
-  if (!t) return [];
-  if (t.length <= CHUNK_TARGET_CHARS) return [t];
+  const t2 = text.trim();
+  if (!t2) return [];
+  if (t2.length <= CHUNK_TARGET_CHARS) return [t2];
   const chunks = [];
   let start = 0;
-  while (start < t.length && chunks.length < MAX_CHUNKS_PER_RECORD) {
-    let end = Math.min(start + CHUNK_TARGET_CHARS, t.length);
-    if (end < t.length) {
+  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 = t.slice(start, end);
+      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(" ");
@@ -2099,9 +2099,9 @@ function chunkForEmbedding(text) {
         }
       }
     }
-    const chunk = t.slice(start, end).trim();
+    const chunk = t2.slice(start, end).trim();
     if (chunk) chunks.push(chunk);
-    if (end >= t.length) break;
+    if (end >= t2.length) break;
     start = Math.max(end - CHUNK_OVERLAP_CHARS, start + 1);
   }
   return chunks;
@@ -2186,17 +2186,17 @@ async function embedBatch(texts) {
   const settings = loadEmbedSettings();
   if (!settings.enabled) return texts.map(() => null);
   const results = [];
-  for (const t of texts) {
-    if (!t || !t.trim()) {
+  for (const t2 of texts) {
+    if (!t2 || !t2.trim()) {
       results.push(null);
       continue;
     }
     try {
       let vec = null;
       if (settings.endpoint) {
-        vec = await embedTier0(t, settings);
+        vec = await embedTier0(t2, settings);
       }
-      if (!vec) vec = await embedTier1(t);
+      if (!vec) vec = await embedTier1(t2);
       results.push(vec);
     } catch {
       results.push(null);
@@ -2340,6 +2340,8 @@ __export(memory_db_exports, {
   MEMORY_FILE_TITLE_LIKE: () => MEMORY_FILE_TITLE_LIKE,
   MEMORY_FILE_TITLE_PREFIX: () => MEMORY_FILE_TITLE_PREFIX,
   MEMORY_SCHEMA_VERSION: () => MEMORY_SCHEMA_VERSION,
+  PENDING_SYNC_MAX_AGE_DAYS: () => PENDING_SYNC_MAX_AGE_DAYS,
+  PENDING_SYNC_MAX_ITEMS: () => PENDING_SYNC_MAX_ITEMS,
   TOOL_COST_EVENTS_RETENTION_DAYS: () => TOOL_COST_EVENTS_RETENTION_DAYS,
   USAGE_COUNTER_ARMED_KEY: () => USAGE_COUNTER_ARMED_KEY,
   addConversationTurn: () => addConversationTurn,
@@ -2348,6 +2350,7 @@ __export(memory_db_exports, {
   addSummary: () => addSummary,
   addToolCallDetail: () => addToolCallDetail,
   addUserPrompt: () => addUserPrompt,
+  allPendingSync: () => allPendingSync,
   appendIncidentToFailureClass: () => appendIncidentToFailureClass,
   armUsageCounter: () => armUsageCounter,
   assignImportance: () => assignImportance,
@@ -2355,6 +2358,7 @@ __export(memory_db_exports, {
   createSession: () => createSession,
   deduplicateFailedAttempt: () => deduplicateFailedAttempt,
   dequeuePendingSync: () => dequeuePendingSync,
+  discardPendingSync: () => discardPendingSync,
   embedMissingObservations: () => embedMissingObservations,
   endSession: () => endSession,
   enqueueRulePromotionEvent: () => enqueueRulePromotionEvent,
@@ -2411,14 +2415,14 @@ function sanitizeFts5Query(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return '""';
   const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter(Boolean);
-  return tokens.map((t) => `"${t}"`).join(" ");
+  return tokens.map((t2) => `"${t2}"`).join(" ");
 }
 function sanitizeFts5QueryOr(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return '""';
-  const tokens = trimmed.replace(/"/g, "").split(/\s+/).filter((t) => t.replace(/[^a-zA-Z0-9]/g, "").length >= 3);
+  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((t) => `"${t}"`).join(" OR ");
+  return tokens.map((t2) => `"${t2}"`).join(" OR ");
 }
 function getMemoryDb() {
   const dbPath = getResolvedPaths().memoryDbPath;
@@ -3337,6 +3341,35 @@ function initMemorySchema(db) {
 }
 function enqueueSyncPayload(db, payload) {
   db.prepare("INSERT INTO pending_sync (payload) VALUES (?)").run(payload);
+  const overflow = db.prepare(
+    `SELECT id, retry_count, last_error, payload FROM pending_sync
+      WHERE created_at < datetime('now', ?)
+         OR id NOT IN (SELECT id FROM pending_sync ORDER BY created_at DESC, id DESC LIMIT ?)
+      LIMIT 10000`
+  ).all(`-${PENDING_SYNC_MAX_AGE_DAYS} days`, PENDING_SYNC_MAX_ITEMS);
+  if (overflow.length > 0) {
+    discardPendingSync(db, overflow, `over the queue limit (${PENDING_SYNC_MAX_ITEMS} items / ${PENDING_SYNC_MAX_AGE_DAYS} days)`);
+  }
+}
+function discardPendingSync(db, rows, why) {
+  if (rows.length === 0) return 0;
+  const rescued = rescueLearningFromStalePayloads(db, rows);
+  for (let i = 0; i < rows.length; i += 500) {
+    const ids = rows.slice(i, i + 500).map((r2) => r2.id);
+    db.prepare(`DELETE FROM pending_sync WHERE id IN (${ids.map(() => "?").join(",")})`).run(...ids);
+  }
+  if (rescued > 0) {
+    process.stderr.write(
+      `[massu] RESCUED ${rescued} learned rule(s) from ${rows.length} discarded payload(s) \u2014 they were re-queued for delivery, NOT discarded.
+`
+    );
+  }
+  process.stderr.write(`[massu] cloud sync: discarded ${rows.length} queued upload(s): ${why}.
+`);
+  return rows.length;
+}
+function allPendingSync(db) {
+  return db.prepare("SELECT id, retry_count, last_error, payload FROM pending_sync").all();
 }
 function getMemoryMeta(db, key) {
   const row = db.prepare("SELECT value FROM memory_meta WHERE key = ?").get(key);
@@ -3364,9 +3397,9 @@ function upsertObservationEmbedding(db, observationId, vec, modelId, dim) {
   ).run(observationId, modelId, dim, float32ToBlob(vec));
 }
 function observationEmbedText(title, detail) {
-  const t = (title ?? "").trim();
+  const t2 = (title ?? "").trim();
   const d = (detail ?? "").trim();
-  return d ? `${t}. ${d}` : t;
+  return d ? `${t2}. ${d}` : t2;
 }
 async function embedMissingObservations(db, opts = {}) {
   return runEmbedSweep(
@@ -3539,7 +3572,9 @@ function dequeuePendingSync(db, limit = 10) {
     }
   }
   return db.prepare(
-    "SELECT id, payload, retry_count FROM pending_sync ORDER BY created_at ASC LIMIT ?"
+    // Least-retried first: oldest-first retried the same 10 items until they were discarded
+    // while every newer item waited at retry 0 (2026-11-09: 43,492 never attempted).
+    "SELECT id, payload, retry_count FROM pending_sync ORDER BY retry_count ASC, created_at ASC LIMIT ?"
   ).all(limit);
 }
 function removePendingSync(db, id) {
@@ -4212,7 +4247,7 @@ function scoreFailureClasses(db, matchText, filePath, promptContext, weights) {
   }
   return bestMatch;
 }
-var MEMORY_SCHEMA_VERSION, TOOL_COST_EVENTS_RETENTION_DAYS, MAX_DRAFT_TEXT_LEN, FUNNEL_EVENT_OUTBOX_CAP, _temporalColCache, CONSOLIDATION_LESSON_EVIDENCE, MEMORY_FILE_TITLE_PREFIX, MEMORY_FILE_TITLE_LIKE, USAGE_COUNTER_ARMED_KEY;
+var MEMORY_SCHEMA_VERSION, TOOL_COST_EVENTS_RETENTION_DAYS, PENDING_SYNC_MAX_ITEMS, PENDING_SYNC_MAX_AGE_DAYS, MAX_DRAFT_TEXT_LEN, 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";
@@ -4227,6 +4262,8 @@ var init_memory_db = __esm({
     init_memory_embed_sweep();
     MEMORY_SCHEMA_VERSION = 2;
     TOOL_COST_EVENTS_RETENTION_DAYS = 90;
+    PENDING_SYNC_MAX_ITEMS = 500;
+    PENDING_SYNC_MAX_AGE_DAYS = 30;
     MAX_DRAFT_TEXT_LEN = 16384;
     FUNNEL_EVENT_OUTBOX_CAP = 2e4;
     _temporalColCache = /* @__PURE__ */ new WeakMap();
@@ -4560,6 +4597,21 @@ function classifyVisibility(title, detail) {
 }
 
 // src/cloud-sync.ts
+var CLOUD_SYNC_REFUSAL_KEY = "cloud_sync_refused";
+var CLOUD_SYNC_RECHECK_MS = 24 * 60 * 60 * 1e3;
+function isPermanentSyncStatus(status) {
+  return status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+function readCloudSyncRefusal(db) {
+  try {
+    const raw = getMemoryMeta(db, CLOUD_SYNC_REFUSAL_KEY);
+    if (!raw) return null;
+    const v = JSON.parse(raw);
+    return v && typeof v.status === "number" ? v : null;
+  } catch {
+    return null;
+  }
+}
 var MAX_RETRIES = 3;
 var RETRY_DELAYS = [1e3, 2e3, 4e3];
 var DEFAULT_CLOUD_REQUEST_TIMEOUT_MS = 15e3;
@@ -4579,6 +4631,15 @@ async function syncToCloud(db, payload, opts = {}) {
   if (!endpoint) {
     return { success: false, synced: { sessions: 0, observations: 0, analytics: 0, audit: 0 }, error: "No sync endpoint configured" };
   }
+  const refusal = readCloudSyncRefusal(db);
+  if (refusal && Date.now() - Date.parse(refusal.at) < CLOUD_SYNC_RECHECK_MS) {
+    return {
+      success: false,
+      paused: true,
+      synced: { sessions: 0, observations: 0, analytics: 0, audit: 0 },
+      error: `cloud sync paused: HTTP ${refusal.status}: ${refusal.reason}`
+    };
+  }
   const filteredPayload = {};
   if (cloud.sync?.memory !== false) {
     filteredPayload.sessions = payload.sessions;
@@ -4648,9 +4709,12 @@ async function syncToCloud(db, payload, opts = {}) {
     }
   }
   let lastError = "";
+  let permanentStatus = null;
+  let permanentReason = "";
   const configuredTimeoutMs = cloud.requestTimeoutMs ?? DEFAULT_CLOUD_REQUEST_TIMEOUT_MS;
   const deadlineAt = Math.min(Date.now() + SYNC_DEADLINE_MS, opts.deadlineAt ?? Infinity);
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+  const maxAttempts = Math.max(1, Math.min(opts.maxAttempts ?? MAX_RETRIES, MAX_RETRIES));
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const remainingMs = deadlineAt - Date.now();
     if (remainingMs < MIN_ATTEMPT_BUDGET_MS) {
       lastError = lastError || "sync deadline exceeded";
@@ -4671,16 +4735,25 @@ async function syncToCloud(db, payload, opts = {}) {
         signal: AbortSignal.timeout(requestTimeoutMs)
       });
       if (!response.ok) {
-        lastError = `HTTP ${response.status}: ${response.statusText}`;
-        if (response.status >= 400 && response.status < 500) {
+        const reason = await readErrorReason(response);
+        lastError = `HTTP ${response.status}: ${reason}`;
+        if (isPermanentSyncStatus(response.status)) {
+          permanentStatus = response.status;
+          permanentReason = reason;
           break;
         }
-        if (attempt < MAX_RETRIES - 1) {
+        if (attempt < maxAttempts - 1) {
           await sleep(RETRY_DELAYS[attempt]);
           continue;
         }
         break;
       }
+      if (refusal) {
+        try {
+          setMemoryMeta(db, CLOUD_SYNC_REFUSAL_KEY, "");
+        } catch {
+        }
+      }
       const result = await response.json();
       return {
         success: true,
@@ -4700,12 +4773,33 @@ async function syncToCloud(db, payload, opts = {}) {
       if (err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError")) {
         break;
       }
-      if (attempt < MAX_RETRIES - 1) {
+      if (attempt < maxAttempts - 1) {
         await sleep(RETRY_DELAYS[attempt]);
         continue;
       }
     }
   }
+  if (permanentStatus !== null) {
+    if (permanentStatus === 401 || permanentStatus === 403) {
+      try {
+        setMemoryMeta(db, CLOUD_SYNC_REFUSAL_KEY, JSON.stringify({
+          status: permanentStatus,
+          reason: permanentReason,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        discardPendingSync(db, allPendingSync(db), `the cloud refused this account (HTTP ${permanentStatus}: ${permanentReason})`);
+      } catch (err) {
+        process.stderr.write(`[massu] WARNING: could not record the cloud-sync refusal: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    return {
+      success: false,
+      permanent: true,
+      synced: { sessions: 0, observations: 0, analytics: 0, audit: 0 },
+      error: lastError
+    };
+  }
   if (opts.enqueueOnFailure !== false) {
     try {
       enqueueSyncPayload(db, JSON.stringify(stripLearningFromPayload(payload)));
@@ -4726,6 +4820,8 @@ async function drainSyncQueue(db, deadlineAt) {
   const out = { attempted: 0, deferred: 0 };
   const config = getConfig();
   if (!config.cloud?.enabled || !config.cloud?.apiKey) return out;
+  const refusal = readCloudSyncRefusal(db);
+  if (refusal && Date.now() - Date.parse(refusal.at) < CLOUD_SYNC_RECHECK_MS) return out;
   const pending = dequeuePendingSync(db, 10);
   for (let i = 0; i < pending.length; i++) {
     const item = pending[i];
@@ -4737,9 +4833,14 @@ async function drainSyncQueue(db, deadlineAt) {
     out.attempted++;
     try {
       const payload = JSON.parse(item.payload);
-      const result = await syncToCloud(db, payload, { deadlineAt, enqueueOnFailure: false });
+      const result = await syncToCloud(db, payload, { deadlineAt, enqueueOnFailure: false, maxAttempts: 1 });
       if (result.success) {
         removePendingSync(db, item.id);
+      } else if (result.paused) {
+        break;
+      } else if (result.permanent) {
+        discardPendingSync(db, [{ id: item.id, retry_count: item.retry_count, last_error: result.error ?? null, payload: item.payload }], result.error ?? "permanent refusal");
+        if (readCloudSyncRefusal(db)) break;
       } else {
         incrementRetryCount(db, item.id, result.error ?? "Unknown error");
       }
@@ -4750,7 +4851,21 @@ async function drainSyncQueue(db, deadlineAt) {
   return out;
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+async function readErrorReason(response) {
+  try {
+    const text = (await response.text()).slice(0, 300);
+    try {
+      const j = JSON.parse(text);
+      const r2 = typeof j.error === "string" ? j.error : typeof j.message === "string" ? j.message : "";
+      if (r2) return r2;
+    } catch {
+    }
+    return text.trim() || response.statusText;
+  } catch {
+    return response.statusText;
+  }
 }
 
 // src/team-rule-sync.ts
@@ -5131,6 +5246,13 @@ function assertContainedIn(rootDir, candidate, opts = {}) {
   }
   return abs;
 }
+function isSameRealPath(a, b) {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch {
+    return false;
+  }
+}
 function isContainedIn(rootDir, candidate, opts = {}) {
   if (candidate.includes("\0")) return false;
   const root = resolve7(rootDir);
@@ -5953,9 +6075,9 @@ var NOISE_PATTERNS = [
   /system-reminder/i
 ];
 function isSummarizableSignal(text) {
-  const t = text.trim();
-  if (t.length < 25) return false;
-  return !NOISE_PATTERNS.some((re) => re.test(t));
+  const t2 = text.trim();
+  if (t2.length < 25) return false;
+  return !NOISE_PATTERNS.some((re) => re.test(t2));
 }
 var CREDENTIAL_LABELS = ["api[_-]?key", "secret", "password", "token"];
 var LABELLED_CREDENTIAL = new RegExp(
@@ -6400,9 +6522,403 @@ function backfillQualityScores(db) {
 
 // src/cost-reprice.ts
 init_config();
-init_memory_db();
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
+import { dirname as dirname14, join as join12 } from "path";
+
+// src/db.ts
+init_db_driver();
 import { dirname as dirname13, join as join11 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync14, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+
+// src/preflight.ts
+init_db_driver();
+init_config();
+
+// src/db.ts
+init_config();
+
+// src/lib/sql-table-names.ts
+init_config();
+function t(suffix) {
+  return `${getConfig().toolPrefix}_${suffix}`;
+}
+
+// src/db.ts
+function getDataDb() {
+  const dbPath = getResolvedPaths().dataDbPath;
+  const dir = dirname13(dbPath);
+  if (!existsSync16(dir)) {
+    mkdirSync14(dir, { recursive: true });
+  }
+  const db = openDatabase2(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initDataSchema(db);
+  return db;
+}
+function initDataSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${t("imports")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_file TEXT NOT NULL,
+      target_file TEXT NOT NULL,
+      import_type TEXT NOT NULL CHECK(import_type IN ('named', 'default', 'namespace', 'side_effect', 'dynamic')),
+      imported_names TEXT NOT NULL DEFAULT '[]',
+      line INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_massu_imports_source ON ${t("imports")}(source_file);
+    CREATE INDEX IF NOT EXISTS idx_massu_imports_target ON ${t("imports")}(target_file);
+
+    CREATE TABLE IF NOT EXISTS ${t("trpc_procedures")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      router_file TEXT NOT NULL,
+      router_name TEXT NOT NULL,
+      procedure_name TEXT NOT NULL,
+      procedure_type TEXT NOT NULL CHECK(procedure_type IN ('query', 'mutation')),
+      has_ui_caller INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_massu_trpc_router ON ${t("trpc_procedures")}(router_name);
+
+    CREATE TABLE IF NOT EXISTS ${t("trpc_call_sites")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      procedure_id INTEGER NOT NULL,
+      file TEXT NOT NULL,
+      line INTEGER NOT NULL DEFAULT 0,
+      call_pattern TEXT NOT NULL,
+      FOREIGN KEY (procedure_id) REFERENCES ${t("trpc_procedures")}(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_massu_call_sites_proc ON ${t("trpc_call_sites")}(procedure_id);
+
+    CREATE TABLE IF NOT EXISTS ${t("page_deps")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      page_file TEXT NOT NULL,
+      route TEXT NOT NULL,
+      portal TEXT NOT NULL DEFAULT 'unknown',
+      components TEXT NOT NULL DEFAULT '[]',
+      hooks TEXT NOT NULL DEFAULT '[]',
+      routers TEXT NOT NULL DEFAULT '[]',
+      tables_touched TEXT NOT NULL DEFAULT '[]'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_massu_page_deps_page ON ${t("page_deps")}(page_file);
+
+    CREATE TABLE IF NOT EXISTS ${t("middleware_tree")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file TEXT NOT NULL UNIQUE
+    );
+
+    CREATE TABLE IF NOT EXISTS ${t("meta")} (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    -- ============================================================
+    -- Python Code Intelligence Tables
+    -- ============================================================
+
+    CREATE TABLE IF NOT EXISTS ${t("py_imports")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_file TEXT NOT NULL,
+      target_file TEXT NOT NULL,
+      import_type TEXT NOT NULL CHECK(import_type IN ('absolute', 'relative', 'from_absolute', 'from_relative')),
+      imported_names TEXT NOT NULL DEFAULT '[]',
+      line INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_imports_source ON ${t("py_imports")}(source_file);
+    CREATE INDEX IF NOT EXISTS idx_massu_py_imports_target ON ${t("py_imports")}(target_file);
+
+    CREATE TABLE IF NOT EXISTS ${t("py_meta")} (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS ${t("py_routes")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file TEXT NOT NULL,
+      method TEXT NOT NULL,
+      path TEXT NOT NULL,
+      function_name TEXT NOT NULL,
+      dependencies TEXT NOT NULL DEFAULT '[]',
+      request_model TEXT,
+      response_model TEXT,
+      is_authenticated INTEGER NOT NULL DEFAULT 0,
+      line INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_routes_path ON ${t("py_routes")}(path);
+    CREATE INDEX IF NOT EXISTS idx_massu_py_routes_file ON ${t("py_routes")}(file);
+
+    CREATE TABLE IF NOT EXISTS ${t("py_route_callers")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      route_id INTEGER NOT NULL REFERENCES ${t("py_routes")}(id) ON DELETE CASCADE,
+      frontend_file TEXT NOT NULL,
+      line INTEGER NOT NULL DEFAULT 0,
+      call_pattern TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_route_callers_route ON ${t("py_route_callers")}(route_id);
+
+    CREATE TABLE IF NOT EXISTS ${t("py_models")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      class_name TEXT NOT NULL,
+      table_name TEXT,
+      file TEXT NOT NULL,
+      line INTEGER NOT NULL DEFAULT 0,
+      columns TEXT NOT NULL DEFAULT '[]',
+      relationships TEXT NOT NULL DEFAULT '[]',
+      foreign_keys TEXT NOT NULL DEFAULT '[]'
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_models_file ON ${t("py_models")}(file);
+    CREATE INDEX IF NOT EXISTS idx_massu_py_models_table ON ${t("py_models")}(table_name);
+
+    CREATE TABLE IF NOT EXISTS ${t("py_fk_edges")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_table TEXT NOT NULL,
+      source_column TEXT NOT NULL,
+      target_table TEXT NOT NULL,
+      target_column TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_fk_source ON ${t("py_fk_edges")}(source_table);
+    CREATE INDEX IF NOT EXISTS idx_massu_py_fk_target ON ${t("py_fk_edges")}(target_table);
+
+    CREATE TABLE IF NOT EXISTS ${t("py_migrations")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      revision TEXT NOT NULL UNIQUE,
+      down_revision TEXT,
+      file TEXT NOT NULL,
+      description TEXT,
+      operations TEXT NOT NULL DEFAULT '[]',
+      is_head INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_massu_py_migrations_rev ON ${t("py_migrations")}(revision);
+
+    -- ============================================================
+    -- Sentinel: Feature Registry Tables
+    -- ============================================================
+
+    -- Core feature definition
+    CREATE TABLE IF NOT EXISTS ${t("sentinel")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_key TEXT UNIQUE NOT NULL,
+      domain TEXT NOT NULL,
+      subdomain TEXT,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'active'
+        CHECK(status IN ('planned', 'active', 'deprecated', 'removed')),
+      priority TEXT DEFAULT 'standard'
+        CHECK(priority IN ('critical', 'standard', 'nice-to-have')),
+      portal_scope TEXT DEFAULT '[]',
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now')),
+      removed_at TEXT,
+      removed_reason TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sentinel_domain ON ${t("sentinel")}(domain);
+    CREATE INDEX IF NOT EXISTS idx_sentinel_status ON ${t("sentinel")}(status);
+    CREATE INDEX IF NOT EXISTS idx_sentinel_key ON ${t("sentinel")}(feature_key);
+
+    -- Feature-to-component mapping (many-to-many)
+    CREATE TABLE IF NOT EXISTS ${t("sentinel_components")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      component_file TEXT NOT NULL,
+      component_name TEXT,
+      role TEXT DEFAULT 'implementation'
+        CHECK(role IN ('implementation', 'ui', 'data', 'utility')),
+      is_primary BOOLEAN DEFAULT 0,
+      UNIQUE(feature_id, component_file, component_name)
+    );
+
+    -- Feature-to-procedure mapping (many-to-many)
+    CREATE TABLE IF NOT EXISTS ${t("sentinel_procedures")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      router_name TEXT NOT NULL,
+      procedure_name TEXT NOT NULL,
+      procedure_type TEXT,
+      UNIQUE(feature_id, router_name, procedure_name)
+    );
+
+    -- Feature-to-page mapping (where feature is accessible)
+    CREATE TABLE IF NOT EXISTS ${t("sentinel_pages")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      page_route TEXT NOT NULL,
+      portal TEXT,
+      UNIQUE(feature_id, page_route, portal)
+    );
+
+    -- Feature dependency graph
+    CREATE TABLE IF NOT EXISTS ${t("sentinel_deps")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      depends_on_feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      dependency_type TEXT DEFAULT 'requires'
+        CHECK(dependency_type IN ('requires', 'enhances', 'replaces')),
+      UNIQUE(feature_id, depends_on_feature_id)
+    );
+
+    -- Feature change log (audit trail)
+    CREATE TABLE IF NOT EXISTS ${t("sentinel_changelog")} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id INTEGER NOT NULL REFERENCES ${t("sentinel")}(id) ON DELETE CASCADE,
+      change_type TEXT NOT NULL,
+      changed_by TEXT,
+      change_detail TEXT,
+      commit_hash TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sentinel_components_file ON ${t("sentinel_components")}(component_file);
+    CREATE INDEX IF NOT EXISTS idx_sentinel_procedures_router ON ${t("sentinel_procedures")}(router_name);
+    CREATE INDEX IF NOT EXISTS idx_sentinel_pages_route ON ${t("sentinel_pages")}(page_route);
+    CREATE INDEX IF NOT EXISTS idx_sentinel_changelog_feature ON ${t("sentinel_changelog")}(feature_id);
+  `);
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS ${t("sentinel_fts")} USING fts5(
+      feature_key, title, description, domain, subdomain,
+      content=${t("sentinel")}, content_rowid=id
+    );
+  `);
+  db.exec(`
+    CREATE TRIGGER IF NOT EXISTS massu_sentinel_ai AFTER INSERT ON ${t("sentinel")} BEGIN
+      INSERT INTO ${t("sentinel_fts")}(rowid, feature_key, title, description, domain, subdomain)
+      VALUES (new.id, new.feature_key, new.title, new.description, new.domain, new.subdomain);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS massu_sentinel_ad AFTER DELETE ON ${t("sentinel")} BEGIN
+      INSERT INTO ${t("sentinel_fts")}(${t("sentinel_fts")}, rowid, feature_key, title, description, domain, subdomain)
+      VALUES ('delete', old.id, old.feature_key, old.title, old.description, old.domain, old.subdomain);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS massu_sentinel_au AFTER UPDATE ON ${t("sentinel")} BEGIN
+      INSERT INTO ${t("sentinel_fts")}(${t("sentinel_fts")}, rowid, feature_key, title, description, domain, subdomain)
+      VALUES ('delete', old.id, old.feature_key, old.title, old.description, old.domain, old.subdomain);
+      INSERT INTO ${t("sentinel_fts")}(rowid, feature_key, title, description, domain, subdomain)
+      VALUES (new.id, new.feature_key, new.title, new.description, new.domain, new.subdomain);
+    END;
+  `);
+}
+
+// src/feature-cost-attribution.ts
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve8 } from "path";
+
+// src/sentinel-db.ts
+init_config();
+init_memory_db();
+var PROJECT_ROOT = getProjectRoot();
+function parsePortalScope(raw) {
+  if (!raw) return [];
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function toFeature(row) {
+  return {
+    id: row.id,
+    feature_key: row.feature_key,
+    domain: row.domain,
+    subdomain: row.subdomain || null,
+    title: row.title,
+    description: row.description || null,
+    status: row.status,
+    priority: row.priority,
+    portal_scope: parsePortalScope(row.portal_scope),
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    removed_at: row.removed_at || null,
+    removed_reason: row.removed_reason || null
+  };
+}
+function getFeaturesByFile(db, filePath) {
+  const rows = db.prepare(`
+    SELECT DISTINCT s.* FROM ${t("sentinel")} s
+    JOIN ${t("sentinel_components")} c ON c.feature_id = s.id
+    WHERE c.component_file = ?
+    ORDER BY s.feature_key
+    LIMIT 1000
+  `).all(filePath);
+  return rows.map(toFeature);
+}
+
+// src/feature-cost-attribution.ts
+var UNATTRIBUTED_FEATURE = "(no registered feature)";
+var MAX_SESSION_FILES = 2e4;
+function sessionFileTouches(memDb, sessionId, projectRoot) {
+  const rows = memDb.prepare(
+    `SELECT j.value AS file, COUNT(*) AS n
+       FROM tool_call_details t, json_each(t.files_involved) j
+      WHERE t.session_id = ? AND json_valid(t.files_involved)
+        AND json_type(t.files_involved) = 'array' AND j.type = 'text' AND j.value <> ''
+      GROUP BY j.value
+      LIMIT ?`
+  ).all(sessionId, MAX_SESSION_FILES + 1);
+  if (rows.length > MAX_SESSION_FILES) {
+    throw new Error(`session ${sessionId} touched more than ${MAX_SESSION_FILES} distinct files; not allocating a truncated list`);
+  }
+  const touches = /* @__PURE__ */ new Map();
+  for (const { file, n } of rows) {
+    const abs = isAbsolute2(file) ? file : resolve8(projectRoot, file);
+    const rel = relative2(projectRoot, abs);
+    const key = rel.startsWith("..") || isAbsolute2(rel) ? abs : rel;
+    touches.set(key, (touches.get(key) ?? 0) + Number(n));
+  }
+  return touches;
+}
+function allocateSessionCost(touches, featuresOf, totals) {
+  const units = /* @__PURE__ */ new Map();
+  let all = 0;
+  for (const [file, n] of touches) {
+    all += n;
+    const features = [...new Set(featuresOf(file))];
+    if (features.length === 0) {
+      units.set(UNATTRIBUTED_FEATURE, (units.get(UNATTRIBUTED_FEATURE) ?? 0) + n);
+    } else {
+      for (const k of features) units.set(k, (units.get(k) ?? 0) + n / features.length);
+    }
+  }
+  if (all === 0) return [{ featureKey: UNATTRIBUTED_FEATURE, share: 1, tokens: totals.tokens, costUsd: totals.costUsd }];
+  return [...units].map(([featureKey, u]) => ({
+    featureKey,
+    share: u / all,
+    tokens: Math.round(totals.tokens * u / all),
+    costUsd: totals.costUsd * u / all
+  })).sort((a, b) => b.costUsd - a.costUsd || a.featureKey.localeCompare(b.featureKey));
+}
+function attributeSessionCost(memDb, dataDb, sessionId, projectRoot) {
+  const cost = memDb.prepare(
+    `SELECT total_tokens, estimated_cost_usd, cost_status FROM session_costs WHERE session_id = ?`
+  ).get(sessionId);
+  const replace = memDb.transaction((rows2) => {
+    memDb.prepare("DELETE FROM feature_costs WHERE session_id = ?").run(sessionId);
+    const ins = memDb.prepare(
+      "INSERT INTO feature_costs (feature_key, session_id, tokens_used, estimated_cost_usd) VALUES (?, ?, ?, ?)"
+    );
+    for (const r2 of rows2) ins.run(r2.featureKey, sessionId, r2.tokens, r2.costUsd);
+  });
+  if (!cost || cost.cost_status === "unknown") {
+    replace([]);
+    return [];
+  }
+  const touches = sessionFileTouches(memDb, sessionId, projectRoot);
+  const featuresOf = (file) => {
+    const keys = getFeaturesByFile(dataDb, file).map((f) => f.feature_key);
+    if (!isAbsolute2(file)) keys.push(...getFeaturesByFile(dataDb, resolve8(projectRoot, file)).map((f) => f.feature_key));
+    return keys;
+  };
+  const rows = allocateSessionCost(touches, featuresOf, { tokens: cost.total_tokens, costUsd: cost.estimated_cost_usd });
+  replace(rows);
+  return rows;
+}
+
+// src/cost-reprice.ts
+init_hook_failure_signal();
+init_memory_db();
 
 // src/cost-tracker.ts
 init_config();
@@ -6472,8 +6988,8 @@ function tokenCounts(u) {
 }
 function priceResponse(price, u) {
   if (!price) return null;
-  const t = tokenCounts(u);
-  const prompt = t.input + t.cacheRead + t.cacheWrite5m + t.cacheWrite1h;
+  const t2 = tokenCounts(u);
+  const prompt = t2.input + t2.cacheRead + t2.cacheWrite5m + t2.cacheWrite1h;
   let rates = price.longPrompt && prompt > price.longPrompt.overTokens ? price.longPrompt.rates : price;
   if (u.speed === "fast" && price.fast) {
     const k = price.fast.input / rates.input;
@@ -6486,7 +7002,7 @@ function priceResponse(price, u) {
     };
   }
   const geo = u.inference_geo === "us" ? price.usGeoMultiplier ?? 1 : 1;
-  const dollars = t.input * rates.input + t.output * rates.output + t.cacheRead * rates.cacheRead + t.cacheWrite5m * rates.cacheWrite5m + t.cacheWrite1h * rates.cacheWrite1h;
+  const dollars = t2.input * rates.input + t2.output * rates.output + t2.cacheRead * rates.cacheRead + t2.cacheWrite5m * rates.cacheWrite5m + t2.cacheWrite1h * rates.cacheWrite1h;
   return dollars / 1e6 * geo;
 }
 
@@ -6520,12 +7036,12 @@ function costTranscriptEntries(entries, opts = {}) {
       out.lastMessageId = msg.id;
     }
     const usage = msg.usage;
-    const t = tokenCounts(usage);
-    if (t.input + t.output + t.cacheRead + t.cacheWrite5m + t.cacheWrite1h === 0) continue;
-    out.inputTokens += t.input;
-    out.outputTokens += t.output;
-    out.cacheReadTokens += t.cacheRead;
-    out.cacheWriteTokens += t.cacheWrite5m + t.cacheWrite1h;
+    const t2 = tokenCounts(usage);
+    if (t2.input + t2.output + t2.cacheRead + t2.cacheWrite5m + t2.cacheWrite1h === 0) continue;
+    out.inputTokens += t2.input;
+    out.outputTokens += t2.output;
+    out.cacheReadTokens += t2.cacheRead;
+    out.cacheWriteTokens += t2.cacheWrite5m + t2.cacheWrite1h;
     const dollars = priceResponse(resolveModelPrice(msg.model, overrides), usage);
     if (dollars === null) {
       out.unpricedResponses++;
@@ -6605,7 +7121,7 @@ function markSessionCostUnknown(db, sessionId) {
 var cursorKey = (sid) => `cost_processed_line:${sid}`;
 var lastIdKey = (sid) => `cost_last_message:${sid}`;
 var sessionLeaseKey = (sid) => `session_end_lease:${sid}`;
-async function updateSessionCost(db, sessionId, transcriptPath) {
+async function updateSessionCost(db, sessionId, transcriptPath, attribute = attributeFeatureCosts) {
   const row = db.prepare("SELECT pricing_version FROM session_costs WHERE session_id = ?").get(sessionId);
   const cursor = Number(getMemoryMeta(db, cursorKey(sessionId)) ?? "0") || 0;
   const incremental = row?.pricing_version === PRICING_VERSION && cursor > 0;
@@ -6617,11 +7133,23 @@ async function updateSessionCost(db, sessionId, transcriptPath) {
   storeSessionCost(db, sessionId, slice, incremental ? "add" : "replace");
   setMemoryMeta(db, cursorKey(sessionId), String(totalLines));
   if (slice.lastMessageId) setMemoryMeta(db, lastIdKey(sessionId), slice.lastMessageId);
+  attribute(db, sessionId);
 }
+var attributeFeatureCosts = (db, sessionId) => {
+  let dataDb = null;
+  try {
+    dataDb = getDataDb();
+    attributeSessionCost(db, dataDb, sessionId, getProjectRoot());
+  } catch (err) {
+    recordHookFailure("cost:feature-attribution", err, { sessionId });
+  } finally {
+    dataDb?.close();
+  }
+};
 function defaultTranscriptFor(sessionId) {
   if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) return null;
-  const path = join11(dirname13(getResolvedPaths().memoryDir), `${sessionId}.jsonl`);
-  return existsSync16(path) ? path : null;
+  const path = join12(dirname14(getResolvedPaths().memoryDir), `${sessionId}.jsonl`);
+  return existsSync17(path) ? path : null;
 }
 async function repriceStoredSessions(db, opts = {}) {
   const deadlineAt = opts.deadlineAt ?? Infinity;
@@ -6645,10 +7173,11 @@ async function repriceStoredSessions(db, opts = {}) {
       try {
         const path = find(sid);
         if (path) {
-          await updateSessionCost(db, sid, path);
+          await updateSessionCost(db, sid, path, opts.attribute);
           out.repriced++;
         } else {
           markSessionCostUnknown(db, sid);
+          (opts.attribute ?? attributeFeatureCosts)(db, sid);
           out.markedUnknown++;
         }
       } catch (err) {
@@ -6781,8 +7310,8 @@ init_memory_vector();
 function temporalPredicate(asOf, includeSuperseded, prefix) {
   const c = (name) => `${prefix}${name}`;
   if (asOf != null && Number.isFinite(asOf)) {
-    const t = Math.floor(Number(asOf) / 1e3);
-    return `${c("ingested_at_epoch")} <= ${t} AND (${c("expired_at_epoch")} IS NULL OR ${c("expired_at_epoch")} > ${t}) AND ${c("valid_from_epoch")} <= ${t} AND (${c("valid_to_epoch")} IS NULL OR ${c("valid_to_epoch")} > ${t})`;
+    const t2 = Math.floor(Number(asOf) / 1e3);
+    return `${c("ingested_at_epoch")} <= ${t2} AND (${c("expired_at_epoch")} IS NULL OR ${c("expired_at_epoch")} > ${t2}) AND ${c("valid_from_epoch")} <= ${t2} AND (${c("valid_to_epoch")} IS NULL OR ${c("valid_to_epoch")} > ${t2})`;
   }
   if (!includeSuperseded) {
     return `${c("expired_at_epoch")} IS NULL`;
@@ -6878,7 +7407,7 @@ function collectObservations(memDb, queryText, pool, nowMs, loadVec, modelId, di
 }
 function collectLikeSource(db, source, cfg, queryText, pool, nowMs) {
   const map = /* @__PURE__ */ new Map();
-  const tokens = queryText.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 3).slice(0, 8);
+  const tokens = queryText.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t2) => t2.length >= 3).slice(0, 8);
   const ageExpr = (created) => {
     const ms = cfg.createdIsEpoch ? Number(created) * 1e3 : Date.parse(String(created));
     return Number.isFinite(ms) ? ageDaysFrom(ms, nowMs) : 0;
@@ -6886,7 +7415,7 @@ function collectLikeSource(db, source, cfg, queryText, pool, nowMs) {
   if (tokens.length > 0) {
     const likeClause = cfg.searchCols.map((col) => tokens.map(() => `${col} LIKE ?`).join(" OR ")).join(" OR ");
     const params = [];
-    for (const _col of cfg.searchCols) for (const t of tokens) params.push(`%${t}%`);
+    for (const _col of cfg.searchCols) for (const t2 of tokens) params.push(`%${t2}%`);
     try {
       const rows = db.prepare(
         `SELECT ${cfg.idCol} AS id, ${cfg.titleExpr} AS title,
@@ -7304,8 +7833,8 @@ ${d.decision}`.trim(),
 // src/memory-consolidate.ts
 init_memory_db();
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync17, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync15, writeFileSync as writeFileSync10 } from "fs";
+import { join as join13 } from "path";
 init_memory_embedder();
 init_memory_vector();
 var LEASE_KEY = "consolidate_lease";
@@ -7466,7 +7995,7 @@ ${r2.detail ?? ""}`.trim());
     }
     clusters.push(cluster);
   }
-  const candidateDir = join12(projectRoot, ".massu", "rule-candidates");
+  const candidateDir = join13(projectRoot, ".massu", "rule-candidates");
   let promoted = 0;
   for (const cluster of clusters) {
     const occurrences = cluster.reduce((n, c) => n + (c.recurrence_count || 1), 0);
@@ -7479,13 +8008,13 @@ ${r2.detail ?? ""}`.trim());
 ${representative.detail}` : ""}`;
     const clusterKey = cluster.map((c) => c.title.toLowerCase().replace(/\s+/g, " ").trim()).sort().join("|");
     const promptHash = createHash6("sha256").update(clusterKey).digest("hex").slice(0, 16);
-    const candidatePath = join12(candidateDir, `${promptHash}.json`);
-    if (existsSync17(candidatePath)) continue;
+    const candidatePath = join13(candidateDir, `${promptHash}.json`);
+    if (existsSync18(candidatePath)) continue;
     if (dryRun) {
       promoted++;
       continue;
     }
-    mkdirSync14(candidateDir, { recursive: true });
+    mkdirSync15(candidateDir, { recursive: true });
     writeFileSync10(
       candidatePath,
       JSON.stringify(
@@ -7644,12 +8173,17 @@ async function runConsolidation(db, opts = {}) {
 init_hook_failure_signal();
 
 // src/hooks/lib/is-direct-invocation.ts
-import { pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 function isDirectInvocation(moduleUrl) {
   const entry = process.argv[1];
   if (!entry) return false;
   try {
-    return moduleUrl === pathToFileURL(entry).href;
+    if (moduleUrl === pathToFileURL(entry).href) return true;
+  } catch {
+    return false;
+  }
+  try {
+    return isSameRealPath(fileURLToPath2(moduleUrl), entry);
   } catch {
     return false;
   }
@@ -8084,14 +8618,14 @@ function extractFilesFromToolCall(toolName, input) {
   return [];
 }
 function readStdin() {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve8(data));
-    setTimeout(() => resolve8(data), 5e3);
+    process.stdin.on("end", () => resolve9(data));
+    setTimeout(() => resolve9(data), 5e3);
   });
 }
 if (isDirectInvocation(import.meta.url)) {