memorix 1.6.0 → 1.6.1

package/dist/cli/index.js

@@ -2,7 +2,18 @@
 import {spawnSync as __ms} from "node:child_process";
 import {fileURLToPath as __fu} from "node:url";
 if(!process.env.__MEMORIX_HEAP){process.env.__MEMORIX_HEAP="1";
-let r=__ms(process.execPath,["--max-old-space-size=4096",__fu(import.meta.url),...process.argv.slice(2)],{stdio:"inherit",env:process.env,windowsHide:true});
+const __args=process.argv.slice(2);
+let __cmd;
+for(let __i=0;__i<__args.length;__i++){
+const __a=__args[__i];
+if(__a==="--")break;
+if(__a.startsWith("-")){if(!__a.includes("=")&&__args[__i+1]&&!__args[__i+1].startsWith("-"))__i++;continue;}
+__cmd=__a;break;}
+const __fallback=__cmd==="hook"?512:4096;
+const __raw=__cmd==="hook"?process.env.MEMORIX_HOOK_HEAP_MB:process.env.MEMORIX_HEAP_MB;
+const __n=Number(__raw);
+const __heap=(Number.isFinite(__n)&&__n>=64&&__n<=16384)?String(Math.floor(__n)):String(__fallback);
+let r=__ms(process.execPath,["--max-old-space-size="+__heap,__fu(import.meta.url),...process.argv.slice(2)],{stdio:"inherit",env:process.env,windowsHide:true});
 process.exit(r.status??1);}
 import {createRequire as __memorix_cjsRequire} from "module";
 const require = __memorix_cjsRequire(import.meta.url);
@@ -3221,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.6.0" : pkg.version;
+  return true ? "1.6.1" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -3231,7 +3242,7 @@ var init_version = __esm({
 });
 
 // src/cli/invocation.ts
-import { existsSync as existsSync2, statSync } from "fs";
+import { existsSync as existsSync2, realpathSync, statSync } from "fs";
 import { resolve as resolve2 } from "path";
 function readOption(argument) {
   const equals = argument.indexOf("=");
@@ -3261,10 +3272,11 @@ function normalizeCliInvocation(argv2 = process.argv) {
     if (inlineValue === void 0) index += 1;
   }
   if (invocation.projectRoot) {
-    const projectRoot = resolve2(invocation.projectRoot);
-    if (!existsSync2(projectRoot) || !statSync(projectRoot).isDirectory()) {
-      throw new Error(`CLI project directory does not exist: ${projectRoot}`);
+    const resolvedProjectRoot = resolve2(invocation.projectRoot);
+    if (!existsSync2(resolvedProjectRoot) || !statSync(resolvedProjectRoot).isDirectory()) {
+      throw new Error(`CLI project directory does not exist: ${resolvedProjectRoot}`);
     }
+    const projectRoot = realpathSync(resolvedProjectRoot);
     process.chdir(projectRoot);
     process.env.MEMORIX_CLI_PROJECT_ROOT = projectRoot;
     invocation.projectRoot = projectRoot;
@@ -22778,6 +22790,7 @@ __export(provider_exports, {
   MAX_INLINE_EMBEDDING_BYTES: () => MAX_INLINE_EMBEDDING_BYTES,
   UnsupportedEmbeddingModalityError: () => UnsupportedEmbeddingModalityError,
   getEmbeddingProvider: () => getEmbeddingProvider,
+  getEmbeddingRuntimeHealth: () => getEmbeddingRuntimeHealth,
   isEmbeddingExplicitlyDisabled: () => isEmbeddingExplicitlyDisabled,
   isVectorSearchAvailable: () => isVectorSearchAvailable,
   resetProvider: () => resetProvider,
@@ -22885,13 +22898,36 @@ function isTemporaryEmbeddingFailure(error40) {
   if (!(error40 instanceof Error)) return false;
   return /embedding api error \(401\)/i.test(error40.message) || /invalid_api_key/i.test(error40.message) || /incorrect api key/i.test(error40.message) || /unauthorized/i.test(error40.message) || /embedding api timeout/i.test(error40.message) || /embedding api error \((402|429|5\d\d)\)/i.test(error40.message) || /quota exceeded/i.test(error40.message) || /account balance/i.test(error40.message) || /fetch failed/i.test(error40.message) || /econnreset/i.test(error40.message) || /econnrefused/i.test(error40.message) || /temporarily unavailable/i.test(error40.message);
 }
+function classifyEmbeddingFailure(error40) {
+  const message = error40 instanceof Error ? error40.message : String(error40);
+  if (/embedding api error \(401\)|invalid_api_key|incorrect api key|unauthorized/i.test(message)) {
+    return "authorization";
+  }
+  if (/embedding api error \(402\)|quota exceeded|account balance/i.test(message)) {
+    return "billing";
+  }
+  if (/embedding api timeout|abort/i.test(message)) {
+    return "timeout";
+  }
+  return "upstream";
+}
 function markTemporaryFailure(reason) {
   provider = null;
   initPromise = null;
   lastInitWasTemporaryFailure = true;
   lastFailureTimestamp = Date.now();
+  lastEmbeddingFailure = {
+    kind: classifyEmbeddingFailure(reason),
+    occurredAt: lastFailureTimestamp
+  };
   const message = reason instanceof Error ? reason.message : String(reason);
-  warnOnce(`[memorix] Embedding provider temporarily unavailable at runtime: ${message}`);
+  warnOnce(`[memorix] Embedding provider unavailable at runtime: ${message}`);
+}
+function markProviderReady(candidate2) {
+  provider = wrapProvider(candidate2);
+  lastInitWasTemporaryFailure = false;
+  lastEmbeddingFailure = null;
+  return provider;
 }
 async function createFastEmbedProvider() {
   try {
@@ -23007,35 +23043,35 @@ async function getEmbeddingProvider(options = {}) {
     if (mode === "fastembed") {
       const initialized = await createFastEmbedProvider();
       if (!initialized) return null;
-      provider = wrapProvider(initialized);
+      provider = markProviderReady(initialized);
       warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
       return provider;
     }
     if (mode === "transformers") {
       const initialized = await createTransformersProvider();
       if (!initialized) return null;
-      provider = wrapProvider(initialized);
+      provider = markProviderReady(initialized);
       warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
       return provider;
     }
     if (mode === "api") {
       const initialized = await createAPIProvider(options);
       if (!initialized) return null;
-      provider = wrapProvider(initialized);
+      provider = markProviderReady(initialized);
       warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
       return provider;
     }
     if (hasAPIEmbeddingConfig()) {
       const initialized = await createAPIProvider(options);
       if (initialized) {
-        provider = wrapProvider(initialized);
+        provider = markProviderReady(initialized);
         warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
         return provider;
       }
     }
     const localFallback = await createLocalFallbackProvider();
     if (localFallback) {
-      provider = wrapProvider(localFallback);
+      provider = markProviderReady(localFallback);
       warnOnce(`[memorix] Embedding provider: ${provider.name} (${provider.dimensions}d)`);
       return provider;
     }
@@ -23057,6 +23093,27 @@ async function isVectorSearchAvailable() {
   const p3 = await getEmbeddingProvider();
   return p3 !== null;
 }
+function getEmbeddingRuntimeHealth() {
+  const mode = getEmbeddingMode2();
+  if (mode === "off") return { status: "disabled" };
+  if (lastInitWasTemporaryFailure && lastEmbeddingFailure) {
+    return {
+      status: "degraded",
+      failure: {
+        kind: lastEmbeddingFailure.kind,
+        occurredAt: new Date(lastEmbeddingFailure.occurredAt).toISOString(),
+        retryAfterMs: Math.max(0, RETRY_COOLDOWN_MS - (Date.now() - lastEmbeddingFailure.occurredAt))
+      }
+    };
+  }
+  if (provider) {
+    return {
+      status: "ready",
+      provider: { name: provider.name, dimensions: provider.dimensions }
+    };
+  }
+  return { status: "uninitialized" };
+}
 function isEmbeddingExplicitlyDisabled() {
   return getEmbeddingMode2() === "off";
 }
@@ -23065,10 +23122,11 @@ function resetProvider() {
   initPromise = null;
   lastInitWasTemporaryFailure = false;
   lastFailureTimestamp = 0;
+  lastEmbeddingFailure = null;
   lastEmbeddingWarning = "";
   lastEmbeddingWarningAt = 0;
 }
-var EmbeddingInputError, UnsupportedEmbeddingModalityError, MAX_INLINE_EMBEDDING_BYTES, provider, initPromise, lastInitWasTemporaryFailure, lastEmbeddingWarning, lastEmbeddingWarningAt, WARNING_COOLDOWN_MS, RETRY_COOLDOWN_MS, lastFailureTimestamp;
+var EmbeddingInputError, UnsupportedEmbeddingModalityError, MAX_INLINE_EMBEDDING_BYTES, provider, initPromise, lastInitWasTemporaryFailure, lastEmbeddingFailure, lastEmbeddingWarning, lastEmbeddingWarningAt, WARNING_COOLDOWN_MS, RETRY_COOLDOWN_MS, lastFailureTimestamp;
 var init_provider = __esm({
   "src/embedding/provider.ts"() {
     "use strict";
@@ -23093,6 +23151,7 @@ var init_provider = __esm({
     provider = null;
     initPromise = null;
     lastInitWasTemporaryFailure = false;
+    lastEmbeddingFailure = null;
     lastEmbeddingWarning = "";
     lastEmbeddingWarningAt = 0;
     WARNING_COOLDOWN_MS = 3e4;
@@ -259024,7 +259083,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.6.0" : "1.0.1"
+    version: true ? "1.6.1" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {
@@ -265892,6 +265951,7 @@ var init_control_plane_maintenance = __esm({
 var serve_http_exports = {};
 __export(serve_http_exports, {
   DEFAULT_SESSION_TIMEOUT_MS: () => DEFAULT_SESSION_TIMEOUT_MS,
+  EXPIRED_SESSION_TTL_MS: () => EXPIRED_SESSION_TTL_MS,
   _testing: () => _testing2,
   default: () => serve_http_default,
   parseSessionTimeoutMs: () => parseSessionTimeoutMs,
@@ -265901,7 +265961,7 @@ function parseSessionTimeoutMs(raw) {
   const value = raw?.trim();
   if (!value) return DEFAULT_SESSION_TIMEOUT_MS;
   const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SESSION_TIMEOUT_MS;
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_SESSION_TIMEOUT_MS;
   return Math.floor(parsed);
 }
 function resolveServeHttpDefaults(argsPort, configured) {
@@ -265913,7 +265973,7 @@ function resolveServeHttpDefaults(argsPort, configured) {
   const transportNotice = configured.transport === "stdio" ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).' : void 0;
   return { port, transportNotice };
 }
-var DEFAULT_SESSION_TIMEOUT_MS, serve_http_default, _testing2;
+var DEFAULT_SESSION_TIMEOUT_MS, EXPIRED_SESSION_TTL_MS, serve_http_default, _testing2;
 var init_serve_http = __esm({
   "src/cli/commands/serve-http.ts"() {
     "use strict";
@@ -265925,7 +265985,8 @@ var init_serve_http = __esm({
     init_visibility();
     init_port();
     init_mcp_root_path();
-    DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+    DEFAULT_SESSION_TIMEOUT_MS = 12 * 60 * 60 * 1e3;
+    EXPIRED_SESSION_TTL_MS = 10 * 60 * 1e3;
     serve_http_default = defineCommand({
       meta: {
         name: "serve-http",
@@ -265984,7 +266045,9 @@ var init_serve_http = __esm({
         console.error(`[memorix] HTTP transport starting on ${host}:${port}`);
         console.error(`[memorix] Project root: ${projectRoot}`);
         const sessionTimeoutMs = parseSessionTimeoutMs(process.env.MEMORIX_SESSION_TIMEOUT_MS);
-        console.error(`[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 6e4)}min (${sessionTimeoutMs}ms)`);
+        console.error(
+          sessionTimeoutMs === 0 ? "[memorix] HTTP session idle timeout: disabled" : `[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 6e4)}min (${sessionTimeoutMs}ms)`
+        );
         const teamStoreCache = /* @__PURE__ */ new Map();
         const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
         async function getTeamStore2(dataDir) {
@@ -266001,6 +266064,7 @@ var init_serve_http = __esm({
         const sharedTeamStore = await getTeamStore2(teamDataDir);
         const sessions = /* @__PURE__ */ new Map();
         const sessionLastActivity = /* @__PURE__ */ new Map();
+        const expiredSessions = /* @__PURE__ */ new Map();
         let suppressedProbeCount = 0;
         let lastProbeSummaryTime = Date.now();
         const PROBE_SUMMARY_INTERVAL_MS = 6e4;
@@ -266013,6 +266077,26 @@ var init_serve_http = __esm({
             lastProbeSummaryTime = Date.now();
           }
         }
+        function forgetExpiredSessions(now3 = Date.now()) {
+          for (const [sessionId, expiresAt] of expiredSessions) {
+            if (expiresAt <= now3) expiredSessions.delete(sessionId);
+          }
+        }
+        function sendUnknownSession(res, sessionId, jsonRpc = false) {
+          const expired = Boolean(sessionId && expiredSessions.has(sessionId));
+          const message = expired ? "MCP session expired after inactivity. Initialize a new session and retry the request." : "MCP session not found. Initialize a new session and retry the request.";
+          if (jsonRpc) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              jsonrpc: "2.0",
+              error: { code: -32001, message },
+              id: null
+            }));
+            return;
+          }
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end(message);
+        }
         function parseBody(req) {
           return new Promise((resolve6, reject) => {
             const chunks = [];
@@ -266129,6 +266213,10 @@ var init_serve_http = __esm({
             await sessions.get(sessionId).transport.handleRequest(req, res, body);
             return;
           }
+          if (sessionId) {
+            sendUnknownSession(res, sessionId, true);
+            return;
+          }
           if (!sessionId && isInitializeRequest2(body)) {
             let createdState = null;
             const transport = new StreamableHTTPServerTransport2({
@@ -266227,8 +266315,12 @@ var init_serve_http = __esm({
         async function handleGet(req, res) {
           const sessionId = req.headers["mcp-session-id"];
           if (!sessionId || !sessions.has(sessionId)) {
-            res.writeHead(400, { "Content-Type": "text/plain" });
-            res.end("Invalid or missing session ID");
+            if (!sessionId) {
+              res.writeHead(400, { "Content-Type": "text/plain" });
+              res.end("Missing MCP session ID");
+              return;
+            }
+            sendUnknownSession(res, sessionId);
             return;
           }
           await sessions.get(sessionId).transport.handleRequest(req, res);
@@ -266236,8 +266328,12 @@ var init_serve_http = __esm({
         async function handleDelete(req, res) {
           const sessionId = req.headers["mcp-session-id"];
           if (!sessionId || !sessions.has(sessionId)) {
-            res.writeHead(400, { "Content-Type": "text/plain" });
-            res.end("Invalid or missing session ID");
+            if (!sessionId) {
+              res.writeHead(400, { "Content-Type": "text/plain" });
+              res.end("Missing MCP session ID");
+              return;
+            }
+            sendUnknownSession(res, sessionId);
             return;
           }
           await sessions.get(sessionId).transport.handleRequest(req, res);
@@ -266986,13 +267082,15 @@ var init_serve_http = __esm({
           }
           const url2 = new URL(req.url || "/", `http://localhost:${port}`);
           if (url2.pathname === "/health") {
+            const { getEmbeddingRuntimeHealth: getEmbeddingRuntimeHealth2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
               status: "ok",
               mode: "control-plane",
               port,
               uptime: Math.round(process.uptime()),
-              pid: process.pid
+              pid: process.pid,
+              embedding: getEmbeddingRuntimeHealth2()
             }));
             return;
           }
@@ -267050,6 +267148,8 @@ var init_serve_http = __esm({
           }
           await serveDashStatic(req, res);
         });
+        httpServer.keepAliveTimeout = 6e4;
+        httpServer.headersTimeout = 65e3;
         httpServer.listen(port, host, () => {
           try {
             const memorixDir = (process.env.HOME || process.env.USERPROFILE || "").replace(/\\/g, "/") + "/.memorix";
@@ -267073,10 +267173,13 @@ var init_serve_http = __esm({
         const gcInterval = setInterval(() => {
           maybeProbeSummary();
           const now3 = Date.now();
+          forgetExpiredSessions(now3);
+          if (SESSION_TIMEOUT_MS === 0) return;
           for (const [sid, state] of sessions) {
             const lastActive = sessionLastActivity.get(sid) ?? 0;
             if (now3 - lastActive > SESSION_TIMEOUT_MS) {
               console.error(`[memorix] Session ${sid.slice(0, 8)}\u2026 timed out (idle ${Math.round((now3 - lastActive) / 6e4)}min), closing`);
+              expiredSessions.set(sid, now3 + EXPIRED_SESSION_TTL_MS);
               state.transport.close().catch(() => {
               });
               sessions.delete(sid);
@@ -268715,6 +268818,144 @@ var init_pattern_detector = __esm({
   }
 });
 
+// src/hooks/lifecycle.ts
+var lifecycle_exports2 = {};
+__export(lifecycle_exports2, {
+  DEFAULT_HOOK_STDIN_TIMEOUT_MS: () => DEFAULT_HOOK_STDIN_TIMEOUT_MS,
+  DEFAULT_HOOK_TIMEOUT_MS: () => DEFAULT_HOOK_TIMEOUT_MS,
+  MAX_HOOK_STDIN_TIMEOUT_MS: () => MAX_HOOK_STDIN_TIMEOUT_MS,
+  MAX_HOOK_TIMEOUT_MS: () => MAX_HOOK_TIMEOUT_MS,
+  MIN_HOOK_STDIN_TIMEOUT_MS: () => MIN_HOOK_STDIN_TIMEOUT_MS,
+  MIN_HOOK_TIMEOUT_MS: () => MIN_HOOK_TIMEOUT_MS,
+  hookObservationRuntimeOptions: () => hookObservationRuntimeOptions,
+  readHookStdin: () => readHookStdin,
+  resolveHookStdinTimeoutMs: () => resolveHookStdinTimeoutMs,
+  resolveHookTimeoutMs: () => resolveHookTimeoutMs,
+  runHookWithDeadline: () => runHookWithDeadline
+});
+function parseBoundedMs(raw, fallback, min, max) {
+  const value = raw?.trim();
+  if (!value) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(parsed)));
+}
+function resolveHookTimeoutMs(env3 = process.env) {
+  return parseBoundedMs(
+    env3.MEMORIX_HOOK_TIMEOUT_MS,
+    DEFAULT_HOOK_TIMEOUT_MS,
+    MIN_HOOK_TIMEOUT_MS,
+    MAX_HOOK_TIMEOUT_MS
+  );
+}
+function resolveHookStdinTimeoutMs(env3 = process.env) {
+  return parseBoundedMs(
+    env3.MEMORIX_HOOK_STDIN_TIMEOUT_MS,
+    DEFAULT_HOOK_STDIN_TIMEOUT_MS,
+    MIN_HOOK_STDIN_TIMEOUT_MS,
+    MAX_HOOK_STDIN_TIMEOUT_MS
+  );
+}
+function hookObservationRuntimeOptions(projectRoot) {
+  return {
+    embeddingWriteMode: "deferred",
+    projectRoot
+  };
+}
+async function readHookStdin(stdin2, timeoutMs) {
+  return new Promise((resolve6) => {
+    const chunks = [];
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      stdin2.removeListener("data", onData);
+      stdin2.removeListener("end", finish);
+      stdin2.removeListener("error", finish);
+      stdin2.pause?.();
+      if (!stdin2.isTTY) {
+        stdin2.destroy?.();
+      } else {
+        stdin2.unref?.();
+      }
+      resolve6(Buffer.concat(chunks).toString("utf-8").trim());
+    };
+    const onData = (chunk) => {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    stdin2.on("data", onData);
+    stdin2.on("end", finish);
+    stdin2.on("error", finish);
+  });
+}
+function writeContinue(stdout2) {
+  try {
+    stdout2.write(JSON.stringify({ continue: true }));
+  } catch {
+  }
+}
+async function runHookWithDeadline(options) {
+  const stdout2 = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const exit = options.exit ?? ((code) => {
+    process.exit(code);
+  });
+  await new Promise((resolve6) => {
+    let finished2 = false;
+    const settle = () => {
+      if (finished2) return;
+      finished2 = true;
+      clearTimeout(timer);
+      resolve6();
+    };
+    const timer = setTimeout(() => {
+      if (finished2) return;
+      try {
+        stderr.write(`[memorix] hook timed out after ${options.timeoutMs}ms
+`);
+      } catch {
+      }
+      writeContinue(stdout2);
+      exit(0);
+      settle();
+    }, options.timeoutMs);
+    options.run().then(
+      () => {
+        if (finished2) return;
+        exit(0);
+        settle();
+      },
+      (error40) => {
+        if (finished2) return;
+        try {
+          const message = error40 instanceof Error ? error40.message : String(error40);
+          stderr.write(`[memorix] hook failed: ${message}
+`);
+        } catch {
+        }
+        writeContinue(stdout2);
+        exit(0);
+        settle();
+      }
+    );
+  });
+}
+var DEFAULT_HOOK_TIMEOUT_MS, MIN_HOOK_TIMEOUT_MS, MAX_HOOK_TIMEOUT_MS, DEFAULT_HOOK_STDIN_TIMEOUT_MS, MIN_HOOK_STDIN_TIMEOUT_MS, MAX_HOOK_STDIN_TIMEOUT_MS;
+var init_lifecycle2 = __esm({
+  "src/hooks/lifecycle.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_HOOK_TIMEOUT_MS = 2e4;
+    MIN_HOOK_TIMEOUT_MS = 1e3;
+    MAX_HOOK_TIMEOUT_MS = 12e4;
+    DEFAULT_HOOK_STDIN_TIMEOUT_MS = 3e3;
+    MIN_HOOK_STDIN_TIMEOUT_MS = 100;
+    MAX_HOOK_STDIN_TIMEOUT_MS = 3e4;
+  }
+});
+
 // src/hooks/handler.ts
 var handler_exports = {};
 __export(handler_exports, {
@@ -269194,26 +269435,7 @@ function formatHookOutput(agent, rawEventName, output) {
   return finalOutput;
 }
 async function runHook(agentOverride, eventOverride) {
-  const rawInput = await new Promise((resolve6) => {
-    const chunks = [];
-    const finish = () => resolve6(Buffer.concat(chunks).toString("utf-8").trim());
-    const timer = setTimeout(() => {
-      process.stdin.removeAllListeners("data");
-      process.stdin.removeAllListeners("end");
-      finish();
-    }, 3e3);
-    process.stdin.on("data", (chunk) => {
-      chunks.push(chunk);
-    });
-    process.stdin.on("end", () => {
-      clearTimeout(timer);
-      finish();
-    });
-    process.stdin.on("error", () => {
-      clearTimeout(timer);
-      finish();
-    });
-  });
+  const rawInput = await readHookStdin(process.stdin, resolveHookStdinTimeoutMs());
   if (!rawInput) {
     process.stdout.write(JSON.stringify({ continue: true }));
     return;
@@ -269263,7 +269485,7 @@ async function runHook(agentOverride, eventOverride) {
       await initObservationStore2(dataDir);
       await initMSStore(dataDir);
       await initSessStore(dataDir);
-      await initObservations2(dataDir);
+      await initObservations2(dataDir, hookObservationRuntimeOptions(rawProject.rootPath));
       await storeObservation2({ ...observation, projectId, sourceDetail: "hook" });
     } catch (storeErr) {
       console.error("[memorix] hook store failed:", storeErr?.message ?? storeErr);
@@ -269309,6 +269531,7 @@ var init_handler = __esm({
     init_normalizer();
     init_pattern_detector();
     init_significance_filter();
+    init_lifecycle2();
     TYPE_EMOJI2 = {
       "gotcha": "[GOTCHA]",
       "decision": "[DECISION]",
@@ -269365,7 +269588,11 @@ var init_hook = __esm({
       },
       run: async ({ args }) => {
         const { runHook: runHook2 } = await Promise.resolve().then(() => (init_handler(), handler_exports));
-        await runHook2(args.agent, args.event);
+        const { resolveHookTimeoutMs: resolveHookTimeoutMs2, runHookWithDeadline: runHookWithDeadline2 } = await Promise.resolve().then(() => (init_lifecycle2(), lifecycle_exports2));
+        await runHookWithDeadline2({
+          timeoutMs: resolveHookTimeoutMs2(),
+          run: () => runHook2(args.agent, args.event)
+        });
       }
     });
   }
@@ -272131,7 +272358,7 @@ __export(agent_integrations_exports, {
   repairAgentIntegrations: () => repairAgentIntegrations
 });
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync28, realpathSync as realpathSync2 } from "fs";
 import { mkdir as mkdir8, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename5, dirname as dirname8, resolve as resolve4 } from "path";
 import { homedir as homedir34 } from "os";
@@ -272525,10 +272752,15 @@ function sanitizeServer(server) {
   };
 }
 function normalizeProjectKey(projectRoot) {
-  return resolve4(projectRoot).replace(/\\/g, "/").toLowerCase();
+  return canonicalProjectPath(projectRoot).toLowerCase();
 }
 function defaultClaudeProjectKey(projectRoot) {
-  return resolve4(projectRoot).replace(/\\/g, "/");
+  return canonicalProjectPath(projectRoot);
+}
+function canonicalProjectPath(projectRoot) {
+  const resolved = resolve4(projectRoot);
+  const canonical = existsSync28(resolved) ? realpathSync2(resolved) : resolved;
+  return canonical.replace(/\\/g, "/");
 }
 function getClaudeLocalConfigPath() {
   return `${homedir34()}/.claude.json`;
@@ -273137,6 +273369,7 @@ var init_doctor = __esm({
         let bgRunning = false;
         let bgPort = 0;
         let bgPid = 0;
+        let backgroundHealthy = false;
         try {
           if (existsSync33(bgStatePath)) {
             const bgState = JSON.parse(readFileSync22(bgStatePath, "utf-8"));
@@ -273154,7 +273387,7 @@ var init_doctor = __esm({
           lines.push(ok(`Background control plane running (PID ${bgPid}, port ${bgPort})`));
           try {
             const http3 = await import("http");
-            const healthy = await new Promise((resolve6) => {
+            backgroundHealthy = await new Promise((resolve6) => {
               const req = http3.request({ hostname: "127.0.0.1", port: bgPort, path: "/api/team", timeout: 3e3 }, (res) => {
                 res.resume();
                 resolve6(res.statusCode === 200);
@@ -273166,7 +273399,7 @@ var init_doctor = __esm({
               });
               req.end();
             });
-            if (healthy) {
+            if (backgroundHealthy) {
               lines.push(ok("Health check: OK"));
             } else {
               lines.push(warn2("Health check: FAILED (process alive but not responding)"));
@@ -273174,8 +273407,9 @@ var init_doctor = __esm({
             }
           } catch {
             lines.push(warn2("Health check: could not connect"));
+            issues.push('Background process is alive but its health endpoint could not be reached. Try "memorix background restart".');
           }
-          report.mode = { type: "background", pid: bgPid, port: bgPort, healthy: true };
+          report.mode = { type: "background", pid: bgPid, port: bgPort, healthy: backgroundHealthy };
         } else {
           lines.push(info2("Background control plane: not running"));
           lines.push(info2("Current invocation: CLI (stdio)"));
@@ -273216,18 +273450,39 @@ var init_doctor = __esm({
             report.embedding = { mode: "off", status: "disabled" };
           } else {
             lines.push(ok(`Mode: ${mode}`));
-            const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
-            const provider2 = await getEmbeddingProvider2();
-            if (provider2) {
-              lines.push(ok(`Provider: ${provider2.name} (${provider2.dimensions}d)`));
-              lines.push(ok("Status: ready"));
-              lines.push(info2("Search: hybrid (BM25 + vector)"));
-              report.embedding = { mode, status: "ready", provider: provider2.name, dimensions: provider2.dimensions };
+            let controlPlaneEmbedding;
+            if (bgRunning) {
+              try {
+                const response = await fetch(`http://127.0.0.1:${bgPort}/health`, { signal: AbortSignal.timeout(3e3) });
+                if (response.ok) {
+                  const health = await response.json();
+                  controlPlaneEmbedding = health.embedding;
+                }
+              } catch {
+              }
+            }
+            if (controlPlaneEmbedding?.status === "degraded") {
+              const kind = controlPlaneEmbedding.failure?.kind ?? "upstream";
+              const retryAfterMs = controlPlaneEmbedding.failure?.retryAfterMs;
+              const retry2 = typeof retryAfterMs === "number" && retryAfterMs > 0 ? `; retry in ${Math.ceil(retryAfterMs / 1e3)}s` : "";
+              lines.push(warn2(`Status: degraded in the running control plane (${kind}${retry2})`));
+              lines.push(info2("Search: degraded to BM25 fulltext until the provider recovers"));
+              issues.push("The running control plane has an unavailable embedding provider. Check provider credentials, billing, or connectivity.");
+              report.embedding = { mode, status: "degraded", failure: kind };
             } else {
-              lines.push(warn2("Status: temporarily unavailable"));
-              lines.push(info2("Search: degraded to BM25 fulltext (no vector similarity)"));
-              issues.push(`Embedding mode is "${mode}" but provider failed to initialize. Check API keys/connectivity.`);
-              report.embedding = { mode, status: "temporarily_unavailable" };
+              const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
+              const provider2 = await getEmbeddingProvider2();
+              if (provider2) {
+                lines.push(ok(`Provider: ${provider2.name} (${provider2.dimensions}d)`));
+                lines.push(ok("Status: ready"));
+                lines.push(info2("Search: hybrid (BM25 + vector)"));
+                report.embedding = { mode, status: "ready", provider: provider2.name, dimensions: provider2.dimensions };
+              } else {
+                lines.push(warn2("Status: temporarily unavailable"));
+                lines.push(info2("Search: degraded to BM25 fulltext (no vector similarity)"));
+                issues.push(`Embedding mode is "${mode}" but provider failed to initialize. Check API keys/connectivity.`);
+                report.embedding = { mode, status: "temporarily_unavailable" };
+              }
             }
             try {
               const cachePath = join34(memorixDir, "embedding-cache.json");