memorix 1.6.2 → 1.6.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memorix",
   "mcpName": "io.github.AVIDS2/memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Local-first shared memory layer for AI coding agents across MCP clients, Git history, reasoning context, and project sessions.",
   "type": "module",
   "sideEffects": false,

package/plugins/claude/memorix/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Shared workspace memory for Claude Code and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codebuddy/memorix/.codebuddy-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Local-first project memory for CodeBuddy Code and other coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/codex/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Shared workspace memory for Codex and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.6.2",
+  "version": "1.6.3",
   "websiteUrl": "https://github.com/AVIDS2/memorix#readme",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.6.2",
+      "version": "1.6.3",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/src/cli/commands/background.ts

@@ -23,7 +23,9 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn, execFileSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
+import os from 'node:os';
 import { parseTcpPort } from '../port.js';
+import { homeProjectRootError, inheritProjectRootFromHome, isHomeDirectory } from '../../project/launch-root.js';
 
 // ============================================================
 // Paths & Types
@@ -40,6 +42,16 @@ interface BackgroundState {
   startCwd?: string;
 }
 
+export function resolveBackgroundCwd(cwd: string, homeDir: string = os.homedir()): string {
+  if (!isHomeDirectory(cwd, homeDir)) return cwd;
+  const inherited = inheritProjectRootFromHome({
+    homeDir,
+    envProjectRoot: process.env.MEMORIX_PROJECT_ROOT,
+  });
+  if (inherited) return inherited;
+  throw new Error(homeProjectRootError(cwd));
+}
+
 function getMemorixDir(): string {
   const home = process.env.HOME || process.env.USERPROFILE || '';
   // Use join-style path to ensure native separators on Windows
@@ -380,6 +392,7 @@ export async function doStart(port: number): Promise<void> {
   // can be reclaimed with its parent by terminal hosts on Windows; a detached Node
   // child can flash a console. Start-Process gives us a hidden, independent child
   // and its real Node PID. POSIX retains the direct detached child path.
+  const startCwd = resolveBackgroundCwd(process.cwd());
   let pid: number;
   try {
     if (process.platform === 'win32') {
@@ -387,7 +400,7 @@ export async function doStart(port: number): Promise<void> {
         nodePath: process.execPath,
         cliEntry,
         port,
-        cwd: process.cwd(),
+        cwd: startCwd,
         stdoutLogFile: `${logFile}.stdout`,
         stderrLogFile: logFile,
       });
@@ -397,7 +410,7 @@ export async function doStart(port: number): Promise<void> {
         detached: true,
         stdio: ['ignore', logFd, logFd],
         env: { ...process.env },
-        cwd: process.cwd(),
+        cwd: startCwd,
       });
       child.unref();
       fs.closeSync(logFd);
@@ -418,7 +431,7 @@ export async function doStart(port: number): Promise<void> {
     startedAt: new Date().toISOString(),
     logFile,
     instanceToken,
-    startCwd: process.cwd(),
+    startCwd,
   });
 
   // 8. Print essential info immediately
@@ -824,4 +837,5 @@ export const _testing = {
   formatBackgroundCommandError,
   resolveBackgroundCliEntry,
   resolveBackgroundCliEntryFrom,
+  resolveBackgroundCwd,
 };

package/src/cli/commands/operator-shared.ts

@@ -1,4 +1,5 @@
 import { detectProjectWithDiagnostics } from '../../project/detector.js';
+import { homeProjectRootError, isHomeDirectory, writeLastProjectRoot } from '../../project/launch-root.js';
 import { getProjectDataDir } from '../../store/persistence.js';
 import { initObservations, prepareSearchIndex } from '../../memory/observations.js';
 import { initSessionStore } from '../../store/session-store.js';
@@ -42,19 +43,22 @@ async function resolveCliProjectContext(options?: CliContextOptions): Promise<{
   invocation: ReturnType<typeof getCliInvocation>;
 }> {
   const invocation = getCliInvocation();
-  const detection = detectProjectWithDiagnostics(
-    options?.projectRoot
-      ?? invocation.projectRoot
-      ?? process.env.MEMORIX_PROJECT_ROOT
-      ?? process.cwd(),
-  );
-  if (!detection.project) {
-    const detail = detection.failure?.detail ?? 'No git repository found in the current directory.';
+  const requestedRoot = options?.projectRoot
+    ?? invocation.projectRoot
+    ?? process.env.MEMORIX_PROJECT_ROOT
+    ?? process.cwd();
+  if (isHomeDirectory(requestedRoot)) {
+    throw new Error(homeProjectRootError(requestedRoot));
+  }
+  const detection = detectProjectWithDiagnostics(requestedRoot);
+  if (!detection.project || isHomeDirectory(detection.project.rootPath)) {
+    const detail = detection.failure?.detail ?? homeProjectRootError(requestedRoot);
     throw new Error(detail);
   }
 
   const project = detection.project;
   const dataDir = await getProjectDataDir(project.id);
+  writeLastProjectRoot(project.rootPath);
   return { project, dataDir, invocation };
 }
 

package/src/cli/commands/serve-http.ts

@@ -130,10 +130,29 @@ export default defineCommand({
     const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: 'team' });
 
     // Priority: explicit --cwd arg > MEMORIX_PROJECT_ROOT env > process.cwd().
-    // Do not silently bind a control plane to another project's remembered root.
+    // $HOME is never a project root; inherit last-project-root instead of creating ~/memorix.db.
     let safeCwd: string;
     try { safeCwd = process.cwd(); } catch { safeCwd = homedir(); }
-    let projectRoot = args.cwd || process.env.MEMORIX_PROJECT_ROOT || safeCwd;
+    const { resolveServeProject } = await import('./serve-shared.js');
+    const { writeLastProjectRoot } = await import('../../project/launch-root.js');
+    const persistMod = await import('../../store/persistence.js');
+    const detectorMod = await import('../../project/detector.js');
+    const serveResolution = resolveServeProject(
+      {
+        cwdArg: args.cwd,
+        envProjectRoot: process.env.MEMORIX_PROJECT_ROOT,
+        processCwd: safeCwd,
+        homeDir: homedir(),
+      },
+      { detectProject: detectorMod.detectProject, findGitInSubdirs: detectorMod.findGitInSubdirs, isSystemDirectory: detectorMod.isSystemDirectory },
+    );
+    for (const message of serveResolution.messages) {
+      console.error(message);
+    }
+    let projectRoot = serveResolution.projectRoot;
+    if (serveResolution.detectedProject) {
+      writeLastProjectRoot(serveResolution.detectedProject.rootPath);
+    }
 
     console.error(`[memorix] HTTP transport starting on ${host}:${port}`);
     console.error(`[memorix] Project root: ${projectRoot}`);
@@ -157,11 +176,10 @@ export default defineCommand({
       return store;
     }
 
-    // Bootstrap the initial project's TeamStore
-    const persistMod = await import('../../store/persistence.js');
-    const detectorMod = await import('../../project/detector.js');
-    const detectedProj = detectorMod.detectProject(projectRoot);
-    const teamDataDir = detectedProj ? await persistMod.getProjectDataDir(detectedProj.rootPath) : projectRoot;
+    // Bootstrap the initial project's TeamStore. Never open SQLite at $HOME
+    // (that creates a decoy ~/memorix.db). Unresolved launches share ~/.memorix/data.
+    const detectedProj = serveResolution.detectedProject ?? detectorMod.detectProject(projectRoot);
+    const teamDataDir = await persistMod.getProjectDataDir(detectedProj?.id ?? '__unresolved__');
     const sharedTeamStore = await getTeamStore(teamDataDir);
 
     type SessionState = {

package/src/cli/commands/serve-shared.ts

@@ -1,5 +1,4 @@
-import path from 'node:path';
-
+import { inheritProjectRootFromHome, isHomeDirectory } from '../../project/launch-root.js';
 import type { ProjectInfo } from '../../types.js';
 
 export interface ResolveServeProjectOptions {
@@ -19,7 +18,7 @@ export interface ResolveServeProjectDeps {
 export interface ServeProjectResolution {
   projectRoot: string;
   detectedProject: ProjectInfo | null;
-  source: 'direct' | 'subdir' | 'unresolved';
+  source: 'direct' | 'subdir' | 'last-project-root' | 'unresolved';
   messages: string[];
   error?: string;
 }
@@ -35,8 +34,54 @@ export function resolveServeProject(
     options.processCwd;
 
   const messages: string[] = [`[memorix] Starting with cwd: ${projectRoot}`];
+  const hasExplicitRoot = Boolean(options.cwdArg || options.envProjectRoot || options.initCwd);
+  const startsAtHome = isHomeDirectory(projectRoot, options.homeDir);
+
+  if (startsAtHome) {
+    if (hasExplicitRoot) {
+      messages.push(`[memorix] Refusing explicit $HOME project root: ${projectRoot}`);
+      messages.push('[memorix] Memorix will wait for MCP Roots or an explicit memorix_session_start projectRoot.');
+      return {
+        projectRoot,
+        detectedProject: null,
+        source: 'unresolved',
+        messages,
+        error: 'Refusing to bind $HOME as a project root. Pass a git project path instead of $HOME.',
+      };
+    }
+    const inherited = inheritProjectRootFromHome({
+      homeDir: options.homeDir,
+      envProjectRoot: options.envProjectRoot,
+    });
+    if (inherited) {
+      const inheritedProject = deps.detectProject(inherited);
+      if (inheritedProject && !isHomeDirectory(inheritedProject.rootPath, options.homeDir)) {
+        messages.push(`[memorix] Unreliable launch directory detected: ${projectRoot}`);
+        messages.push(`[memorix] Inherited last git project: ${inheritedProject.rootPath}`);
+        return {
+          projectRoot: inheritedProject.rootPath,
+          detectedProject: inheritedProject,
+          source: 'last-project-root',
+          messages,
+        };
+      }
+    }
+    messages.push(`[memorix] Unreliable launch directory detected: ${projectRoot}`);
+    messages.push('[memorix] Memorix will wait for MCP Roots or an explicit memorix_session_start projectRoot.');
+    messages.push('[memorix] It will not create ~/memorix.db or treat $HOME as a project.');
+    return {
+      projectRoot,
+      detectedProject: null,
+      source: 'unresolved',
+      messages,
+      error: 'No reliable git project was provided by the launcher.',
+    };
+  }
 
   let detected = deps.detectProject(projectRoot);
+  if (detected && isHomeDirectory(detected.rootPath, options.homeDir)) {
+    detected = null;
+  }
   if (detected) {
     return {
       projectRoot,
@@ -46,9 +91,7 @@ export function resolveServeProject(
     };
   }
 
-  const hasExplicitRoot = Boolean(options.cwdArg || options.envProjectRoot || options.initCwd);
-  const startsAtHome = path.resolve(projectRoot) === path.resolve(options.homeDir);
-  if (deps.isSystemDirectory(projectRoot) || (!hasExplicitRoot && startsAtHome)) {
+  if (deps.isSystemDirectory(projectRoot)) {
     messages.push(`[memorix] Unreliable launch directory detected: ${projectRoot}`);
     messages.push('[memorix] Memorix will wait for MCP Roots or an explicit memorix_session_start projectRoot.');
     messages.push('[memorix] It will not restore a previous project automatically, to prevent cross-project memory access.');

package/src/cli/commands/serve.ts

@@ -71,6 +71,10 @@ export default defineCommand({
 
     const detected = resolution.detectedProject;
     const projectRoot = resolution.projectRoot;
+    if (detected) {
+      const { writeLastProjectRoot } = await import('../../project/launch-root.js');
+      writeLastProjectRoot(detected.rootPath);
+    }
 
     // Always register ALL tools BEFORE connecting transport.
     // This ensures tools/list returns the full tool set immediately on connect.

package/src/memory/session.ts

@@ -140,10 +140,20 @@ async function loadAliasActiveSessions(projectIds: Set<string>): Promise<Session
   return groups.flat();
 }
 
-async function loadAliasActiveObservations(projectIds: Set<string>): Promise<Observation[]> {
+const SESSION_RESUME_OBSERVATION_LIMIT = 64;
+const SESSION_CONTEXT_OBSERVATION_LIMIT = 128;
+
+async function loadAliasActiveObservations(
+  projectIds: Set<string>,
+  limit: number = SESSION_RESUME_OBSERVATION_LIMIT,
+): Promise<Observation[]> {
   const store = getObservationStore();
   const groups = await Promise.all(
-    [...projectIds].map((projectId) => store.loadByProject(projectId, { status: 'active' })),
+    [...projectIds].map((projectId) => store.loadByProject(projectId, {
+      status: 'active',
+      limit,
+      newestFirst: true,
+    })),
   );
   return groups.flat();
 }
@@ -522,7 +532,7 @@ export async function getSessionContext(
   const aliasSet = await resolveProjectIds(projectId);
   const [sessions, allObs] = await Promise.all([
     loadAliasSessions(aliasSet),
-    loadAliasActiveObservations(aliasSet),
+    loadAliasActiveObservations(aliasSet, SESSION_CONTEXT_OBSERVATION_LIMIT),
   ]);
   const readableObs = readableAliasObservations(allObs, aliasSet, reader);
   /** Check if a session summary contains noise/system-self content */

package/src/project/launch-root.ts

@@ -0,0 +1,115 @@
+/**
+ * Launch-root guards for HTTP/stdio/background.
+ *
+ * LaunchAgents and Cursor stdio often start with cwd=$HOME. Binding that path
+ * treats the home directory as a project and can create a decoy ~/memorix.db
+ * while the real store lives in ~/.memorix/data/memorix.db.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const LAST_PROJECT_ROOT_FILENAME = 'last-project-root';
+
+/**
+ * Resolve the home directory used by Memorix boundary guards.
+ *
+ * Node's os.homedir() is intentionally stable on Windows and does not always
+ * follow a process-level HOME/USERPROFILE override. The CLI and test harnesses
+ * use those environment variables as the configured home, so all guards need
+ * one shared resolution rule instead of mixing the two sources.
+ */
+export function effectiveHomeDirectory(): string {
+  const configuredHome = process.platform === 'win32'
+    ? process.env.USERPROFILE?.trim() || process.env.HOME?.trim()
+    : process.env.HOME?.trim() || process.env.USERPROFILE?.trim();
+  return path.resolve(configuredHome || os.homedir());
+}
+
+export function isHomeDirectory(candidate: string, homeDir: string = effectiveHomeDirectory()): boolean {
+  try {
+    return path.resolve(candidate) === path.resolve(homeDir);
+  } catch {
+    return false;
+  }
+}
+
+export function lastProjectRootPath(homeDir: string = effectiveHomeDirectory()): string {
+  return path.join(homeDir, '.memorix', LAST_PROJECT_ROOT_FILENAME);
+}
+
+export function readLastProjectRoot(homeDir: string = effectiveHomeDirectory()): string | null {
+  try {
+    const raw = readFileSync(lastProjectRootPath(homeDir), 'utf8').trim();
+    if (!raw) return null;
+    const resolved = path.resolve(raw);
+    if (isHomeDirectory(resolved, homeDir)) return null;
+    if (!existsSync(resolved)) return null;
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+
+export function writeLastProjectRoot(projectRoot: string, homeDir?: string): void {
+  // Tests pass an explicit homeDir. Default writes are skipped under Vitest so
+  // unit tests do not mutate the developer's ~/.memorix/last-project-root.
+  if (process.env.VITEST && homeDir === undefined) return;
+  const resolvedHome = homeDir ?? effectiveHomeDirectory();
+  const resolved = path.resolve(projectRoot);
+  if (isHomeDirectory(resolved, resolvedHome)) return;
+  if (!existsSync(resolved)) return;
+  const memorixDir = path.join(resolvedHome, '.memorix');
+  mkdirSync(memorixDir, { recursive: true });
+  writeFileSync(lastProjectRootPath(resolvedHome), `${resolved}\n`, 'utf8');
+}
+
+export function homeProjectRootError(candidate: string): string {
+  return (
+    `Refusing to bind $HOME as a project root (${candidate}). ` +
+    'Pass a git project via --cwd, MEMORIX_PROJECT_ROOT, or memorix_session_start({ projectRoot }). ' +
+    'Memorix will not create ~/memorix.db.'
+  );
+}
+
+/**
+ * When the launcher cwd is $HOME, inherit the last git project or an explicit
+ * MEMORIX_PROJECT_ROOT. System directories stay fail-closed (no restore).
+ */
+export function inheritProjectRootFromHome(options: {
+  homeDir: string;
+  envProjectRoot?: string;
+  readLastRoot?: () => string | null;
+}): string | null {
+  const envRoot = options.envProjectRoot?.trim();
+  if (envRoot && !isHomeDirectory(envRoot, options.homeDir) && existsSync(envRoot)) {
+    return path.resolve(envRoot);
+  }
+  const lastRoot = (options.readLastRoot ?? (() => readLastProjectRoot(options.homeDir)))();
+  if (lastRoot && !isHomeDirectory(lastRoot, options.homeDir) && existsSync(lastRoot)) {
+    return lastRoot;
+  }
+  return null;
+}
+
+/**
+ * Shared SQLite must never be opened at $HOME — that creates a decoy ~/memorix.db.
+ */
+export function resolveControlPlaneDataDir(options: {
+  requestedDataDir?: string;
+  homeDir?: string;
+  globalDataDir: string;
+}): string {
+  const homeDir = options.homeDir ?? effectiveHomeDirectory();
+  if (options.requestedDataDir && !isHomeDirectory(options.requestedDataDir, homeDir)) {
+    return options.requestedDataDir;
+  }
+  return options.globalDataDir;
+}
+
+export function assertNotHomeDataDir(dataDir: string, homeDir: string = effectiveHomeDirectory()): void {
+  if (isHomeDirectory(dataDir, homeDir)) {
+    throw new Error(homeProjectRootError(dataDir));
+  }
+}

package/src/runtime/isolated-maintenance.ts

@@ -1,5 +1,6 @@
 import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -52,6 +53,16 @@ function childError(prefix: string, detail: string): Error {
   return new Error(cleaned ? `${prefix}: ${cleaned}` : prefix);
 }
 
+/**
+ * Isolated jobs already receive an absolute projectRoot on stdin. Using that
+ * directory as spawn cwd keeps the folder locked on Windows (EBUSY on rmdir)
+ * for the life of the child. Park the process in a disposable temp dir instead.
+ */
+export function isolatedMaintenanceCwd(): string {
+  const tmp = os.tmpdir();
+  return existsSync(tmp) ? tmp : process.cwd();
+}
+
 /**
  * Resolve the runner beside the compiled package entry. The CLI bundle lives
  * in dist/cli while the library entry lives directly in dist.
@@ -148,7 +159,7 @@ export async function runMaintenanceInChildProcess(
     let child: ChildProcessWithoutNullStreams;
     try {
       child = spawn(process.execPath, [runnerPath], {
-        cwd: request.projectRoot,
+        cwd: isolatedMaintenanceCwd(),
         env,
         stdio: ['pipe', 'pipe', 'pipe'],
         windowsHide: true,

package/src/server.ts

@@ -33,6 +33,7 @@ import { canManageObservation, canReadObservation, filterReadableObservations, r
 import { compactSearch, compactTimeline, compactDetail } from './compact/engine.js';
 import { buildGraphContextPacket, formatGraphContextPrompt } from './memory/graph-context.js';
 import { detectProject } from './project/detector.js';
+import { homeProjectRootError, isHomeDirectory, writeLastProjectRoot } from './project/launch-root.js';
 import { registerAlias, initAliasRegistry, resolveAliases, autoMergeByBaseName } from './project/aliases.js';
 import { getProjectDataDir } from './store/persistence.js';
 import type { ObservationType, RuleSource, AgentTarget, MCPServerEntry, ObservationReader } from './types.js';
@@ -228,6 +229,7 @@ export const BOOTSTRAP_SAFE_TOOL_NAMES = new Set([
   'memorix_codegraph_status',
   'memorix_graph_context',
   'memorix_context_pack',
+  'memorix_session_start',
 ]);
 
 const AUTOPILOT_RETRIEVAL_BOUNDARY_TTL_MS = 2 * 60 * 1000;
@@ -265,7 +267,10 @@ export async function createMemorixServer(
   });
   const teamFeaturesEnabled = isToolInProfile('team_manage', toolProfile);
   const projectBinding = options.projectBinding ?? createProjectBindingController(cwd ?? process.cwd());
-  const detectedProject = detectProject(cwd);
+  const detectedProjectRaw = detectProject(cwd);
+  const detectedProject = detectedProjectRaw && !isHomeDirectory(detectedProjectRaw.rootPath)
+    ? detectedProjectRaw
+    : null;
   let rawProject: import('./types.js').ProjectInfo;
   let projectResolved = true;
   let projectResolutionError: string | null = null;
@@ -316,6 +321,7 @@ export async function createMemorixServer(
   }
   if (projectResolved) {
     projectBinding.recordResolvedProject(project.id, project.rootPath);
+    writeLastProjectRoot(project.rootPath);
   }
 
   const registerMaintenanceTarget = async (): Promise<void> => {
@@ -362,6 +368,7 @@ export async function createMemorixServer(
 
   const lightweightUnresolvedSession = !projectResolved && deferProjectInitUntilBound;
   let projectRuntimeInitPromise: Promise<void> | null = null;
+  let runtimeHydratedForDir: string | null = null;
 
   const initializeProjectRuntime = async (logPrefix: 'startup' | 'switch'): Promise<void> => {
     await initObservationStore(projectDir);
@@ -430,14 +437,20 @@ export async function createMemorixServer(
   } catch { /* migration is optional */ }
 
   await initializeProjectRuntime('startup');
+    runtimeHydratedForDir = projectDir;
   } else {
     // Intentionally silent — serve-http.ts deferred logging handles session lifecycle visibility.
     // Noisy per-probe 'awaiting binding' log was removed to reduce terminal spam.
   }
 
   const ensureProjectRuntimeInitialized = async (): Promise<void> => {
-    if (lightweightUnresolvedSession || !deferProjectRuntimeInit) return;
+    if (!projectResolved) return;
+    if (runtimeHydratedForDir === projectDir) {
+      if (projectRuntimeInitPromise) await projectRuntimeInitPromise;
+      return;
+    }
     if (!projectRuntimeInitPromise) {
+      const targetDir = projectDir;
       projectRuntimeInitPromise = (async () => {
         // Auto-merge obvious alias groups by scanning observed projectIds in data.
         try {
@@ -470,7 +483,8 @@ export async function createMemorixServer(
           }
         } catch { /* migration is optional */ }
 
-        await initializeProjectRuntime('startup');
+        await initializeProjectRuntime(runtimeHydratedForDir ? 'switch' : 'startup');
+        runtimeHydratedForDir = targetDir;
       })().catch((err) => {
         projectRuntimeInitPromise = null;
         throw err;
@@ -3846,6 +3860,15 @@ export async function createMemorixServer(
       // BEFORE checking whether the project is resolved. This is the primary
       // mechanism for HTTP/control-plane multi-project support.
       if (explicitRoot && typeof explicitRoot === 'string') {
+        if (isHomeDirectory(explicitRoot)) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: homeProjectRootError(explicitRoot),
+            }],
+            isError: true as const,
+          };
+        }
         let bound = await switchProject(explicitRoot, 'explicit-project-root');
         // switchProject returns false for both "same project, no-op" and "no git repo".
         // Only scan subdirectories when explicitRoot is not itself a git repo; otherwise
@@ -5503,8 +5526,12 @@ export async function createMemorixServer(
   ): Promise<boolean> => {
     if (source === 'mcp-roots' && projectBinding.isExplicit()) return false;
     const { detectProjectWithDiagnostics } = await import('./project/detector.js');
+    if (isHomeDirectory(newCwd)) {
+      console.error(`[memorix] Refusing to bind $HOME as a project root: ${newCwd}`);
+      return false;
+    }
     const result = detectProjectWithDiagnostics(newCwd);
-    if (!result.project) {
+    if (!result.project || isHomeDirectory(result.project.rootPath)) {
       if (result.failure) {
         console.error(`[memorix] Project detection failed for "${newCwd}": [${result.failure.reason}] ${result.failure.detail}`);
       }
@@ -5523,6 +5550,7 @@ export async function createMemorixServer(
       else if (source === 'mcp-roots') projectBinding.bindFromRoots(newDetected.rootPath);
       else projectBinding.bindStartup(newDetected.rootPath);
       projectBinding.recordResolvedProject(project.id, project.rootPath);
+      writeLastProjectRoot(project.rootPath);
       return false; // same project, no-op
     }
 
@@ -5580,7 +5608,12 @@ export async function createMemorixServer(
       }
     } catch { /* best-effort - coordination features degrade gracefully */ }
 
-    await initializeProjectRuntime('switch');
+    writeLastProjectRoot(project.rootPath);
+    runtimeHydratedForDir = null;
+    projectRuntimeInitPromise = null;
+    void ensureProjectRuntimeInitialized().catch((err) => {
+      console.error(`[memorix] Background project runtime init failed: ${err instanceof Error ? err.message : err}`);
+    });
     try {
       await startProjectMaintenanceWorker();
     } catch {