@ephemushroom/opencode-claude-mem 0.5.0 → 0.6.1

package/dist/index.js

@@ -16,7 +16,6 @@ var __export = (target, all) => {
 
 // src/shared.ts
 var MAX_OBSERVATION_BYTES = 24 * 1024;
-var MAX_TAG_REPLACEMENTS = 100;
 var META_TOOLS = new Set([
   "askuserquestion",
   "getmcpresource",
@@ -29,26 +28,27 @@ var META_TOOLS = new Set([
   "slashcommand",
   "todowrite"
 ]);
-var PRIVATE_TAG_REGEX = /<private>[\s\S]*?<\/private>/g;
-var CONTEXT_TAG_REGEX = /<claude-mem-context>[\s\S]*?<\/claude-mem-context>/g;
 function stripTaggedContent(text) {
-  if (!text) {
-    return text;
-  }
-  let result = text;
-  let replacements = 0;
-  while (replacements < MAX_TAG_REPLACEMENTS && PRIVATE_TAG_REGEX.test(result)) {
-    PRIVATE_TAG_REGEX.lastIndex = 0;
-    result = result.replace(PRIVATE_TAG_REGEX, "");
-    replacements++;
+  let result = "";
+  let offset = 0;
+  const stack = [];
+  for (const match of text.matchAll(/<(\/?)(private|claude-mem-context)\b[^>]*>/gi)) {
+    if (stack.length === 0) {
+      result += text.slice(offset, match.index);
+    }
+    const name = match[2].toLowerCase();
+    if (match[1] === "/") {
+      if (stack.at(-1) === name) {
+        stack.pop();
+      }
+    } else {
+      stack.push(name);
+    }
+    offset = match.index + match[0].length;
   }
-  PRIVATE_TAG_REGEX.lastIndex = 0;
-  while (replacements < MAX_TAG_REPLACEMENTS && CONTEXT_TAG_REGEX.test(result)) {
-    CONTEXT_TAG_REGEX.lastIndex = 0;
-    result = result.replace(CONTEXT_TAG_REGEX, "");
-    replacements++;
+  if (stack.length === 0) {
+    result += text.slice(offset);
   }
-  CONTEXT_TAG_REGEX.lastIndex = 0;
   return result.trim();
 }
 function sanitizeObservationValue(value) {
@@ -90,7 +90,7 @@ function shouldSkipObservationTool(toolName) {
     return true;
   }
   const normalizedName = toolName.toLowerCase().replaceAll("_", "-");
-  if (normalizedName.includes("mcp-search") || /(?:^|[-.])mem-(?:search|timeline|get-observations)$/.test(normalizedName)) {
+  if (normalizedName.includes("mcp-search") || /(?:^|[-.])mem-(?:save|search|timeline|get-observations)$/.test(normalizedName)) {
     return true;
   }
   return META_TOOLS.has(normalizedName);
@@ -12436,6 +12436,44 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/memory-turn.ts
+function memoryTurn(id, text, media = false) {
+  const cleaned = stripTaggedContent(text.replace(/<(system-reminder|system_instruction|system-instruction|persisted-output)\b[^>]*>[\s\S]*?<\/\1>/gi, ""));
+  const internal = /^\s*<task-notification\b[^>]*>[\s\S]*?<\/task-notification>\s*$/i.test(text);
+  return {
+    id,
+    text: truncateUtf8Bytes(cleaned || (media ? "[media prompt]" : ""), 256 * 1024),
+    capture: !internal && (Boolean(cleaned) || media && !text.trim()),
+    semantic: !internal && cleaned.length >= 20
+  };
+}
+var deliveredRecord = object({
+  id: string2(),
+  type: string2(),
+  text: string2().optional(),
+  files: array(unknown()).optional(),
+  metadata: object({ synthetic: boolean2().optional(), agentId: string2().optional() }).optional()
+});
+var v1Record = object({
+  info: object({ id: string2(), role: string2() }),
+  parts: array(unknown())
+});
+function resumedV1Turn(messages) {
+  if (!Array.isArray(messages)) {
+    return;
+  }
+  for (const raw of messages.toReversed()) {
+    const parsed = v1Record.safeParse(raw);
+    if (parsed.success && parsed.data.info.role === "user") {
+      return memoryTurn(parsed.data.info.id, extractTextFromParts(parsed.data.parts), parsed.data.parts.some((part) => typeof part === "object" && part !== null && ("type" in part) && part.type === "file"));
+    }
+  }
+  return;
+}
+
+// src/file-context.ts
+import { relative, resolve } from "path";
+
 // src/worker-client.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
@@ -12636,7 +12674,16 @@ class WorkerClient {
       if (!response.ok) {
         return null;
       }
-      return await response.json();
+      const value = await response.json();
+      if (!isRecord(value) || typeof value.sessionDbId !== "number" || typeof value.promptNumber !== "number" || !Number.isFinite(value.sessionDbId) || !Number.isFinite(value.promptNumber)) {
+        return null;
+      }
+      return {
+        sessionDbId: value.sessionDbId,
+        promptNumber: value.promptNumber,
+        skipped: value.skipped === true,
+        reason: typeof value.reason === "string" ? value.reason : undefined
+      };
     } catch {
       return null;
     }
@@ -12670,8 +12717,8 @@ class WorkerClient {
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           contentSessionId,
-          last_user_message: lastUserMessage,
-          last_assistant_message: lastAssistantMessage,
+          last_user_message: stripTaggedContent(lastUserMessage),
+          last_assistant_message: stripTaggedContent(lastAssistantMessage),
           platformSource: PLATFORM_SOURCE,
           observedModel: metadata.observedModel,
           observedBilling: metadata.observedBilling
@@ -12684,7 +12731,7 @@ class WorkerClient {
   }
   static async getContext(project) {
     try {
-      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`);
+      const response = await fetch(`${this.BASE_URL}/api/context/inject?project=${encodeURIComponent(project)}`, { signal: AbortSignal.timeout(2000) });
       if (!response.ok) {
         return null;
       }
@@ -12835,6 +12882,376 @@ class WorkerClient {
   }
 }
 
+// src/memory-worker.ts
+var saveInput = object({
+  text: string2().min(1).max(MAX_OBSERVATION_BYTES),
+  title: string2().max(MAX_OBSERVATION_BYTES).optional(),
+  project: string2().trim().min(1).max(1000).optional()
+});
+var saveResponse = object({
+  success: literal(true),
+  id: number2().int().positive(),
+  title: string2(),
+  project: string2(),
+  message: string2()
+});
+var semanticResponse = object({ context: string2(), count: number2().int().nonnegative() });
+var fileResponse = object({
+  observations: array(object({
+    id: number2().int().positive(),
+    title: string2().nullable(),
+    type: string2(),
+    created_at_epoch: number2().finite(),
+    memory_session_id: string2().nullable().optional()
+  })),
+  count: number2().int().nonnegative()
+});
+
+class MemoryWorker {
+  static baseUrl = getWorkerBaseUrl();
+  static async json(path, init) {
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, init);
+      if (!response.ok) {
+        return null;
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        return null;
+      }
+      const chunks = [];
+      let size = 0;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          size += value.byteLength;
+          if (size > 512 * 1024) {
+            return null;
+          }
+          chunks.push(value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } finally {
+        await reader.cancel();
+      }
+    } catch {
+      return null;
+    }
+  }
+  static async save(input, project) {
+    const parsed = saveInput.safeParse(input);
+    if (!parsed.success) {
+      return "Memory not saved: invalid or oversized input.";
+    }
+    const text = stripTaggedContent(parsed.data.text);
+    const title = parsed.data.title === undefined ? undefined : stripTaggedContent(parsed.data.title);
+    if (!text || title !== undefined && !title || Buffer.byteLength(text) > MAX_OBSERVATION_BYTES || title !== undefined && Buffer.byteLength(title) > MAX_OBSERVATION_BYTES) {
+      return "Memory not saved: content is empty, private, or exceeds 24 KiB.";
+    }
+    const result = saveResponse.safeParse(await this.json("/api/memory/save", {
+      method: "POST",
+      signal: AbortSignal.timeout(1e4),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text,
+        title,
+        project: parsed.data.project ?? project,
+        metadata: { platformSource: "opencode" }
+      })
+    }));
+    return result.success ? JSON.stringify(result.data) : "Memory save not confirmed. The Worker may be unavailable or unsupported; check before retrying to avoid duplicates.";
+  }
+  static async semantic(prompt, project, options) {
+    const q = stripTaggedContent(prompt);
+    if (!options.enabled || q.length < 20) {
+      return "";
+    }
+    const result = semanticResponse.safeParse(await this.json("/api/context/semantic", {
+      method: "POST",
+      signal: AbortSignal.timeout(options.timeoutMs),
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ q, project, limit: options.limit })
+    }));
+    return result.success ? stripTaggedContent(result.data.context).slice(0, options.maxChars) : "";
+  }
+  static async byFile(paths, project, options) {
+    const lookahead = Math.max(40, options.limit);
+    const params = new URLSearchParams({ projects: project, limit: String(lookahead) });
+    for (const path of new Set(paths.map((item) => item.replaceAll("\\", "/")))) {
+      params.append("path", path);
+    }
+    const result = fileResponse.safeParse(await this.json(`/api/observations/by-file?${params}`, {
+      signal: AbortSignal.timeout(options.timeoutMs)
+    }));
+    return result.success ? result.data.observations.slice(0, lookahead) : [];
+  }
+}
+
+// src/file-context.ts
+import { stat } from "fs/promises";
+var readInput = object({
+  filePath: string2().optional(),
+  file_path: string2().optional(),
+  filePaths: array(string2()).optional(),
+  file_paths: array(string2()).optional(),
+  path: string2().optional()
+}).passthrough();
+
+class FileContext {
+  sessions = new Map;
+  options;
+  worker;
+  constructor(options, worker = MemoryWorker) {
+    this.options = options;
+    this.worker = worker;
+  }
+  async read(session, input, location) {
+    if (!this.options.enabled || !/(?:^|[._-])read(?:_file|_files)?$/i.test(input.tool)) {
+      return "";
+    }
+    const parsed = readInput.safeParse(input.args);
+    if (!parsed.success) {
+      return "";
+    }
+    const args = parsed.data;
+    const paths = [
+      ...new Set([
+        args.filePath,
+        args.file_path,
+        args.path,
+        ...args.filePaths ?? [],
+        ...args.file_paths ?? []
+      ].filter((path) => path !== undefined))
+    ].slice(0, 10);
+    let seen = this.sessions.get(session);
+    if (!seen) {
+      seen = new Map;
+      this.sessions.set(session, seen);
+    }
+    const revisions = seen;
+    const attempted = new Map;
+    const deadline = Date.now() + this.options.timeoutMs;
+    let active = true;
+    const timeout = Promise.withResolvers();
+    const timer = setTimeout(() => timeout.resolve(""), this.options.timeoutMs);
+    const pending = (async () => {
+      const results = await Promise.all(paths.map(async (path) => {
+        const absolute = resolve(location.directory, path);
+        const file = await stat(absolute).catch(() => null);
+        if (!active || this.sessions.get(session) !== revisions || !file?.isFile() || file.size < 1500) {
+          return [];
+        }
+        const revision = `${file.mtimeMs}:${file.size}`;
+        const inFlight = `pending:${revision}`;
+        if (revisions.get(absolute) === revision || revisions.get(absolute) === inFlight) {
+          return [];
+        }
+        attempted.set(absolute, inFlight);
+        revisions.set(absolute, inFlight);
+        const rows = await this.worker.byFile([absolute, relative(location.directory, absolute)], location.project, { ...this.options, timeoutMs: Math.max(1, deadline - Date.now()) });
+        if (!active || this.sessions.get(session) !== revisions || !rows.length || file.mtimeMs >= Math.max(...rows.map((row) => row.created_at_epoch))) {
+          return [];
+        }
+        return rows.map((row) => ({ row, path: absolute, revision }));
+      }));
+      const sessions = new Set;
+      const selected = results.flat().toSorted((a, b) => b.row.created_at_epoch - a.row.created_at_epoch).filter(({ row }) => {
+        const key = row.memory_session_id ?? `observation:${row.id}`;
+        if (sessions.has(key)) {
+          return false;
+        }
+        sessions.add(key);
+        return true;
+      }).slice(0, this.options.limit);
+      const delivered = new Map;
+      let text = "";
+      for (const { row, path, revision } of selected) {
+        const separator = text ? `
+` : "";
+        const available = this.options.maxChars - text.length - separator.length;
+        if (available <= 0) {
+          break;
+        }
+        const line = `#${row.id} ${stripTaggedContent(row.type)}: ${stripTaggedContent(row.title ?? "")}`;
+        text += separator + line.slice(0, available);
+        delivered.set(path, revision);
+      }
+      if (text && active && this.sessions.get(session) === revisions) {
+        for (const [path, revision] of delivered) {
+          revisions.set(path, revision);
+        }
+      }
+      return text ? `
+
+<claude-mem-context>
+Supplementary file history (past observations, not file contents):
+${text}
+</claude-mem-context>` : "";
+    })();
+    try {
+      return await Promise.race([pending, timeout.promise]);
+    } catch {
+      return "";
+    } finally {
+      active = false;
+      clearTimeout(timer);
+      for (const [path, revision] of attempted) {
+        if (revisions.get(path) === revision) {
+          revisions.delete(path);
+        }
+      }
+    }
+  }
+  delete(session) {
+    this.sessions.delete(session);
+  }
+  clear() {
+    this.sessions.clear();
+  }
+}
+
+// src/memory-session.ts
+class MemorySessions {
+  sessions = new Map;
+  deleted = new Set;
+  options;
+  worker;
+  constructor(options, worker = MemoryWorker) {
+    this.options = options;
+    this.worker = worker;
+  }
+  state(id) {
+    let state = this.sessions.get(id);
+    if (!state) {
+      state = {
+        turns: new Map,
+        registered: new Set,
+        blocked: new Set,
+        pending: [],
+        semantic: new Map
+      };
+      this.sessions.set(id, state);
+    }
+    return state;
+  }
+  select(session, turn) {
+    if (this.isDeleted(session)) {
+      return false;
+    }
+    const state = this.state(session);
+    const known = state.turns.get(turn.id);
+    if (known && state.current !== known) {
+      return false;
+    }
+    state.current = known ?? turn;
+    if (!known) {
+      state.turns.set(turn.id, turn);
+      if (turn.capture) {
+        state.pending.push(turn);
+      }
+    }
+    return !known;
+  }
+  hasTurn(session) {
+    return Boolean(this.sessions.get(session)?.current);
+  }
+  hasMessage(session, id) {
+    return this.sessions.get(session)?.turns.has(id) ?? false;
+  }
+  isDeleted(session) {
+    return this.deleted.has(session);
+  }
+  canCapture(session) {
+    const state = this.sessions.get(session);
+    const turn = state?.current;
+    return Boolean(turn?.capture && state?.registered.has(turn.id) && !state.blocked.has(turn.id));
+  }
+  async register(session, project) {
+    const state = this.sessions.get(session);
+    if (!state?.current?.capture) {
+      return false;
+    }
+    if (state.registration) {
+      return state.registration;
+    }
+    const pending = (async () => {
+      while (state.pending.length) {
+        const [turn] = state.pending;
+        if (!turn || this.sessions.get(session) !== state) {
+          return false;
+        }
+        const result = await WorkerClient.sessionInit(session, project, turn.text);
+        if (!result || this.sessions.get(session) !== state) {
+          return false;
+        }
+        if (result.skipped && result.reason !== "duplicate") {
+          state.blocked.add(turn.id);
+        }
+        state.registered.add(turn.id);
+        state.pending.shift();
+      }
+      return this.canCapture(session);
+    })();
+    state.registration = pending;
+    try {
+      return await pending;
+    } finally {
+      state.registration = undefined;
+    }
+  }
+  async semantic(session, project) {
+    const state = this.sessions.get(session);
+    const turn = state?.current;
+    if (!state || !turn?.semantic || !this.canCapture(session)) {
+      return "";
+    }
+    let pending = state.semantic.get(turn.id);
+    if (!pending) {
+      pending = this.worker.semantic(turn.text, project, this.options.semanticInjection);
+      state.semantic.set(turn.id, pending);
+    }
+    const result = await pending;
+    return this.sessions.get(session) === state && state.current === turn ? result : "";
+  }
+  async context(session, project) {
+    if (this.isDeleted(session)) {
+      return null;
+    }
+    const state = this.state(session);
+    if (!state.context) {
+      state.context = WorkerClient.getContext(project);
+    }
+    const pending = state.context;
+    const value = await pending;
+    if (this.sessions.get(session) !== state || state.context !== pending) {
+      return null;
+    }
+    if (value === null) {
+      state.context = undefined;
+    }
+    return value === null ? null : stripTaggedContent(value).slice(0, 24000);
+  }
+  invalidate(session) {
+    const state = this.sessions.get(session);
+    if (state) {
+      state.context = undefined;
+    }
+  }
+  delete(session) {
+    this.deleted.add(session);
+    this.sessions.delete(session);
+  }
+  clear() {
+    for (const session of this.sessions.keys()) {
+      this.deleted.add(session);
+    }
+    this.sessions.clear();
+  }
+}
+
 // src/tui-registration.ts
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
@@ -12904,10 +13321,73 @@ function ensureTuiPluginEntry() {
   }
 }
 
+// src/memory-options.ts
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+var group = object({
+  enabled: boolean2().optional().catch(undefined),
+  limit: number2().int().min(1).max(50).optional().catch(undefined),
+  maxChars: number2().int().min(256).max(24000).optional().catch(undefined),
+  timeoutMs: number2().int().min(100).max(1e4).optional().catch(undefined)
+}).catch({});
+var optionsSchema = object({
+  semanticInjection: group.optional(),
+  fileContext: group.optional()
+}).catch({});
+var settingsSchema = object({
+  CLAUDE_MEM_SEMANTIC_INJECT: unknown().optional(),
+  CLAUDE_MEM_SEMANTIC_INJECT_LIMIT: unknown().optional()
+}).catch({});
+function booleanSetting(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
+  if (normalized === true || normalized === "true" || normalized === "1") {
+    return true;
+  }
+  if (normalized === false || normalized === "false" || normalized === "0") {
+    return false;
+  }
+  return;
+}
+function limitSetting(value) {
+  const parsed = exports_coerce.number().int().min(1).max(50).safeParse(value);
+  return parsed.success ? parsed.data : undefined;
+}
+function parseMemoryOptions(options, env, settings) {
+  const explicit = optionsSchema.parse(options);
+  const stored = settingsSchema.parse(settings);
+  return {
+    semanticInjection: {
+      enabled: explicit.semanticInjection?.enabled ?? booleanSetting(env.CLAUDE_MEM_SEMANTIC_INJECT) ?? booleanSetting(stored.CLAUDE_MEM_SEMANTIC_INJECT) ?? false,
+      limit: explicit.semanticInjection?.limit ?? limitSetting(env.CLAUDE_MEM_SEMANTIC_INJECT_LIMIT) ?? limitSetting(stored.CLAUDE_MEM_SEMANTIC_INJECT_LIMIT) ?? 5,
+      maxChars: explicit.semanticInjection?.maxChars ?? 6000,
+      timeoutMs: explicit.semanticInjection?.timeoutMs ?? 2000
+    },
+    fileContext: {
+      enabled: explicit.fileContext?.enabled ?? true,
+      limit: explicit.fileContext?.limit ?? 15,
+      maxChars: explicit.fileContext?.maxChars ?? 6000,
+      timeoutMs: explicit.fileContext?.timeoutMs ?? 1500
+    }
+  };
+}
+function resolveMemoryOptions(options) {
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync3(join3(homedir3(), ".claude-mem", "settings.json"), "utf8"));
+  } catch {}
+  return parseMemoryOptions(options, process.env, settings);
+}
+
 // src/index.ts
 var ASSISTANT_FLUSH_DEBOUNCE_MS = 250;
-var ClaudeMemPlugin = async (ctx) => {
+var ClaudeMemPlugin = async (ctx, options) => {
   const { project, directory, client } = ctx;
+  const config = resolveMemoryOptions(options);
+  const memory = new MemorySessions(config);
+  const files = new FileContext(config.fileContext);
+  const resumed = new Map;
+  const subagentSessions = new Set;
   ensureTuiPluginEntry();
   const projectRoot = directory || process.cwd();
   const projectName = project?.worktree ? project.worktree.split(/[\\/]/).findLast(Boolean) || "unknown-project" : "unknown-project";
@@ -12918,17 +13398,6 @@ var ClaudeMemPlugin = async (ctx) => {
       });
     } catch {}
   }
-  let contextCache = undefined;
-  async function getCachedContext() {
-    if (contextCache !== undefined) {
-      return contextCache;
-    }
-    const context = await WorkerClient.getContext(projectName);
-    if (context !== null) {
-      contextCache = context;
-    }
-    return context;
-  }
   let workerHealthy = null;
   let initToastShown = false;
   async function checkWorkerAndToast() {
@@ -12941,9 +13410,17 @@ var ClaudeMemPlugin = async (ctx) => {
     return workerHealthy;
   }
   let currentSessionId = null;
-  const initializedSessions = new Set;
   const assistantBuffers = new Map;
+  const assistantFlushes = new Map;
   async function flushAssistantBuffer(sessionId) {
+    const existing = assistantFlushes.get(sessionId);
+    if (existing) {
+      await existing;
+    }
+    if (!memory.canCapture(sessionId)) {
+      discardAssistantBuffer(sessionId);
+      return;
+    }
     const buf = assistantBuffers.get(sessionId);
     if (!buf || !buf.messageId) {
       return;
@@ -12954,13 +13431,23 @@ var ClaudeMemPlugin = async (ctx) => {
     }
     const { messageId } = buf;
     buf.messageId = null;
+    const pending = (async () => {
+      try {
+        const text = await fetchAssistantMessageText(sessionId, messageId);
+        const sanitized = truncateUtf8Bytes(stripTaggedContent(text), MAX_OBSERVATION_BYTES);
+        if (sanitized) {
+          await WorkerClient.sendObservation(sessionId, "assistant_message", { messageId }, sanitized, projectRoot);
+        }
+      } catch {}
+    })();
+    assistantFlushes.set(sessionId, pending);
     try {
-      const text = await fetchAssistantMessageText(sessionId, messageId);
-      const sanitized = truncateUtf8Bytes(stripTaggedContent(text), MAX_OBSERVATION_BYTES);
-      if (sanitized) {
-        await WorkerClient.sendObservation(sessionId, "assistant_message", { messageId }, sanitized, projectRoot);
+      await pending;
+    } finally {
+      if (assistantFlushes.get(sessionId) === pending) {
+        assistantFlushes.delete(sessionId);
       }
-    } catch {}
+    }
   }
   function scheduleAssistantFlush(sessionId) {
     const buf = assistantBuffers.get(sessionId);
@@ -12982,23 +13469,34 @@ var ClaudeMemPlugin = async (ctx) => {
     }
     assistantBuffers.delete(sessionId);
   }
-  async function ensureSessionInit(sessionId, prompt) {
-    if (initializedSessions.has(sessionId)) {
-      return true;
-    }
-    const isHealthy = await checkWorkerAndToast();
-    if (!isHealthy) {
+  async function ensureSessionInit(sessionId) {
+    if (memory.isDeleted(sessionId)) {
       return false;
     }
     try {
-      const result = await WorkerClient.sessionInit(sessionId, projectName, prompt || "SESSION_START");
-      if (!result) {
+      if (!memory.hasTurn(sessionId)) {
+        let pending = resumed.get(sessionId);
+        if (!pending) {
+          pending = (async () => {
+            const result = await client.session.messages({ path: { id: sessionId } });
+            const turn = resumedV1Turn(result.data);
+            if (turn && !memory.hasTurn(sessionId) && resumed.has(sessionId)) {
+              memory.select(sessionId, turn);
+            }
+          })();
+          resumed.set(sessionId, pending);
+        }
+        await pending;
+        if (!memory.hasTurn(sessionId)) {
+          resumed.delete(sessionId);
+        }
+      }
+      if (!memory.hasTurn(sessionId) || !await checkWorkerAndToast()) {
         return false;
       }
-      initializedSessions.add(sessionId);
-      currentSessionId = sessionId;
-      return true;
+      return await memory.register(sessionId, projectName);
     } catch {
+      resumed.delete(sessionId);
       return false;
     }
   }
@@ -13042,6 +13540,15 @@ var ClaudeMemPlugin = async (ctx) => {
   }
   return {
     tool: {
+      "mem-save": tool({
+        description: "Save an explicit memory to Claude-Mem. Private and injected context are removed. Check an uncertain result before retrying.",
+        args: {
+          text: tool.schema.string().min(1).max(MAX_OBSERVATION_BYTES),
+          title: tool.schema.string().max(MAX_OBSERVATION_BYTES).optional(),
+          project: tool.schema.string().min(1).optional()
+        },
+        execute: async (input) => MemoryWorker.save(input, projectName)
+      }),
       "mem-search": tool({
         description: "Search Claude-Mem persistent memory. Supports query, project, platformSource, type, obs_type, dateStart, dateEnd, offset, and orderBy filters.",
         args: {
@@ -13136,7 +13643,10 @@ var ClaudeMemPlugin = async (ctx) => {
             return;
           }
           currentSessionId = sessionId;
-          contextCache = undefined;
+          if (event.properties?.info?.parentID) {
+            subagentSessions.add(sessionId);
+          }
+          memory.invalidate(sessionId);
           await checkWorkerAndToast();
           return;
         }
@@ -13186,7 +13696,11 @@ var ClaudeMemPlugin = async (ctx) => {
           if (!sessionId) {
             return;
           }
+          memory.invalidate(sessionId);
           await flushAssistantBuffer(sessionId);
+          if (!await ensureSessionInit(sessionId)) {
+            return;
+          }
           const isHealthy = await checkWorkerAndToast();
           if (!isHealthy) {
             return;
@@ -13203,6 +13717,9 @@ var ClaudeMemPlugin = async (ctx) => {
             return;
           }
           await flushAssistantBuffer(sessionId);
+          if (!await ensureSessionInit(sessionId)) {
+            return;
+          }
           try {
             const { user, assistant, observedModel } = await fetchLastMessages(sessionId);
             if (await WorkerClient.summarize(sessionId, user, assistant, { observedModel })) {
@@ -13218,7 +13735,10 @@ var ClaudeMemPlugin = async (ctx) => {
           }
           await flushAssistantBuffer(sessionId);
           discardAssistantBuffer(sessionId);
-          initializedSessions.delete(sessionId);
+          memory.delete(sessionId);
+          files.delete(sessionId);
+          resumed.delete(sessionId);
+          subagentSessions.delete(sessionId);
           if (currentSessionId === sessionId) {
             currentSessionId = null;
           }
@@ -13233,11 +13753,23 @@ var ClaudeMemPlugin = async (ctx) => {
       const sessionId = input.sessionID;
       if (sessionId) {
         const userPrompt = extractTextFromParts(output.parts);
-        await ensureSessionInit(sessionId, userPrompt || undefined);
+        const id = input.messageID ?? output.message.id;
+        if (!id) {
+          return;
+        }
+        if (!memory.hasMessage(sessionId, id)) {
+          await flushAssistantBuffer(sessionId);
+        }
+        currentSessionId = sessionId;
+        memory.select(sessionId, memoryTurn(id, userPrompt, output.parts.some((part) => part.type === "file")));
+        await ensureSessionInit(sessionId);
       }
     },
     "experimental.chat.system.transform": async (input, output) => {
-      const sessionId = input.sessionID;
+      const sessionId = input.sessionID ?? currentSessionId;
+      if (!sessionId) {
+        return;
+      }
       if (sessionId) {
         await ensureSessionInit(sessionId);
       }
@@ -13246,7 +13778,16 @@ var ClaudeMemPlugin = async (ctx) => {
         return;
       }
       try {
-        const context = await getCachedContext();
+        const base = await memory.context(sessionId, projectName);
+        const semantic = await memory.semantic(sessionId, projectName);
+        const context = [base, semantic].filter(Boolean).join(`
+
+`);
+        for (let i = output.system.length - 1;i >= 0; i--) {
+          if (output.system[i].startsWith("<claude-mem-context>")) {
+            output.system.splice(i, 1);
+          }
+        }
         if (context) {
           output.system.push(`<claude-mem-context>
 [Claude-Mem] Memory Active. Previous Context:
@@ -13257,6 +13798,7 @@ ${context}
     },
     "experimental.session.compacting": async (input, output) => {
       const sessionId = input.sessionID;
+      memory.invalidate(sessionId);
       if (sessionId) {
         await ensureSessionInit(sessionId);
       }
@@ -13265,7 +13807,7 @@ ${context}
         return;
       }
       try {
-        const context = await getCachedContext();
+        const context = await memory.context(sessionId, projectName);
         if (context) {
           output.context.push(`<claude-mem-context>
 [Claude-Mem] Memory Active. Previous Context:
@@ -13289,6 +13831,8 @@ ${context}
         const sanitizedToolInput = sanitizeObservationValue(input.args || {});
         const sanitizedToolOutput = truncateUtf8Bytes(stripTaggedContent(normalizeToolOutput(output.output)), MAX_OBSERVATION_BYTES);
         await WorkerClient.sendObservation(sessionId, input.tool, sanitizedToolInput, sanitizedToolOutput, projectRoot, input.callID);
+        const history = subagentSessions.has(sessionId) ? "" : await files.read(sessionId, { tool: input.tool, args: input.args }, { directory: projectRoot, project: projectName });
+        output.output += history;
       } catch {}
     }
   };