@echomem/mcp 1.4.25 → 1.4.27

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

@@ -378,6 +378,38 @@ function slimScored(row) {
         repo: row.repo,
     };
 }
+/**
+ * The vendored scorer's waste ledger is the canonical classified quantity. Useful context is its
+ * complement inside the provider's official input window. Deriving the complement here prevents a
+ * long floating-point accumulation from making useful + waste exceed the official window.
+ */
+export function reconcileCanonicalTokenPartition(officialInputTokens, wasteTokens) {
+    const input = Math.max(0, Math.round(Number(officialInputTokens) || 0));
+    const waste = Math.max(0, Math.min(input, Math.round(Number(wasteTokens) || 0)));
+    return {
+        officialInputTokens: input,
+        usefulTokens: input - waste,
+        wasteTokens: waste,
+    };
+}
+function reconcileBucketParts(values, target) {
+    const safe = values.map((value) => Math.max(0, Number(value) || 0));
+    const total = safe.reduce((sum, value) => sum + value, 0);
+    const exactTarget = Math.max(0, Math.round(target));
+    if (Math.abs(total - exactTarget) < 1e-9 && safe.every(Number.isInteger))
+        return safe;
+    if (total <= 0)
+        return safe.map((_, index) => index === 0 ? exactTarget : 0);
+    const scaled = safe.map((value) => (value / total) * exactTarget);
+    const result = scaled.map(Math.floor);
+    let remainder = exactTarget - result.reduce((sum, value) => sum + value, 0);
+    const byFraction = scaled
+        .map((value, index) => ({ index, fraction: value - Math.floor(value) }))
+        .sort((a, b) => b.fraction - a.fraction || a.index - b.index);
+    for (let index = 0; index < remainder; index++)
+        result[byFraction[index % byFraction.length].index] += 1;
+    return result;
+}
 function aggregate(scored, metadata) {
     const totals = scored.reduce((sum, row) => {
         const value = row.dashboard.totals;
@@ -402,6 +434,17 @@ function aggregate(scored, metadata) {
             rawBuckets.opt_dead += turn.opt_dead || 0;
         }
     }
+    const partition = reconcileCanonicalTokenPartition(totals.input, totals.waste);
+    const [keepOh, keepProd] = reconcileBucketParts([rawBuckets.keep_oh, rawBuckets.keep_prod], partition.usefulTokens);
+    const [optDup, optRefind, optDead] = reconcileBucketParts([rawBuckets.opt_dup, rawBuckets.opt_refind, rawBuckets.opt_dead], partition.wasteTokens);
+    const reconciledRawBuckets = {
+        keep_oh: keepOh,
+        keep_prod: keepProd,
+        opt_dup: optDup,
+        opt_refind: optRefind,
+        opt_dead: optDead,
+    };
+    const [duplicate, refind, dead, unattributed] = reconcileBucketParts([totals.duplicate, totals.refind, totals.dead, totals.unattributed], partition.wasteTokens);
     const problemRows = new Map();
     for (const id of PROBLEM_IDS)
         problemRows.set(id, { tokens: 0, count: 0, pressure: 0, sessions: 0, examples: [] });
@@ -517,19 +560,19 @@ function aggregate(scored, metadata) {
             sessionsAnalyzed: scored.length,
             reposAnalyzed: repoRows.size,
             turnsAnalyzed: totals.turns,
-            officialInputTokens: totals.input,
-            usefulTokens: totals.useful,
-            wasteTokens: totals.waste,
-            usefulPct: percentage(totals.useful, totals.input),
-            wastePct: percentage(totals.waste, totals.input),
-            attributedWasteTokens: Math.round(Math.max(0, totals.waste - totals.unattributed)),
-            unattributedWasteTokens: totals.unattributed,
-            rawUsefulTokens: rawBuckets.keep_oh + rawBuckets.keep_prod,
-            rawOutcomeResidueTokens: rawBuckets.opt_dup + rawBuckets.opt_refind + rawBuckets.opt_dead,
+            officialInputTokens: partition.officialInputTokens,
+            usefulTokens: partition.usefulTokens,
+            wasteTokens: partition.wasteTokens,
+            usefulPct: percentage(partition.usefulTokens, partition.officialInputTokens),
+            wastePct: percentage(partition.wasteTokens, partition.officialInputTokens),
+            attributedWasteTokens: partition.wasteTokens - unattributed,
+            unattributedWasteTokens: unattributed,
+            rawUsefulTokens: keepOh + keepProd,
+            rawOutcomeResidueTokens: optDup + optRefind + optDead,
             excludedUnlabeledTokens: totals.excluded,
         },
-        buckets: { duplicate: totals.duplicate, refind: totals.refind, dead: totals.dead, unattributed: totals.unattributed },
-        rawBuckets,
+        buckets: { duplicate, refind, dead, unattributed },
+        rawBuckets: reconciledRawBuckets,
         problems,
         sessions,
         repos: [...repoRows.entries()].map(([repo, values]) => ({ repo, ...values })).sort((a, b) => b.officialInputTokens - a.officialInputTokens),

package/dist/forensics.js

@@ -1373,8 +1373,25 @@ export async function buildForensicReport(opts) {
         : [];
     const total = codexFiles.length + claudeFiles.length;
     let done = 0;
-    const progress = (stage, detail, progressDone = done, progressTotal = total) => {
-        opts?.onProgress?.(progressDone, progressTotal, stage, detail);
+    // Every stage reports the same file counters as scanned/total, so the visible "N of M sessions
+    // scanned" only ever climbs. A stage's own counters (the canonical pass counts a different set,
+    // on a different scale) drive nothing but its slice of the overall bar — feeding them straight
+    // into scanned/total is what made the bar and the caption fall back partway through the scan.
+    const STAGE_BANDS = {
+        "reading-transcripts": [0, 0.7],
+        "building-summary": [0.7, 0.75],
+        "classifying-repeated-context": [0.75, 0.95],
+        "finalizing-report": [0.95, 1],
+    };
+    const overallFor = (stage, stageDone, stageTotal) => {
+        const band = STAGE_BANDS[stage];
+        if (!band)
+            return 0;
+        const ratio = stageTotal > 0 ? Math.min(1, Math.max(0, stageDone / stageTotal)) : 0;
+        return band[0] + (band[1] - band[0]) * ratio;
+    };
+    const progress = (stage, detail, stageDone = done, stageTotal = total) => {
+        opts?.onProgress?.(done, total, stage, detail, overallFor(stage, stageDone, stageTotal));
     };
     progress("reading-transcripts", "finding local Codex and Claude transcript files");
     const tick = (stage = "reading-transcripts") => {
@@ -1417,7 +1434,10 @@ export async function buildForensicReport(opts) {
     timelineFiles.sort((a, b) => (a.fe.firstTs ?? Number.POSITIVE_INFINITY) - (b.fe.firstTs ?? Number.POSITIVE_INFINITY) ||
         a.path.localeCompare(b.path));
     replayTimelineFiles(eng, timelineFiles);
-    progress("building-summary", "aggregating rereads, model usage, cost, and local context signals");
+    // Entering a stage means it has done none of its own work yet, so it opens its band rather than
+    // inheriting the finished file counters — otherwise a stage announces itself at its band ceiling
+    // and its real sub-progress then drags the bar back down.
+    progress("building-summary", "aggregating rereads, model usage, cost, and local context signals", 0, 1);
     const report = eng.build();
     const firstTimelineSession = timelineFiles.find(({ fe }) => fe.firstTs != null);
     report.firstSession = firstTimelineSession ? {
@@ -1461,7 +1481,7 @@ export async function buildForensicReport(opts) {
             canonicalSources.push("codex");
         if (sources.includes("claude"))
             canonicalSources.push("claude-code");
-        progress("classifying-repeated-context", "reconstructing context windows and attributing P01/P03/P08/P10/P13 waste");
+        progress("classifying-repeated-context", "reconstructing context windows and attributing P01/P03/P08/P10/P13 waste", 0, 1);
         report.canonicalGoldenStandard = await buildCanonicalGoldenReport({
             sources: canonicalSources,
             codexSessionPaths: canonicalCodexFiles,

package/dist/hud/cli.js

@@ -5,11 +5,12 @@ import { fileURLToPath } from "node:url";
 import { adapterList } from "./adapters.js";
 import { autostartPlistPath, autostartSupported, disableAutostart, enableAutostart, isAutostartEnabled } from "./autostart.js";
 import { statSignature } from "./fs.js";
-import { installHooks } from "./hooks.js";
+import { installHooks, installSaveCheckpointHooks } from "./hooks.js";
 import { HudMonitor } from "./monitor.js";
 import { renderStateText } from "./render.js";
 import { renderReportText, runReport } from "./report.js";
 import { createHudServer } from "./server.js";
+import { runSaveCheckpointHook } from "../save-checkpoint-hook.js";
 const argv = process.argv.slice(2);
 const command = argv[0] || "summary";
 const flags = parseFlags(argv.slice(1));
@@ -24,6 +25,10 @@ try {
         await cmdApp(flags);
     else if (command === "install-hooks")
         await cmdInstallHooks(flags);
+    else if (command === "install-save-hooks")
+        await cmdInstallSaveHooks(flags);
+    else if (command === "save-checkpoint")
+        await cmdSaveCheckpoint();
     else if (command === "autostart")
         cmdAutostart(argv[1] || "status", flags);
     else if (command === "status")
@@ -114,6 +119,17 @@ async function cmdInstallHooks(flags) {
     console.log(`Installed EchoMem HUD hook support:\n${paths.map((p) => `- ${p}`).join("\n")}`);
     console.log("Codex users: run /hooks in a new Codex session to review and trust changed hooks.");
 }
+async function cmdInstallSaveHooks(flags) {
+    const paths = installSaveCheckpointHooks(parseMode(flags.client));
+    console.log(`Installed EchoMem private-save checkpoint hooks:\n${paths.map((p) => `- ${p}`).join("\n")}`);
+    console.log("Codex users: run /hooks in a new Codex session to review and trust changed hooks.");
+}
+async function cmdSaveCheckpoint() {
+    let input = "";
+    for await (const chunk of process.stdin)
+        input += String(chunk);
+    process.stdout.write(runSaveCheckpointHook(input));
+}
 async function cmdReport(flags) {
     const result = runReport(parseMode(flags.client), { limit: readNumber(flags.limit, 40) });
     if (flags.json)
@@ -166,6 +182,7 @@ Usage:
   echomem-hud serve [--client codex|claude-code|claude-desktop|both|auto] [--port 17377]
   echomem-hud app [--client codex|claude-code|claude-desktop|both|auto]
   echomem-hud install-hooks [--client codex|claude-code|both]
+  echomem-hud install-save-hooks [--client codex|claude-code|both]
   echomem-hud autostart on|off|status   (show the HUD after restart — macOS)
   echomem-hud status
   echomem-hud report [--client codex|claude-code|claude-desktop|auto] [--limit 40] [--json]

package/dist/hud/hooks.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 export function installHooks(mode) {
     const written = [];
     if (mode === "codex" || mode === "both" || mode === "auto") {
@@ -11,6 +12,16 @@ export function installHooks(mode) {
     }
     return written;
 }
+export function installSaveCheckpointHooks(mode) {
+    const written = [];
+    if (mode === "codex" || mode === "both" || mode === "auto") {
+        written.push(installCodexSaveCheckpointHook());
+    }
+    if (mode === "claude-code" || mode === "both" || mode === "auto") {
+        written.push(installClaudeCodeSaveCheckpointHook());
+    }
+    return written;
+}
 function installCodexHooks() {
     const dir = path.join(os.homedir(), ".codex");
     const file = path.join(dir, "hooks.json");
@@ -24,6 +35,44 @@ function installCodexHooks() {
     fs.writeFileSync(file, JSON.stringify(content, null, 2));
     return file;
 }
+function saveCheckpointCommand() {
+    const lifecycleCli = fileURLToPath(new URL("./cli.js", import.meta.url));
+    return `${JSON.stringify(process.execPath)} ${JSON.stringify(lifecycleCli)} save-checkpoint`;
+}
+function installCodexSaveCheckpointHook() {
+    const dir = path.join(os.homedir(), ".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",
+            }],
+    });
+    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    return file;
+}
+function installClaudeCodeSaveCheckpointHook() {
+    const dir = path.join(os.homedir(), ".claude");
+    const file = path.join(dir, "settings.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",
+            }],
+    });
+    fs.writeFileSync(file, JSON.stringify(content, null, 2));
+    return file;
+}
 function installClaudeCodeSnippet() {
     const dir = path.join(os.homedir(), ".claude", "echo-ctx");
     fs.mkdirSync(dir, { recursive: true });
@@ -43,8 +92,18 @@ function mergeHookGroup(existing, group) {
     groups.push(group);
     return groups;
 }
+function mergeSaveCheckpointGroup(existing, group) {
+    const groups = Array.isArray(existing) ? existing.filter((item) => !isEchoSaveCheckpointGroup(item)) : [];
+    groups.push(group);
+    return groups;
+}
 function isEchoHudGroup(value) {
     if (typeof value !== "object" || value === null)
         return false;
     return JSON.stringify(value).includes("summary --client codex --json");
 }
+function isEchoSaveCheckpointGroup(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return JSON.stringify(value).includes("save-checkpoint");
+}

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import { ZodError } from "zod";
-import { canonicalToolNames, completeGroupPublicationSchema, createGroupInviteSchema, createGroupSchema, deleteMemorySchema, flagPublicationAttentionSchema, getByContextSchema, groupContextSchema, joinGroupSchema, keywordsSchema, listFriendsSchema, listToolSpecs, othersSchema, publishBatchToGroupSchema, publishToGroupSchema, prepareGroupPublicationSchema, publicMemorySchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, searchUsersSchema, sendFriendRequestSchema, timeRangeSchema, updateGroupProfileSchema, } from "./v1-contract.js";
+import { canonicalToolNames, completeGroupPublicationSchema, createGroupInviteSchema, createGroupSchema, deleteMemorySchema, flagPublicationAttentionSchema, getGroupSessionSharingSchema, getByContextSchema, groupContextSchema, joinGroupSchema, keywordsSchema, listFriendsSchema, listToolSpecs, othersSchema, publishBatchToGroupSchema, publishToGroupSchema, prepareGroupPublicationSchema, publicMemorySchema, 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";
@@ -17,9 +17,20 @@ import { clearBillingAlert, writeBillingAlert } from "./billing-alert.js";
 import { checkLatestUpdateStatus, formatUpdateNotice, formatUpdateStatusText, startBackgroundUpdateCheck, } from "./update-check.js";
 const ECHO_API_BASE_URL = process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app";
 const ECHO_PRICING_URL = process.env.ECHO_PRICING_URL || "https://echoknows.com/account";
-const ECHO_MEMORY_WEB_URL = (process.env.ECHO_MEMORY_WEB_URL || "https://echoknows.com/company/memories").replace(/\/$/, "");
+const ECHO_MEMORY_WEB_URL = (process.env.ECHO_MEMORY_WEB_URL || "https://echoknows.com/memory").replace(/\/$/, "");
 function memoryWebUrl(memoryId) {
-    return `${ECHO_MEMORY_WEB_URL}?memoryId=${encodeURIComponent(memoryId)}`;
+    return `${ECHO_MEMORY_WEB_URL}/${encodeURIComponent(memoryId)}`;
+}
+function personalMemoryWebUrl(memoryId) {
+    return memoryWebUrl(memoryId);
+}
+function memoryMarkdownLink(url, keys, description) {
+    const rawLabel = String(keys || description || "Open memory").replace(/\s+/g, " ").trim();
+    const label = (rawLabel.length > 100 ? `${rawLabel.slice(0, 97).trim()}…` : rawLabel)
+        .replace(/\\/g, "\\\\")
+        .replace(/\[/g, "\\[")
+        .replace(/\]/g, "\\]");
+    return `[${label}](${url})`;
 }
 /** Thrown when no API token is present yet — the model gets a "run login" nudge, not a hard error. */
 class NoTokenError extends Error {
@@ -507,6 +518,11 @@ function inputAnalyticsForTool(canonicalName, args) {
                 confirmed: a.confirmed === true,
             };
         }
+        case canonicalToolNames.setGroupSessionSharing:
+            return {
+                share_to_group: typeof a.share === "boolean" ? a.share : undefined,
+                confirmed: a.confirmed === true,
+            };
         case canonicalToolNames.publishBatchToGroup: {
             const memoryIds = Array.isArray(a.memoryIds) ? a.memoryIds.filter((id) => typeof id === "string") : [];
             return {
@@ -974,6 +990,17 @@ class EchoMemApiClient {
             throw new Error(`get_group_context failed against ${ECHO_API_BASE_URL}: ${describeError(error)}`);
         }
     }
+    async getGroupSessionSharing(args) {
+        getGroupSessionSharingSchema.parse(args ?? {});
+        const response = await this.axios.get(`/api/extension/social/groups/current/session-sharing?sessionKey=${encodeURIComponent(this.sessionId)}`);
+        return response.data;
+    }
+    async setGroupSessionSharing(args) {
+        const parsed = setGroupSessionSharingSchema.parse(args ?? {});
+        const enc = await this.encState();
+        const response = await this.axios.patch("/api/extension/social/groups/current/session-sharing", { ...parsed, sessionKey: this.sessionId }, { headers: enc.enabled && enc.key ? { "X-Encryption-Key": enc.key } : undefined });
+        return response.data;
+    }
     async createGroup(args) {
         const parsed = createGroupSchema.parse(args ?? {});
         const response = await this.axios.post("/api/extension/social/groups", parsed);
@@ -1223,6 +1250,10 @@ class EchoMemMCPServer {
                         return await this.handlePublicMemory(request.params.arguments);
                     case canonicalToolNames.groupContext:
                         return await this.handleGroupContext(request.params.arguments);
+                    case canonicalToolNames.getGroupSessionSharing:
+                        return await this.handleGetGroupSessionSharing(request.params.arguments);
+                    case canonicalToolNames.setGroupSessionSharing:
+                        return await this.handleSetGroupSessionSharing(request.params.arguments);
                     case canonicalToolNames.createGroup:
                         return await this.handleCreateGroup(request.params.arguments);
                     case canonicalToolNames.createGroupInvite:
@@ -1404,8 +1435,11 @@ class EchoMemMCPServer {
                     : m.details == null
                         ? ""
                         : String(m.details).trim();
+                const memoryId = readString(m, "id");
                 return [
                     `[${idx + 1}] ${key}${typeof score === "number" ? ` (score ${score.toFixed(3)})` : ""}`,
+                    memoryId ? `Memory ID: ${memoryId}` : "",
+                    memoryId ? `Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(memoryId), key, description)}` : "",
                     meta,
                     `Description: ${description}`,
                     details ? `Details: ${details}` : "",
@@ -1423,6 +1457,7 @@ class EchoMemMCPServer {
         }
         const formattedResults = memories
             .map((m, idx) => `[Result ${idx + 1}] Memory ID: ${m.id || "unknown"} (Similarity: ${m.similarity_score?.toFixed(3) || "N/A"})
+Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(String(m.id || "unknown")), m.keys, m.description)}
 Time: ${m.time} | Location: ${m.location}
 Category: ${m.category} | Object: ${m.object} | Emotion: ${m.emotion}
 Description: ${m.description}
@@ -1445,7 +1480,7 @@ Details: ${m.details || "N/A"}`)
             rec.conversation_chars = text.length;
             rec.save_source = typeof a?.source === "string" ? a.source : sourceFallback;
         }
-        const { success, memoriesExtracted, memoriesDiscarded, extractedMemories, contextId, capsuleId, passthrough: isPassthrough, error } = await this.client.saveConversation(enrichedArgs);
+        const { success, memoriesExtracted, memoriesDiscarded, extractedMemories, contextId, capsuleId, passthrough: isPassthrough, groupSessionSharing, groupSync, error, } = await this.client.saveConversation(enrichedArgs);
         if (!success)
             throw new Error(`EchoMem API Error: ${error}`);
         if (rec)
@@ -1464,6 +1499,24 @@ Details: ${m.details || "N/A"}`)
         // Surface WHAT was captured (not just the count) so the agent can verify the key facts survived
         // extraction, and so it holds the ids to deterministically re-fetch this batch later (warm-up).
         const saved = Array.isArray(extractedMemories) ? extractedMemories.filter(isRecord) : [];
+        const sharing = isRecord(groupSessionSharing) ? groupSessionSharing : null;
+        const sync = isRecord(groupSync) ? groupSync : null;
+        const sharingGroup = isRecord(sharing?.group) ? sharing.group : {};
+        const protectedIds = Array.isArray(sync?.protectedMemoryIds) ? sync.protectedMemoryIds : [];
+        const receipt = sharing?.hasGroup !== true
+            ? "Saved to your private memory."
+            : sharing?.decision === null || sharing?.decision === undefined
+                ? `Saved to your private memory. Ask once: “Share memories saved from this session with ${readString(sharingGroup, "name") ?? "your current group"}?” Then call set_group_session_sharing with the confirmed answer.`
+                : sharing.decision === "private"
+                    ? "Saved to your private memory."
+                    : sync?.synced === true
+                        ? [
+                            "Saved to your private memory and synced to the group.",
+                            protectedIds.length
+                                ? `${protectedIds.length} protected memory item(s) stayed private.`
+                                : "",
+                        ].filter(Boolean).join(" ")
+                        : `Saved to your private memory, but group sync failed${readString(sync ?? {}, "error") ? `: ${readString(sync ?? {}, "error")}` : "."}`;
         const list = saved
             .map((m, idx) => {
             const keys = readString(m, "keys") ?? "(no key)";
@@ -1479,6 +1532,7 @@ Details: ${m.details || "N/A"}`)
             .join("\n\n");
         const text = [
             `Successfully ingested conversation. Extracted ${memoriesExtracted} memory distinct events.`,
+            receipt,
             typeof memoriesDiscarded === "number" && memoriesDiscarded > 0
                 ? `${memoriesDiscarded} additional memories were not stored because your active-memory limit was reached.`
                 : "",
@@ -1500,7 +1554,9 @@ Details: ${m.details || "N/A"}`)
             };
         }
         const formattedResults = memories
-            .map((m, idx) => `[${idx + 1}] Time: ${m.time} | Location: ${m.location}
+            .map((m, idx) => `[${idx + 1}] Memory ID: ${m.id || "unknown"}
+Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(String(m.id || "unknown")), m.keys, m.description)}
+Time: ${m.time} | Location: ${m.location}
 Category: ${m.category} | Object: ${m.object} | Emotion: ${m.emotion}
 Description: ${m.description}
 Details: ${m.details || "N/A"}`)
@@ -1526,6 +1582,7 @@ Details: ${m.details || "N/A"}`)
         }
         const formattedResults = memories
             .map((m, idx) => `[${idx + 1}] ${m.keys || "Saved memory"}${m.id ? ` · id ${m.id}` : ""}
+${m.id ? `Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(String(m.id)), m.keys, m.description)}` : ""}
 Time: ${m.time} | Category: ${m.category} | Object: ${m.object} | Emotion: ${m.emotion}
 Description: ${m.description}
 Details: ${m.details || "N/A"}`)
@@ -1604,7 +1661,9 @@ Details: ${m.details || "N/A"}`)
             };
         }
         const formattedResults = memories
-            .map((m, idx) => `[${idx + 1}] Time: ${m.time} | Keys: ${m.keys || "N/A"}
+            .map((m, idx) => `[${idx + 1}] Memory ID: ${m.id || "unknown"}
+Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(String(m.id || "unknown")), m.keys, m.description)}
+Time: ${m.time} | Keys: ${m.keys || "N/A"}
 Location: ${m.location} | Category: ${m.category} | Object: ${m.object}
 Description: ${m.description}
 Details: ${m.details || "N/A"}`)
@@ -1657,7 +1716,7 @@ Details: ${m.details || "N/A"}`)
                     ? m.similarity_score
                     : undefined;
             return `[${idx + 1}] Memory ID: ${m.id || "unknown"}
-Open memory: ${memoryWebUrl(String(m.id || "unknown"))}
+Open memory: ${memoryMarkdownLink(memoryWebUrl(String(m.id || "unknown")), m.keys, m.description)}
 User ID: ${m.user_id || "unknown"}
 User Name: ${m.username || m.user_name || m.name || "Anonymous"}
 Time: ${m.time} | Location: ${m.location}
@@ -1783,7 +1842,7 @@ Details: ${m.details || "N/A"}`;
         }
         const text = [
             `Memory ID: ${memory.id || parsed.memoryId}`,
-            `Open memory: ${memoryWebUrl(String(memory.id || parsed.memoryId))}`,
+            `Open memory: ${memoryMarkdownLink(memoryWebUrl(String(memory.id || parsed.memoryId)), memory.keys, memory.description)}`,
             `Owner User ID: ${memory.owner_user_id || memory.user_id || "Unknown"}`,
             memory.time ? `Time: ${memory.time}` : "",
             memory.location ? `Location: ${memory.location}` : "",
@@ -1838,6 +1897,7 @@ Details: ${m.details || "N/A"}`;
             participantText,
             "",
             "Declared titles and responsibilities are directory facts. Use search_others_memories for current work evidence, and label suggested contribution areas as inference that should be confirmed with the team.",
+            "Use get_group_session_sharing to read this exact session's decision; never infer sharing from the member's role or memories.",
             currentParticipant
                 && (!readString(currentParticipant, "title") || !readString(currentParticipant, "responsibilitySummary"))
                 ? "Your group profile is incomplete. Use prepare_group_publication to review your memory evidence, propose the missing fields, and save them only after confirmation with update_group_profile."
@@ -1845,6 +1905,54 @@ Details: ${m.details || "N/A"}`;
         ].filter(Boolean).join("\n");
         return { content: [{ type: "text", text }] };
     }
+    async handleGetGroupSessionSharing(args) {
+        getGroupSessionSharingSchema.parse(args ?? {});
+        const payload = await this.client.getGroupSessionSharing(args);
+        if (payload?.hasGroup !== true) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "No company group is configured for this user. Saves remain private; do not ask about session sharing.",
+                    }],
+            };
+        }
+        const group = isRecord(payload?.group) ? payload.group : {};
+        const decision = typeof payload?.decision === "string" ? payload.decision : null;
+        if (!decision) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No sharing decision exists for this session. Ask once: “Share memories saved from this session with ${readString(group, "name") ?? "your group"}?” Then call set_group_session_sharing with the explicit Yes/No answer.`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: decision === "share"
+                        ? `This session is approved for ${readString(group, "name") ?? "the current group"}. Each save persists privately first, then eligible memories sync automatically. Flagged memories stay private.`
+                        : "This session is private. Future saves remain private unless the user explicitly changes this session's decision.",
+                }],
+        };
+    }
+    async handleSetGroupSessionSharing(args) {
+        const parsed = setGroupSessionSharingSchema.parse(args ?? {});
+        const payload = await this.client.setGroupSessionSharing(parsed);
+        const sync = isRecord(payload?.sync) ? payload.sync : null;
+        const protectedIds = Array.isArray(sync?.protectedMemoryIds) ? sync.protectedMemoryIds : [];
+        const group = isRecord(payload?.group) ? payload.group : {};
+        const receipt = parsed.share
+            ? sync?.synced === false
+                ? "Session sharing is enabled, but the initial group sync failed. Private memories were preserved; retry before claiming publication."
+                : `Session sharing is enabled for ${readString(group, "name") ?? "the current group"}. Existing eligible session memories were synced and later saves will sync automatically.`
+            : "Session sharing is off. Future saves in this session remain private.";
+        return {
+            content: [{
+                    type: "text",
+                    text: `${receipt}${protectedIds.length ? ` ${protectedIds.length} flagged ${protectedIds.length === 1 ? "memory was" : "memories were"} protected and kept private.` : ""}`,
+                }],
+        };
+    }
     async handlePublishToGroup(args) {
         const parsed = publishToGroupSchema.parse(args ?? {});
         const payload = await this.client.publishMemoryToGroup(args);
@@ -1893,8 +2001,8 @@ Details: ${m.details || "N/A"}`;
             content: [{
                     type: "text",
                     text: payload?.alreadyMember
-                        ? `You are already a member of ${payload?.group?.name ?? "this group"}. No memories were published. Use prepare_group_publication to review memories and propose any missing title or responsibility fields.`
-                        : `Joined ${payload?.group?.name ?? "the company group"}. No memories were published. Next use prepare_group_publication to review candidates, infer a proposed title and responsibility summary, and ask the user to confirm that profile together with the publication preview.`,
+                        ? `You are already a member of ${payload?.group?.name ?? "this group"}. No memories were published. Use prepare_group_publication to review memories and propose any missing title or responsibility fields, then call get_group_session_sharing and ask once if this session has no decision.`
+                        : `Joined ${payload?.group?.name ?? "the company group"}. No memories were published. Next use prepare_group_publication to review candidates, infer a proposed title and responsibility summary, and ask the user to confirm that profile together with the publication preview. Also call get_group_session_sharing; if unset, ask once whether memories saved from this session should be shared.`,
                 }],
         };
     }
@@ -1911,7 +2019,7 @@ Details: ${m.details || "N/A"}`;
                 : null;
             return [
                 `[${index + 1}] Memory ID: ${readString(candidate, "memoryId") ?? "unknown"}`,
-                `Open memory: ${memoryWebUrl(readString(candidate, "memoryId") ?? "unknown")}`,
+                `Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(readString(candidate, "memoryId") ?? "unknown"), readString(candidate, "keys"), readString(candidate, "description"))}`,
                 `Created: ${readString(candidate, "createdAt") ?? "unknown"}`,
                 `Category: ${readString(candidate, "category") ?? "unknown"}`,
                 `Description: ${readString(candidate, "description") ?? ""}`,
@@ -1938,9 +2046,9 @@ Details: ${m.details || "N/A"}`;
                         formatted,
                         "",
                         flaggedIds.length
-                            ? `Extra attention required: ${flaggedIds.length} candidate(s) are flagged (${flaggedIds.join(", ")}). Show them in a separate warning and require a separate explicit acknowledgement before including their exact IDs in acknowledgedFlaggedMemoryIds.`
+                            ? `Extra attention required: ${flaggedIds.length} candidate(s) are flagged (${flaggedIds.join(", ")}). Nothing has been published. Show them in a separate warning and offer to exclude them, review them separately, or first search for and mark similar sensitive owned memories for publication attention. Never auto-flag based on inference. Require separate explicit acknowledgement before including their exact IDs in acknowledgedFlaggedMemoryIds.`
                             : "",
-                        "Select exact memory IDs matching the user's instruction. From memory evidence, draft a concise title and responsibility summary. Show the profile proposal and memory preview together, then ask for explicit confirmation. After confirmation, call update_group_profile and complete_group_publication.",
+                        "Select exact memory IDs matching the user's instruction. From memory evidence, draft a concise title and responsibility summary. If an unflagged candidate appears sensitive, proactively ask whether the user wants to mark its exact ID for publication attention first. Explain that marking does not publish or change encryption; it means you will call it out and ask for detailed confirmation whenever a later publication includes it. Never auto-flag. Show the profile proposal and memory preview together, then ask for explicit confirmation. After confirmation, call update_group_profile and complete_group_publication.",
                     ].join("\n"),
                 }],
         };
@@ -1958,6 +2066,7 @@ Details: ${m.details || "N/A"}`;
                         `Flagged ${payload?.flaggedCount ?? parsed.memoryIds.length} memories for publication attention.`,
                         `Label: ${parsed.label}`,
                         `Memory IDs: ${parsed.memoryIds.join(", ")}`,
+                        `Private review links:\n${parsed.memoryIds.map((memoryId) => `- ${memoryId}: ${personalMemoryWebUrl(memoryId)}`).join("\n")}`,
                         "No memory was published, decrypted, or made globally public.",
                         alreadyPublished > 0
                             ? `Attention: ${alreadyPublished} flagged memories already have group snapshots. This flag does not retract those existing snapshots.`

package/dist/package-metadata.js

@@ -28,11 +28,14 @@ export const MCP_SERVER_INSTRUCTIONS = [
     `If the user or local config expects a newer EchoMem MCP version than ${MCP_PACKAGE_VERSION}, update once with \`${MCP_UPDATE_ALL_COMMAND}\` and start a new MCP session.`,
     "Use echomem_update_status to check whether npm has a newer bridge; it is cached and non-blocking during normal tool listing.",
     "Do not auto-update on every MCP startup; this bridge is intentionally stable between explicit updates.",
+    "Before the final response for work that produced a durable decision, confirmed preference, implementation, resolved bug, commit, passing verification, release, or project milestone, call save_conversation. This is a private checkpoint and does not require a separate user request. Skip secrets, incidental chatter, and trivial read-only work. If an encrypted vault is locked, tell the user to run echomem-mcp unlock rather than silently skipping the checkpoint.",
+    "For a user with a company group, call get_group_session_sharing near session start or after the first qualifying private save. If this exact session has no decision, ask once whether memories saved from the session should be shared with the current group, then store only the explicit Yes/No answer with set_group_session_sharing. A Yes decision syncs eligible memories after each private save; a No decision keeps later saves private. Flagged memories stay private.",
     "For company-group sharing, use get_group_context for orientation; create_memory_group/create_group_invite/join_memory_group for membership; and prepare_group_publication as a no-publication preview.",
     "After joining or when profile fields are missing, use candidate memory evidence to propose a title and responsibility summary. Ask the user to confirm that proposal together with the publication preview, then call update_group_profile and complete_group_publication.",
-    "Each group-search result is one memory: preserve its Memory ID and direct echoknows.com link when citing it.",
-    "For sensitive-topic flags, search and preview exact owned memories before confirmed flag_memories_for_publication_attention. During publication, separate flagged candidates and require exact-ID acknowledgement.",
-    "Never save an inferred group profile or complete a group publication without explicit confirmation, and never store or log an echo_grp_ invite code.",
+    "Use one canonical https://echoknows.com/memory/<memory-id> link for private, group, and friend evidence. Label it with the memory key; the site resolves the authorized representation.",
+    "Each search result is one memory: preserve its Memory ID and canonical echoknows.com link when citing it.",
+    "During a publication preview, if an unflagged candidate appears sensitive, proactively ask whether the user wants to mark its exact ID for publication attention first. Explain that marking does not publish or change encryption; it means the agent will call it out and ask for detailed confirmation whenever a later publication includes it. Never auto-flag inferred sensitivity. For sensitive-topic flags, search and preview exact owned memories before confirmed flag_memories_for_publication_attention. Separate already-flagged candidates, state that nothing has been published yet, and offer to exclude them, review them separately, or first search for and mark similar sensitive owned memories.",
+    "Never save an inferred group profile. Manual prepared publication requires explicit preview confirmation; flagged memories still require separate exact-memory confirmation. Never store or log an echo_grp_ invite code.",
 ].join(" ");
 export function withMcpVersion(description) {
     return `${description}\n\nEchoMem MCP bridge: ${MCP_PACKAGE_LABEL}. If this version is stale, update once with \`${MCP_UPDATE_ALL_COMMAND}\` (or add \`--client cursor|windsurf|claude-desktop|claude-code|codex\` for a single client), then start a new MCP session. Do not run updates repeatedly or on every startup.`;