@echomem/mcp 1.4.26 → 1.4.28

package/dist/codex-session-files.js

@@ -5,6 +5,21 @@ const ROLLOUT_FILE_RE = /^rollout-.*\.jsonl$/;
 const UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
 const FIRST_LINE_CHUNK_BYTES = 64 * 1024;
 const MAX_FIRST_LINE_BYTES = 2 * 1024 * 1024;
+function includesCompleteSessionMetadataLine(buffers) {
+    const text = Buffer.concat(buffers).toString("utf8");
+    const lines = text.split(/\r?\n/);
+    if (!text.endsWith("\n"))
+        lines.pop();
+    return lines.some((line) => {
+        try {
+            const row = JSON.parse(line);
+            return isRecord(row) && row.type === "session_meta" && isRecord(row.payload);
+        }
+        catch {
+            return false;
+        }
+    });
+}
 function initialJsonLines(file) {
     const fd = fs.openSync(file, "r");
     try {
@@ -19,6 +34,11 @@ function initialJsonLines(file) {
             const piece = Buffer.from(chunk.subarray(0, bytesRead));
             buffers.push(piece);
             total += bytesRead;
+            // Normal Codex rollouts put session metadata in the first block. Stop as soon as that
+            // complete row is available, while preserving the old 2MB fallback for unusual/legacy
+            // files whose metadata appears later.
+            if (includesCompleteSessionMetadataLine(buffers))
+                break;
         }
         if (!buffers.length)
             return [];

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), 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,13 +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_PERSONAL_MEMORY_WEB_URL = (process.env.ECHO_PERSONAL_MEMORY_WEB_URL || "https://echoknows.com/memories/timeline").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 `${ECHO_PERSONAL_MEMORY_WEB_URL}?memoryId=${encodeURIComponent(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 {
@@ -511,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 {
@@ -978,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);
@@ -1227,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:
@@ -1412,7 +1439,7 @@ class EchoMemMCPServer {
                 return [
                     `[${idx + 1}] ${key}${typeof score === "number" ? ` (score ${score.toFixed(3)})` : ""}`,
                     memoryId ? `Memory ID: ${memoryId}` : "",
-                    memoryId ? `Open private memory: ${personalMemoryWebUrl(memoryId)}` : "",
+                    memoryId ? `Open private memory: ${memoryMarkdownLink(personalMemoryWebUrl(memoryId), key, description)}` : "",
                     meta,
                     `Description: ${description}`,
                     details ? `Details: ${details}` : "",
@@ -1430,7 +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: ${personalMemoryWebUrl(String(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}
@@ -1453,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)
@@ -1472,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)";
@@ -1487,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.`
                 : "",
@@ -1509,7 +1555,7 @@ Details: ${m.details || "N/A"}`)
         }
         const formattedResults = memories
             .map((m, idx) => `[${idx + 1}] Memory ID: ${m.id || "unknown"}
-Open private memory: ${personalMemoryWebUrl(String(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}
@@ -1536,7 +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: ${personalMemoryWebUrl(String(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"}`)
@@ -1616,7 +1662,7 @@ Details: ${m.details || "N/A"}`)
         }
         const formattedResults = memories
             .map((m, idx) => `[${idx + 1}] Memory ID: ${m.id || "unknown"}
-Open private memory: ${personalMemoryWebUrl(String(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}
@@ -1670,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}
@@ -1796,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}` : "",
@@ -1851,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."
@@ -1858,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);
@@ -1906,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.`,
                 }],
         };
     }
@@ -1924,7 +2019,7 @@ Details: ${m.details || "N/A"}`;
                 : null;
             return [
                 `[${index + 1}] Memory ID: ${readString(candidate, "memoryId") ?? "unknown"}`,
-                `Open private memory: ${personalMemoryWebUrl(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") ?? ""}`,

package/dist/migrate.js

@@ -186,14 +186,17 @@ export function normalizeCwd(cwd) {
     const m = cwd.match(/worktrees\/[^/]+\/(.+)$/);
     return m ? m[1] : cwd;
 }
-function userCreatedCodexFiles(codexRoot) {
+function userCreatedCodexSessionFiles(codexRoot) {
     return discoverCodexSessionFiles({
         ...(codexRoot
             ? { roots: [{ kind: "active", path: codexRoot, priority: 0 }] }
             : {}),
         includeArchived: false,
         userInitiatedOnly: true,
-    }).files.map((file) => file.path);
+    }).files;
+}
+function userCreatedCodexFiles(codexRoot) {
+    return userCreatedCodexSessionFiles(codexRoot).map((file) => file.path);
 }
 function userCreatedClaudeFiles(claudeRoot) {
     return walk(claudeRoot, (candidate) => candidate.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows").filter(isUserCreatedClaudeSessionFile);
@@ -312,20 +315,30 @@ function fastSessionInfo(file, source) {
 }
 function fastSessionEntries(opts = {}) {
     const out = [];
-    for (const filePath of userCreatedCodexFiles(opts.codexRoot)) {
-        const stat = statSafe(filePath);
-        const info = fastSessionInfo(filePath, "codex");
-        // Include if we found text OR a real session id (big sessions can have their first text turn beyond
-        // the 1MB probe window — gating only on text dropped them entirely; exact discovery refines later).
-        // We require a real key so the fast/exact conversationKey match (no sha16 fallback mismatch).
-        if (info.hasTextTurn || info.hasRealKey)
-            out.push({ filePath, source: "codex", conversationKey: info.conversationKey, size: stat.size, mtimeMs: stat.mtimeMs });
+    for (const file of userCreatedCodexSessionFiles(opts.codexRoot)) {
+        // Codex discovery has already classified the rollout as user-created and resolved its stable
+        // session key. Do not reread another 1MB of transcript just to rediscover the same ID.
+        const stableId = file.sessionKey.startsWith("session:")
+            ? file.sessionKey.slice("session:".length)
+            : null;
+        const fallback = stableId ? null : fastSessionInfo(file.path, "codex");
+        out.push({
+            filePath: file.path,
+            source: "codex",
+            conversationKey: stableId ? `codex:${stableId}` : fallback?.conversationKey || `codex:${sha16(file.path)}`,
+            size: file.size,
+            mtimeMs: Math.round(file.mtimeMs),
+        });
     }
     const claudeRoot = opts.claudeRoot ?? resolveClaudeProjectsDir();
     if (claudeRoot) {
         for (const filePath of userCreatedClaudeFiles(claudeRoot)) {
             const stat = statSafe(filePath);
-            const info = fastSessionInfo(filePath, "claude-code");
+            const filenameId = path.basename(filePath, path.extname(filePath));
+            const filenameHasStableId = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(filenameId);
+            const info = filenameHasStableId
+                ? { conversationKey: `claude-code:${filenameId.toLowerCase()}`, hasTextTurn: true, hasRealKey: true }
+                : fastSessionInfo(filePath, "claude-code");
             // Same rule as codex: include on text OR a real session id so large sessions aren't undercounted,
             // while keeping the key stable (claude-code sessionId appears on every line, so hasRealKey is reliable).
             if (info.hasTextTurn || info.hasRealKey)