@echomem/mcp 1.4.43 → 1.4.44

package/README.md

@@ -35,22 +35,36 @@ Unencrypted accounts are unaffected. `search_memories` returns retrieved memorie
 your MCP client does the final answer generation; pass `includeAnswer: true` only if you need the
 legacy EchoMem-synthesized recall answer.
 
-## Quick start (recommended)
+## Quick start
 
-Install Echo Desktop, sign in once, then open **Connect MCP** and choose **Connect Echo**. The app
-ships and installs the MCP runtime, configures the detected Codex and Claude hosts, mirrors the same
-device credential used by the desktop app, and verifies the MCP handshake. No terminal login is
-required.
+The standalone package installs and manages its own durable per-user MCP runtime. It configures
+detected Codex and Claude hosts, connects this device, imports selected local coding history, and
+keeps compatible runtime updates ready for the next agent session.
 
-The standalone HUD has been retired; Echo Desktop is the persistent setup and status surface. The
-bridge still reads local agent logs for on-demand context-health tools, but it no longer publishes or
-auto-launches an Electron overlay.
+Prerequisite: **Node.js 18 or newer**. Run the command in the same environment as the agent you
+want to configure. Native Windows and WSL have separate home directories and client configs, so a
+WSL install does not configure native Windows apps.
 
-For headless systems and development, the granular CLI commands remain available:
+macOS, Linux, or WSL:
+
+```bash
+npx -y @echomem/mcp@latest init
+```
+
+Windows PowerShell:
+
+```powershell
+npx.cmd -y @echomem/mcp@latest init
+```
+
+The one-off `npx` command is the recommended install path; it stages a durable per-user runtime
+and does not require a global npm install. On Windows, use a new PowerShell window after installing
+Node if `npx.cmd` is not found.
 
 | Command | What it does |
 |---|---|
-| `npm i -g @echomem/mcp@latest && echomem-mcp init` | Legacy/headless setup for installed agents + login |
+| `npx -y @echomem/mcp@latest init` | One-command setup for installed agents + login (use `npx.cmd` in Windows PowerShell) |
+| `npm i -g @echomem/mcp@latest`, then `echomem-mcp init` | Optional global install for a persistent CLI command |
 | `npm i -g @echomem/mcp@latest && echomem-mcp setup` | Install the CLI globally and configure just the detected editor |
 | `npx -y @echomem/mcp@latest setup` | One-off setup without keeping a global CLI command |
 | `echomem-mcp setup [--client cursor\|windsurf\|claude-desktop\|claude-code\|codex]` | Write client config + log in |
@@ -95,23 +109,6 @@ Both hook entries are merged idempotently into `~/.codex/hooks.json` and
 `~/.claude/settings.json`; unrelated user hooks and settings are preserved. Hooks fail open when
 their local input is missing so they cannot prevent a conversation from starting or finishing.
 
-## Agent Doctor — local workspace forensics (new in 1.4.9)
-
-`echomem-mcp init` / `setup` now ends with an **Agent Doctor report**: a local scan of your
-Codex and Claude Code session logs that shows what your AI coding actually cost and where the
-context went dirty — rendered as an interactive 3D "repo city" plus a full forensic breakdown.
-
-- **Unified cost ledger.** Every provider request is priced individually from official API list
-  rates (model, cache write/read, long-context premiums, intro-pricing windows), so the headline
-  TOTAL SPENT, per-repo costs, per-model costs, and cost components all come from one path and
-  reconcile exactly. It is an **API-equivalent estimate of volume, not a bill you paid**.
-- **Fail-closed validation.** The report refuses to render unless every ledger reconciles
-  (tokens, costs, canonical waste analysis). Stale or preview data can never appear as your data.
-- **Wasteful-context analysis.** Canonical context windows label input tokens useful vs wasteful
-  (re-reads of unchanged files, re-finding, dead work) and project the waste over your billed input.
-- **Fully local, zero upload.** The scan reads local JSONL logs only: no transcripts are uploaded
-  and no LLM calls are made to build the report.
-
 ### Manual / headless (SSH, containers, CI)
 
 No browser? Provide secrets directly — this is the documented headless path:
@@ -140,7 +137,7 @@ npm test   # crypto compat + encrypted-local integration tests
 
 ### Add to your IDE (Cursor or Windsurf)
 
-> Prefer `npm i -g @echomem/mcp@latest && echomem-mcp init` above — it writes these files for you and keeps secrets out of
+> Prefer `npx -y @echomem/mcp@latest init` above (`npx.cmd` in Windows PowerShell) — it writes these files for you and keeps secrets out of
 > the client config. The manual steps below are the fallback.
 
 #### For Cursor

package/dist/config-files.js

@@ -0,0 +1,63 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+function isErrno(error, code) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === code;
+}
+/**
+ * Read a user-owned JSON configuration without treating corruption as an empty file.
+ * Setup must fail closed here: replacing malformed JSON would destroy unrelated client settings.
+ */
+export function readJsonObjectFile(file, label = "configuration") {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return {};
+        throw new Error(`Could not read ${label} at ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Could not safely update ${label} at ${file} because the existing file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Could not safely update ${label} at ${file} because the existing JSON root is not an object.`);
+    }
+    return parsed;
+}
+/** Write beside the destination and rename only after the complete replacement is durable locally. */
+export function atomicWriteTextFile(file, content) {
+    const directory = path.dirname(file);
+    fs.mkdirSync(directory, { recursive: true });
+    const temporary = path.join(directory, `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+    let mode;
+    try {
+        mode = fs.statSync(file).mode;
+    }
+    catch {
+        /* A fresh file uses the process default mode. */
+    }
+    try {
+        fs.writeFileSync(temporary, content, mode === undefined ? undefined : { mode });
+        fs.renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch {
+            /* Preserve the original error. */
+        }
+        throw error;
+    }
+}
+export function atomicWriteJsonObject(file, value) {
+    atomicWriteTextFile(file, JSON.stringify(value, null, 2));
+}

package/dist/context-analysis/claude-native-canonical.js

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { resolveClaudeProjectsDir } from "../local-data-paths.js";
-import { walk } from "../report.js";
+import { walkLocalFiles } from "../local-jsonl.js";
 import { isStrongPositiveFeedback, } from "./workspace-report.js";
 const OUTPUT_TOKEN_CAP = 12_000;
 const IMAGE_TOKENS = 4_000;
@@ -33,7 +33,7 @@ const PROBLEM_META = {
 const PROBLEM_IDS = Object.keys(PROBLEM_META);
 export function buildClaudeNativeCanonicalReport(opts) {
     const claudeRoot = opts?.sessionPaths ? null : resolveClaudeProjectsDir();
-    const discovered = (opts?.sessionPaths ?? (claudeRoot ? walk(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort();
+    const discovered = (opts?.sessionPaths ?? (claudeRoot ? walkLocalFiles(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort();
     const files = typeof opts?.limitFiles === "number" ? discovered.slice(-Math.max(0, opts.limitFiles)) : discovered;
     const sessions = [];
     const errors = [];

package/dist/context-analysis/vendored-canonical.js

@@ -6,7 +6,7 @@ import readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { discoverCodexSessionFiles } from "../codex-session-files.js";
 import { resolveClaudeProjectsDir } from "../local-data-paths.js";
-import { walk } from "../report.js";
+import { walkLocalFiles } from "../local-jsonl.js";
 import { buildClaudeNativeCanonicalReport } from "./claude-native-canonical.js";
 const PROBLEM_IDS = [
     "P01", "P02", "P03", "P04", "P05", "P06", "P07", "P08", "P09", "P10", "P11", "P12", "P13",
@@ -89,7 +89,7 @@ export async function buildVendoredCanonicalReport(opts) {
             .filter(isUserInitiatedSession)
         : [];
     const discoveredClaude = sources.includes("claude-code")
-        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walk(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
+        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walkLocalFiles(claudeRoot, (candidate) => candidate.endsWith(".jsonl") && !candidate.includes(`${path.sep}subagents${path.sep}`) && !candidate.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
         : [];
     const codexFiles = limitFiles(discoveredCodex, opts?.limitFiles);
     const claudeFiles = limitFiles(discoveredClaude, opts?.limitFiles);

package/dist/context-analysis/workspace-report.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { discoverCodexSessionFiles } from "../codex-session-files.js";
 import { resolveClaudeProjectsDir } from "../local-data-paths.js";
-import { eachLine, walk } from "../report.js";
+import { eachJsonLine, walkLocalFiles } from "../local-jsonl.js";
 const PROBLEMS = {
     P01: { id: "P01", label: "Outdated Images & Screenshots", bucket: "dead", category: "Runtime Bug", confidence: "high" },
     P02: { id: "P02", label: "Ignored User Instructions", bucket: "refind", category: "Model Behavior", confidence: "medium" },
@@ -52,7 +52,7 @@ export function buildWorkspaceContextReport(opts) {
         ? discoveredCodexFiles.filter(isUserInitiatedCodexSession)
         : discoveredCodexFiles;
     const claudeFiles = sources.includes("claude-code")
-        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walk(claudeRoot, (p) => p.endsWith(".jsonl") && !p.includes(`${path.sep}subagents${path.sep}`) && !p.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
+        ? (opts?.claudeSessionPaths ?? (claudeRoot ? walkLocalFiles(claudeRoot, (p) => p.endsWith(".jsonl") && !p.includes(`${path.sep}subagents${path.sep}`) && !p.includes(`${path.sep}workflows${path.sep}`), () => false) : [])).sort()
         : [];
     const selectedCodex = typeof opts?.limitFiles === "number" ? codexFiles.slice(-Math.max(0, opts.limitFiles)) : codexFiles;
     const selectedClaude = typeof opts?.limitFiles === "number" ? claudeFiles.slice(-Math.max(0, opts.limitFiles)) : claudeFiles;
@@ -472,7 +472,7 @@ function parseCodexSession(file) {
     const turns = [];
     const ledgerItems = [];
     const callMeta = new Map();
-    eachLine(file, (raw) => {
+    eachJsonLine(file, (raw) => {
         const top = isRecord(raw) ? raw : {};
         const payload = isRecord(top.payload) ? top.payload : top;
         const type = typeof payload.type === "string" ? payload.type : typeof top.type === "string" ? top.type : "";

package/dist/hud/hooks.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { atomicWriteJsonObject, readJsonObjectFile } from "../config-files.js";
 export function installHooks(mode) {
     const written = [];
     if (mode === "codex" || mode === "both" || mode === "auto") {
@@ -33,16 +34,16 @@ export function installSourceSessionHooks(mode) {
     return written;
 }
 function installCodexHooks() {
-    const dir = path.join(os.homedir(), ".codex");
+    const dir = profileDirectory("CODEX_HOME", ".codex");
     const file = path.join(dir, "hooks.json");
     fs.mkdirSync(dir, { recursive: true });
     const hookCommand = `${JSON.stringify(process.execPath)} ${JSON.stringify(process.argv[1])} summary --client codex --json`;
     const content = readHooksFile(file);
     content.hooks = content.hooks || {};
-    content.hooks.PostToolUse = mergeHookGroup(content.hooks.PostToolUse, { matcher: "*", hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
-    content.hooks.PostCompact = mergeHookGroup(content.hooks.PostCompact, { hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
-    content.hooks.Stop = mergeHookGroup(content.hooks.Stop, { hooks: [{ type: "command", command: hookCommand, timeout: 5 }] });
-    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    content.hooks.PostToolUse = mergeHookGroup(content.hooks.PostToolUse, { matcher: "*", hooks: [codexCommandHook(hookCommand, 5)] });
+    content.hooks.PostCompact = mergeHookGroup(content.hooks.PostCompact, { hooks: [codexCommandHook(hookCommand, 5)] });
+    content.hooks.Stop = mergeHookGroup(content.hooks.Stop, { hooks: [codexCommandHook(hookCommand, 5)] });
+    atomicWriteJsonObject(file, content);
     return file;
 }
 function saveCheckpointCommand() {
@@ -54,24 +55,19 @@ function sourceSessionCommand() {
     return `${JSON.stringify(process.execPath)} ${JSON.stringify(lifecycleCli)} bind-source-session`;
 }
 function installCodexSourceSessionHook() {
-    const dir = path.join(os.homedir(), ".codex");
+    const dir = profileDirectory("CODEX_HOME", ".codex");
     const file = path.join(dir, "hooks.json");
     fs.mkdirSync(dir, { recursive: true });
     const content = readHooksFile(file);
     content.hooks = content.hooks || {};
     content.hooks.SessionStart = mergeSourceSessionGroup(content.hooks.SessionStart, {
-        hooks: [{
-                type: "command",
-                command: sourceSessionCommand(),
-                timeout: 5,
-                statusMessage: "Binding EchoMem to this conversation",
-            }],
+        hooks: [codexCommandHook(sourceSessionCommand(), 5, "Binding EchoMem to this conversation")],
     });
-    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    atomicWriteJsonObject(file, content);
     return file;
 }
 function installClaudeCodeSourceSessionHook() {
-    const dir = path.join(os.homedir(), ".claude");
+    const dir = profileDirectory("CLAUDE_CONFIG_DIR", ".claude");
     const file = path.join(dir, "settings.json");
     fs.mkdirSync(dir, { recursive: true });
     const content = readHooksFile(file);
@@ -84,28 +80,23 @@ function installClaudeCodeSourceSessionHook() {
                 statusMessage: "Binding EchoMem to this conversation",
             }],
     });
-    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    atomicWriteJsonObject(file, content);
     return file;
 }
 function installCodexSaveCheckpointHook() {
-    const dir = path.join(os.homedir(), ".codex");
+    const dir = profileDirectory("CODEX_HOME", ".codex");
     const file = path.join(dir, "hooks.json");
     fs.mkdirSync(dir, { recursive: true });
     const content = readHooksFile(file);
     content.hooks = content.hooks || {};
     content.hooks.Stop = mergeSaveCheckpointGroup(content.hooks.Stop, {
-        hooks: [{
-                type: "command",
-                command: saveCheckpointCommand(),
-                timeout: 10,
-                statusMessage: "Checking whether completed work should be remembered",
-            }],
+        hooks: [codexCommandHook(saveCheckpointCommand(), 10, "Checking whether completed work should be remembered")],
     });
-    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    atomicWriteJsonObject(file, content);
     return file;
 }
 function installClaudeCodeSaveCheckpointHook() {
-    const dir = path.join(os.homedir(), ".claude");
+    const dir = profileDirectory("CLAUDE_CONFIG_DIR", ".claude");
     const file = path.join(dir, "settings.json");
     fs.mkdirSync(dir, { recursive: true });
     const content = readHooksFile(file);
@@ -118,22 +109,43 @@ function installClaudeCodeSaveCheckpointHook() {
                 statusMessage: "Checking whether completed work should be remembered",
             }],
     });
-    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    atomicWriteJsonObject(file, content);
     return file;
 }
 function installClaudeCodeSnippet() {
-    const dir = path.join(os.homedir(), ".claude", "echo-ctx");
+    const dir = path.join(profileDirectory("CLAUDE_CONFIG_DIR", ".claude"), "echo-ctx");
     fs.mkdirSync(dir, { recursive: true });
     return dir;
 }
 function readHooksFile(file) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
-        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    return readJsonObjectFile(file, "agent hooks");
+}
+function profileDirectory(envKey, fallbackName) {
+    const home = os.homedir();
+    const configured = process.env[envKey]?.trim();
+    if (!configured)
+        return path.join(home, fallbackName);
+    if (configured === "~")
+        return home;
+    if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+        return path.join(home, configured.slice(2));
     }
-    catch {
-        return {};
+    if (!path.isAbsolute(configured)) {
+        throw new Error(`${envKey} must be an absolute path or start with ~/`);
     }
+    return path.normalize(configured);
+}
+function codexCommandHook(command, timeout, statusMessage) {
+    return {
+        type: "command",
+        command,
+        // Codex supports an explicit Windows override. Keeping it identical is intentional: the
+        // absolute node.exe and CLI paths are already quoted, and Codex can select this field without
+        // interpreting a POSIX-only fallback.
+        commandWindows: command,
+        timeout,
+        ...(statusMessage ? { statusMessage } : {}),
+    };
 }
 function mergeHookGroup(existing, group) {
     const groups = Array.isArray(existing) ? existing.filter((item) => !isEchoHudGroup(item)) : [];

package/dist/index.js

@@ -7,12 +7,11 @@ import { ZodError } from "zod";
 import { bindSourceSessionSchema, canonicalToolNames, completeGroupPublicationSchema, createGroupInviteSchema, createGroupSchema, deleteMemorySchema, flagPublicationAttentionSchema, getGroupSessionSharingSchema, getByContextSchema, groupContextSchema, joinGroupSchema, keywordsSchema, listFriendsSchema, listToolSpecs, othersSchema, publishBatchToGroupSchema, publishToGroupSchema, prepareGroupPublicationSchema, publicMemorySchema, recordMemoryCitationsSchema, requestGroupSessionSharingSchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, searchUsersSchema, sendFriendRequestSchema, timeRangeSchema, updateGroupProfileSchema, setGroupSessionSharingSchema, } from "./v1-contract.js";
 import { KeyStore } from "./keystore.js";
 import { EventLogger, hashText } from "./events.js";
-import { buildReportText } from "./report.js";
 import { contextHealthMarkdown, recomposeCapsuleMarkdown } from "./hud/api.js";
 import { createHash, randomUUID } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fetchEncryptionConfig, decryptMemoryFields, verifyKeyB64, } from "./encryption.js";
-import { runCli } from "./setup.js";
+import { refreshInstalledMemoryGuidance, runCli } from "./setup.js";
 import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS, MEMORY_CITATION_INSTRUCTION, SAVED_MEMORY_RECEIPT_INSTRUCTION, } from "./package-metadata.js";
 import { clearBillingAlert, writeBillingAlert } from "./billing-alert.js";
 import { checkLatestUpdateStatus, formatUpdateNotice, formatUpdateStatusText, startBackgroundUpdateCheck, } from "./update-check.js";
@@ -613,8 +612,6 @@ function toolEventName(canonicalName, status) {
 class EchoMemApiClient {
     store;
     axios;
-    activeToken;
-    accountGeneration = 0;
     boundSourceSession = null;
     requestSourceSession = new AsyncLocalStorage();
     sourceSessionsByCanonicalKey = new Map();
@@ -625,7 +622,6 @@ class EchoMemApiClient {
     deleteConfirmations = new Map();
     constructor(store) {
         this.store = store;
-        this.activeToken = store.getToken();
         this.axios = axios.create({
             baseURL: ECHO_API_BASE_URL.replace(/\/$/, ""),
             headers: {
@@ -635,7 +631,7 @@ class EchoMemApiClient {
         // Read the token fresh on EVERY request (not baked in at construction) so a `login` that runs
         // after the editor already launched the bridge is picked up on the next call — no restart.
         this.axios.interceptors.request.use((config) => {
-            const token = this.synchronizeAccountContext();
+            const token = this.store.getToken();
             if (token)
                 config.headers.set("Authorization", `Bearer ${token}`);
             const sourceSession = this.getBoundSourceSession();
@@ -645,46 +641,21 @@ class EchoMemApiClient {
             return config;
         });
     }
-    /**
-     * Account-scoped state must move atomically with the credential file. The token is intentionally
-     * read fresh, but encryption, identity, source-session, and confirmation caches belong to the
-     * token that populated them and cannot survive an in-process account switch.
-     */
-    synchronizeAccountContext() {
-        const token = this.store.getToken();
-        if (token === this.activeToken)
-            return token;
-        this.activeToken = token;
-        this.accountGeneration += 1;
-        this.encConfigPromise = null;
-        this.whoamiCache = null;
-        this.boundSourceSession = null;
-        this.sourceSessionsByCanonicalKey.clear();
-        this.deleteConfirmations.clear();
-        return token;
-    }
-    /** Lets the MCP server invalidate its account-scoped tool-description caches too. */
-    refreshAccountContext() {
-        this.synchronizeAccountContext();
-        return this.accountGeneration;
-    }
     /** Whether a usable API token currently exists (read fresh from the keystore each call). */
     hasToken() {
-        return !!this.synchronizeAccountContext();
+        return !!this.store.getToken();
     }
     /** The per-process session id — the join key telemetry shares with grouped saves. */
     getSessionId() {
         return this.sessionId;
     }
     getBoundSourceSession() {
-        this.synchronizeAccountContext();
         return this.requestSourceSession.getStore() ?? this.boundSourceSession;
     }
     async withSourceSession(sourceSession, operation) {
         return sourceSession ? this.requestSourceSession.run(sourceSession, operation) : operation();
     }
     async bindSourceSession(verified, persistForBridge = true) {
-        this.synchronizeAccountContext();
         const cached = this.sourceSessionsByCanonicalKey.get(verified.canonicalKey);
         if (cached) {
             if (persistForBridge)
@@ -767,23 +738,16 @@ class EchoMemApiClient {
             return undefined;
         }
     }
-    /** Encryption config for the current account, cached only for the lifetime of its token. */
+    /** Encryption config for the account, fetched once and cached. Failures are not cached. */
     async getEncryptionConfig() {
-        const generation = this.refreshAccountContext();
         if (!this.encConfigPromise) {
-            const request = fetchEncryptionConfig(this.axios).catch((error) => {
-                if (this.encConfigPromise === request)
-                    this.encConfigPromise = null; // allow retry next call
+            this.encConfigPromise = fetchEncryptionConfig(this.axios).catch((error) => {
+                this.encConfigPromise = null; // allow retry next call
                 console.error(`[encryption] config fetch failed: ${describeError(error)} — refusing memory access`);
                 throw new EncryptionStatusUnavailableError("EchoMem could not verify the account encryption state");
             });
-            this.encConfigPromise = request;
         }
-        const request = this.encConfigPromise;
-        const config = await request;
-        if (this.refreshAccountContext() !== generation)
-            return this.getEncryptionConfig();
-        return config;
+        return this.encConfigPromise;
     }
     /**
      * Resolve the encryption state for a read/write. For encrypted accounts this REQUIRES a usable
@@ -791,19 +755,13 @@ class EchoMemApiClient {
      * handing the model ciphertext. For unencrypted accounts it returns `{ enabled: false }`.
      */
     async encState() {
-        const generation = this.refreshAccountContext();
         const cfg = await this.getEncryptionConfig();
-        if (this.refreshAccountContext() !== generation)
-            return this.encState();
         if (!cfg.enabled)
             return { enabled: false };
         const key = this.store.getKey();
         if (!key)
             throw new LockedError("EchoMem vault locked");
-        const isValid = await verifyKeyB64(key, cfg);
-        if (this.refreshAccountContext() !== generation)
-            return this.encState();
-        if (!isValid) {
+        if (!(await verifyKeyB64(key, cfg))) {
             // A file-backed stale key can be removed safely; environment-provided
             // keys remain under the caller's control and are ignored until corrected.
             if (!process.env.ECHO_ENCRYPTION_KEY)
@@ -820,23 +778,16 @@ class EchoMemApiClient {
         }
     }
     async whoami() {
-        const generation = this.refreshAccountContext();
         if (!this.whoamiCache) {
-            const request = this.axios
+            this.whoamiCache = this.axios
                 .get("/api/openclaw/v1/whoami", { timeout: 6000 })
                 .then((response) => response.data)
                 .catch((error) => {
-                if (this.whoamiCache === request)
-                    this.whoamiCache = null;
+                this.whoamiCache = null; // don't pin a token-less failure; retry once a token exists
                 throw error;
             });
-            this.whoamiCache = request;
         }
-        const request = this.whoamiCache;
-        const identity = await request;
-        if (this.refreshAccountContext() !== generation)
-            return this.whoami();
-        return identity;
+        return this.whoamiCache;
     }
     async fetchMemoryById(id, enc) {
         try {
@@ -1303,7 +1254,6 @@ function capWait(pending) {
 class EchoMemMCPServer {
     server;
     client;
-    accountGeneration = 0;
     mapCache = null;
     groupMapCache = null;
     events;
@@ -1376,19 +1326,8 @@ class EchoMemMCPServer {
             platform_source: hostPlatform,
         };
     }
-    refreshAccountContext() {
-        const generation = this.client.refreshAccountContext();
-        if (generation === this.accountGeneration)
-            return;
-        this.accountGeneration = generation;
-        this.mapCache = null;
-        this.groupMapCache = null;
-        this.mapInjected = false;
-        this.groupMapInjected = false;
-    }
     setupToolHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            this.refreshAccountContext();
             const clientVersion = this.server.getClientVersion();
             this.mcpClientName = clientVersion?.name ?? this.mcpClientName;
             this.mcpClientVersion = clientVersion?.version ?? this.mcpClientVersion;
@@ -1420,7 +1359,6 @@ class EchoMemMCPServer {
             return { tools: listToolSpecs({ map, groupMap, updateNotice }) };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-            this.refreshAccountContext();
             const resolvedCanonicalName = resolveCanonicalToolName(request.params.name);
             const recallRoute = routePersonalRecallInvocation(resolvedCanonicalName, request.params.arguments);
             const canonicalName = recallRoute.canonicalName;
@@ -1472,10 +1410,6 @@ class EchoMemMCPServer {
                     if (recallRoute.error) {
                         throw new McpError(ErrorCode.InvalidParams, recallRoute.error);
                     }
-                    // The usage report is a local, $0 audit — works with no login (value before signup).
-                    if (canonicalName === canonicalToolNames.report) {
-                        return { content: [{ type: "text", text: await buildReportText(false) }] };
-                    }
                     if (canonicalName === canonicalToolNames.updateStatus) {
                         if (DESKTOP_MANAGED) {
                             return {
@@ -1671,8 +1605,7 @@ class EchoMemMCPServer {
                     rec.ok = rec.error_kind === "none";
                     rec.latency_ms = Date.now() - t0;
                     this.events.record(rec);
-                    if (canonicalName !== canonicalToolNames.report &&
-                        canonicalName !== canonicalToolNames.updateStatus &&
+                    if (canonicalName !== canonicalToolNames.updateStatus &&
                         canonicalName !== canonicalToolNames.contextHealth &&
                         canonicalName !== canonicalToolNames.recompose &&
                         canonicalName !== canonicalToolNames.save &&
@@ -2764,6 +2697,9 @@ async function main() {
         // inherited descriptor — can't leave the terminal hanging after setup/migrate completes.
         process.exit(process.exitCode ?? 0);
     }
+    // Existing standalone users may receive a new runtime without re-running setup. Refresh only
+    // EchoMem's marker-owned block so stale Desktop-era instructions disappear automatically.
+    refreshInstalledMemoryGuidance();
     const store = new KeyStore();
     // Serve mode is meant to be SPAWNED by the MCP client (editor), which drives us over a piped stdin.
     // A human who runs the bare server in a terminal instead gets a process that blocks forever on stdio