@everme/claude-code 0.6.3 → 0.6.5

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "everme",
       "source": "./",
       "description": "Automatic memory recall for Claude Code through the EverMe gateway. Saves and recalls per-session context using your EverMe account credentials.",
-      "version": "0.6.3",
+      "version": "0.6.5",
       "homepage": "https://everme.evermind.ai",
       "license": "Apache-2.0"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "everme",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "EverMe — automatic memory recall for Claude Code. Recalls relevant context from past sessions before each prompt and saves new turns through the EverMe gateway.",
   "author": {
     "name": "EverMind AI",

package/README.md

@@ -7,9 +7,20 @@ Automatic memory recall + persistence for Claude Code, backed by the EverMe gate
 - **SessionStart** → loads the profile snapshot from past sessions and injects it as `additionalContext` for the model + a one-line `🧠 EverMe loaded N memory items` system message for you.
 - **UserPromptSubmit** → searches your memory for content relevant to the prompt you just typed and injects it BEFORE the model sees the prompt. Silent when no relevant hit (no nag).
 - **Stop** → persists the just-finished raw turn (including tool calls/results) with `flush:false`; every fifth turn triggers extraction.
-- **SubagentStop** → persists the child transcript's assistant/tool trajectory under a stable child conversation id; internal task/user wrappers are excluded and a per-transcript checkpoint prevents repeats.
+- **SubagentStop** → excludes internal task/user wrappers, then skips an independent child transcript without a real user (`subagent_without_user`). Admitted child trajectories keep their stable conversation ID and per-transcript checkpoint.
 - **SessionEnd** → sends a flush-only request so short sessions still extract memory without repeating messages.
 
+Write hooks require a nonblank native string `session_id`; `SubagentStop` also requires a nonblank native string `agent_id`. Missing or invalid IDs produce a bounded diagnostic and skip the write, without generating a fallback ID. Valid child IDs retain the `session_id__agent_id` format. Read-only recall is unaffected.
+
+Tool arguments must encode valid JSON. Invalid calls are skipped with aggregate diagnostics, together with results whose native ID identifies that call uniquely. Other text and valid calls remain unchanged; conflicting source IDs are not used to guess result ownership. Tool result text itself need not be JSON.
+
+Tool names must be nonblank native strings. Missing or invalid names follow the same skip-and-diagnose policy, without substituting `unknown`; an actual native tool named `unknown` remains valid.
+
+Native assistant `message.stop_reason: "end_turn"` is retained as local batching
+metadata so complete turns take priority over tool-pair boundaries. Missing or
+other stop reasons do not imply completion. This metadata is not sent to the
+gateway; oversized turns still use the existing tool-pair/hard-limit fallback.
+
 Plus:
 
 - **MCP server** exposing the read-only `mem_search` / `mem_context` tools for explicit recall (saving is automatic via the hooks).
@@ -105,3 +116,27 @@ install.sh                           bash installer
 ## License
 
 Apache-2.0
+# Task-aware ingestion
+
+Claude Code enables the shared task-aware batching policy: preserve fitting
+user tasks, compress only byte-oversized tool results with 4/3/2 KiB budgets,
+then split remaining overflow at text, tool-pair, or hard boundaries. Existing
+incremental reads, checkpoint commits and flush cadence are unchanged.
+
+SubagentStop skips child transcripts without a real user after filtering,
+reports `subagent_without_user`, and does not advance their checkpoints. Root
+assistant-only deltas remain eligible. No Codex-specific goal envelope is
+assumed for Claude's native transcript format.
+
+## Fork history and progress
+
+Root write hooks exclude records explicitly belonging to another native
+`sessionId` before selecting messages, resolving the turn ID, and calculating
+checkpoint counts or `baseTurn`. The hook's `session_id` remains authoritative.
+Records without a session ID retain the existing compatibility behavior;
+subagent selection is unchanged. First capture still selects only the last turn.
+
+This corrects new-state coordinates only. Existing checkpoints and server
+watermarks are not migrated or cleared; previously contaminated progress can
+still skip messages and requires a separate recovery decision. No historical
+replay is triggered by this change.

package/hooks/scripts/lib/adapter.js

@@ -1,8 +1,10 @@
 import os from "node:os";
 import path from "node:path";
 import { readTranscript, extractAgentMessages } from "./transcript.js";
+import { turnOrdinals } from "@everme/agent-sdk";
 
 const CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit"]);
+const WRITE_EVENTS = new Set(["Stop", "SubagentStop", "SessionEnd", "PreCompact"]);
 
 export const claudeCodeAdapter = {
   platform: "claude-code",
@@ -10,6 +12,7 @@ export const claudeCodeAdapter = {
   // every one of them, so the SDK claims channel="hook" for these writes and
   // they enter L1-2's denominator. Whole-session hosts leave this unset.
   turnBoundary: "stop",
+  taskBatching: true,
 
   envFile() {
     return process.env.EVERME_ENV_FILE_PATH || path.join(os.homedir(), ".claude", "everme.env");
@@ -17,10 +20,14 @@ export const claudeCodeAdapter = {
 
   normalizeInput(rawInput, event) {
     const isSubagent = event === "SubagentStop";
-    const parentSessionId = rawInput?.session_id || "claude-code-session";
-    const agentId = rawInput?.agent_id || "subagent";
+    const parentSessionId = nativeId(rawInput?.session_id);
+    const agentId = nativeId(rawInput?.agent_id);
+    const missingIdentity = !parentSessionId
+      ? "missing_session_id"
+      : isSubagent && !agentId ? "missing_agent_id" : "";
+    if (missingIdentity && WRITE_EVENTS.has(event)) logSkippedWrite(missingIdentity);
     return {
-      sessionId: isSubagent ? `${parentSessionId}__${agentId}` : parentSessionId,
+      sessionId: missingIdentity ? "" : isSubagent ? `${parentSessionId}__${agentId}` : parentSessionId,
       transcriptPath: isSubagent
         ? rawInput?.agent_transcript_path || ""
         : rawInput?.transcript_path || "",
@@ -41,7 +48,7 @@ export const claudeCodeAdapter = {
   // "" (dedup disabled) when the transcript has no uuids.
   async resolveTurnId(input) {
     if (!input?.transcriptPath) return "";
-    const lines = await readTranscript(input.transcriptPath);
+    const lines = await readSessionLines(input);
     for (let index = lines.length - 1; index >= 0; index -= 1) {
       try {
         const event = JSON.parse(lines[index]);
@@ -55,9 +62,11 @@ export const claudeCodeAdapter = {
 
   async readLastTurn(input) {
     if (!input?.transcriptPath) return [];
-    const messages = extractAgentMessages(await readTranscript(input.transcriptPath), {
+    const messages = extractAgentMessages(await readSessionLines(input), {
       subagent: input.isSubagent,
+      diagnostic: (line) => console.error(line),
     });
+    if (skipUserlessChild(input, messages)) return [];
     for (let index = messages.length - 1; index >= 0; index -= 1) {
       if (messages[index]?.role === "user") return messages.slice(index);
     }
@@ -65,24 +74,40 @@ export const claudeCodeAdapter = {
   },
 
   async readStoreBatches(input, { checkpointStore } = {}) {
+    if (!nativeId(input?.sessionId)) {
+      logSkippedWrite("missing_session_id");
+      return [];
+    }
     if (!input?.transcriptPath) return [];
-    const messages = extractAgentMessages(await readTranscript(input.transcriptPath), {
+    const messages = extractAgentMessages(await readSessionLines(input), {
       subagent: input.isSubagent,
+      diagnostic: (line) => console.error(line),
     });
+    if (skipUserlessChild(input, messages)) return [];
     const stateId = `claude-code:${input.sessionId}`;
     const checkpoint = checkpointStore
       ? await checkpointStore.read(stateId)
       : { initialized: false, uploadedCount: 0 };
-    let delta;
-    if (checkpoint.initialized && checkpoint.uploadedCount <= messages.length) {
-      delta = messages.slice(checkpoint.uploadedCount);
-    } else {
-      delta = input.isSubagent ? messages : lastRootTurn(messages);
-    }
+    const continuation = checkpoint.initialized && checkpoint.uploadedCount <= messages.length;
+    const delta = continuation
+      ? messages.slice(checkpoint.uploadedCount)
+      : (input.isSubagent ? messages : lastRootTurn(messages));
     if (!delta.length) return [];
     return [{
       conversationId: input.sessionId,
       messages: delta,
+      // Address the delta by its absolute turn only when everything before it
+      // is known to be covered: a checkpoint continuation, or the whole
+      // transcript. A cold-start tail (no checkpoint yet -- a resumed
+      // pre-existing session, a wiped state dir) must not claim the turns it
+      // skipped, or the importer would trim the history it still has to bring
+      // in; unaddressed, the gate appends it at the current watermark instead.
+      ...(continuation || delta.length === messages.length
+        ? { baseTurn: turnOrdinals(messages)[messages.length - delta.length] }
+        // A cold-start tail also declares no completed turn: appended at the
+        // watermark it would be recorded as turn 0 and the importer would
+        // then trim the real turn 0 as covered.
+        : { turns: 0 }),
       checkpoint: { stateId, uploadedCount: messages.length },
     }];
   },
@@ -102,6 +127,40 @@ export const claudeCodeAdapter = {
   },
 };
 
+async function readSessionLines(input) {
+  const lines = await readTranscript(input.transcriptPath);
+  if (input.isSubagent || !nativeId(input.sessionId)) return lines;
+  let excluded = 0;
+  const selected = lines.filter((line) => {
+    try {
+      const sessionId = nativeId(JSON.parse(line)?.sessionId);
+      if (sessionId && sessionId !== input.sessionId) {
+        excluded++;
+        return false;
+      }
+    } catch {
+      // Leave malformed records to the existing parser.
+    }
+    return true;
+  });
+  if (excluded) console.error(`[everme] claude-code parse reason=claude_inherited_history excluded_records=${excluded}`);
+  return selected;
+}
+
+function nativeId(value) {
+  return typeof value === "string" && value.trim() ? value : "";
+}
+
+function skipUserlessChild(input, messages) {
+  if (!input.isSubagent || messages.some((message) => message.role === "user")) return false;
+  logSkippedWrite("subagent_without_user");
+  return true;
+}
+
+function logSkippedWrite(reason) {
+  console.error(`[everme] claude-code store stage=skip reason=${reason}`);
+}
+
 function lastRootTurn(messages) {
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     if (messages[index]?.role === "user") return messages.slice(index);

package/hooks/scripts/lib/transcript.js

@@ -133,8 +133,9 @@ export function extractTurns(lines) {
   return turns;
 }
 
-export function extractAgentMessages(lines, { subagent = false } = {}) {
+export function extractAgentMessages(lines, { subagent = false, diagnostic = () => {} } = {}) {
   const messages = [];
+  const dropped = { calls: 0, results: 0 };
   for (const line of lines) {
     let ev;
     try {
@@ -160,7 +161,7 @@ export function extractAgentMessages(lines, { subagent = false } = {}) {
       // messages (with their own toolCallId), free text becomes a
       // role=user message. A single CC user event can therefore emit
       // multiple EverMe messages.
-      const toolResults = extractToolResults(rawContent, timestamp);
+      const toolResults = extractToolResults(rawContent, timestamp, dropped);
       messages.push(...toolResults);
       if (subagent) continue;
       const text = normalizeClaudeUserText(textFromContent(rawContent));
@@ -170,20 +171,93 @@ export function extractAgentMessages(lines, { subagent = false } = {}) {
       continue;
     }
     if (role === AGENT_MEMORY_ROLES.ASSISTANT) {
-      const msg = agentAssistantMessage(rawContent, timestamp);
-      if (msg) messages.push(msg);
+      const msg = agentAssistantMessage(rawContent, timestamp, dropped);
+      if (msg) {
+        if (inner?.stop_reason === "end_turn") msg.turnComplete = true;
+        messages.push(msg);
+      }
       continue;
     }
     // Legacy flat tool-role fallback: { role:"tool", content, toolCallId }
     if (role === AGENT_MEMORY_ROLES.TOOL || ev.type === "tool_result") {
-      const toolCallId = ev.toolCallId || ev.tool_call_id || ev.tool_use_id;
-      if (!toolCallId) continue;
+      const toolCallId = firstToolId(ev.toolCallId, ev.tool_call_id, ev.tool_use_id);
+      if (!toolCallId) {
+        dropped.results++;
+        continue;
+      }
       const content =
         typeof rawContent === "string" ? rawContent : safeJsonStringify(rawContent);
       messages.push({ role: AGENT_MEMORY_ROLES.TOOL, timestamp, toolCallId, content });
     }
   }
-  return messages;
+  const filtered = filterInvalidToolCalls(messages, diagnostic);
+  if (dropped.calls || dropped.results) {
+    diagnostic(`[everme] claude-code parse lines=${lines.length} messages=${filtered.length} dropped_invalid_call_id=${dropped.calls} dropped_invalid_result_id=${dropped.results}`.slice(0, 1024));
+  }
+  return filtered;
+}
+
+function filterInvalidToolCalls(messages, diagnostic) {
+  const callCounts = new Map();
+  const invalidCalls = new Set();
+  const invalidIds = new Map();
+  const dropped = {
+    invalid_tool_name: { calls: 0, results: 0 },
+    invalid_tool_arguments: { calls: 0, results: 0 },
+  };
+  for (const message of messages) {
+    for (const call of message.toolCalls || []) {
+      callCounts.set(call.id, (callCounts.get(call.id) || 0) + 1);
+      const reason = invalidToolCallReason(call);
+      if (reason) {
+        invalidCalls.add(call);
+        invalidIds.set(call.id, reason);
+        dropped[reason].calls++;
+      }
+    }
+  }
+  if (!invalidCalls.size) return messages;
+  const filtered = [];
+  for (const message of messages) {
+    if (message.role === AGENT_MEMORY_ROLES.TOOL
+      && invalidIds.has(message.toolCallId) && callCounts.get(message.toolCallId) === 1) {
+      dropped[invalidIds.get(message.toolCallId)].results++;
+      continue;
+    }
+    if (message.toolCalls?.some(call => invalidCalls.has(call))) {
+      const kept = { ...message, toolCalls: message.toolCalls.filter(call => !invalidCalls.has(call)) };
+      if (!kept.toolCalls.length) {
+        delete kept.toolCalls;
+        if (!kept.content?.trim()) continue;
+      }
+      filtered.push(kept);
+    } else {
+      filtered.push(message);
+    }
+  }
+  for (const [reason, counts] of Object.entries(dropped)) {
+    if (counts.calls) diagnostic(`[everme] claude-code parse reason=${reason} dropped_calls=${counts.calls} dropped_results=${counts.results}`.slice(0, 1024));
+  }
+  return filtered;
+}
+
+function invalidToolCallReason(call) {
+  if (typeof call.name !== "string" || !call.name.trim()) return "invalid_tool_name";
+  return isJsonArguments(call.arguments) ? "" : "invalid_tool_arguments";
+}
+
+function isJsonArguments(value) {
+  if (typeof value !== "string") return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function firstToolId(...values) {
+  return values.find(value => typeof value === "string" && value.trim().length > 0) || "";
 }
 
 function isInternalEvent(event, subagent) {
@@ -264,14 +338,17 @@ function envelopeValue(text, tag) {
 // message. CC encodes tool_result as a content block inside a user
 // envelope (not a separate top-level event), so without this step the
 // entire tool round-trip is lost.
-function extractToolResults(content, timestamp) {
+function extractToolResults(content, timestamp, dropped) {
   if (!Array.isArray(content)) return [];
   const out = [];
   for (const b of content) {
     if (!b || typeof b !== "object") continue;
     if (b.type !== "tool_result") continue;
-    const toolCallId = b.tool_use_id || b.toolCallId || b.tool_call_id;
-    if (!toolCallId) continue;
+    const toolCallId = firstToolId(b.tool_use_id, b.toolCallId, b.tool_call_id);
+    if (!toolCallId) {
+      dropped.results++;
+      continue;
+    }
     let text;
     if (typeof b.content === "string") {
       text = b.content;
@@ -294,23 +371,28 @@ function extractToolResults(content, timestamp) {
   return out;
 }
 
-function agentAssistantMessage(content, timestamp) {
+function agentAssistantMessage(content, timestamp, dropped) {
   if (typeof content === "string") {
     return content ? { role: AGENT_MEMORY_ROLES.ASSISTANT, timestamp, content } : null;
   }
   if (!Array.isArray(content)) return null;
   const textParts = [];
   const toolCalls = [];
-  for (const [i, b] of content.entries()) {
+  for (const b of content) {
     if (!b || typeof b !== "object") continue;
     if (b.type === "text" && typeof b.text === "string") {
       textParts.push(b.text);
     } else if (b.type === "tool_use" || b.type === "toolCall") {
+      const id = firstToolId(b.id, b.tool_use_id);
+      if (!id) {
+        dropped.calls++;
+        continue;
+      }
       const args = b.input ?? b.arguments ?? {};
       toolCalls.push({
-        id: b.id || b.tool_use_id || `claude_tool_${timestamp}_${i}`,
+        id,
         type: AGENT_MEMORY_TOOL_CALL_TYPES.FUNCTION,
-        name: b.name || "unknown",
+        name: b.name,
         arguments: typeof args === "string" ? args : safeJsonStringify(args),
       });
     }
@@ -319,7 +401,7 @@ function agentAssistantMessage(content, timestamp) {
   const text = textParts.join("\n\n");
   if (text) out.content = text;
   if (toolCalls.length) out.toolCalls = toolCalls;
-  return out.content || out.toolCalls ? out : null;
+  return text.trim() || toolCalls.length ? out : null;
 }
 
 function textFromContent(content) {

package/hooks/scripts/mcp-server.js

@@ -67,16 +67,27 @@ function getClient() {
 }
 
 // Instructions returned on initialize — Claude Code splices them into the
-// system prompt. Mirrors @everme/memory-mcp's EVERME_MCP_INSTRUCTIONS with
-// the Claude-Code-specific note that native hooks already inject
-// <everme_profile> / <everme_recall> and save turns automatically.
+// system prompt. The plugin's hooks always run on this host, so unlike the
+// generic @everme/memory-mcp copy this one can state plainly that memory is
+// kept on its own; the two READ tools cover what the injected
+// <everme_profile> / <everme_recall> blocks do not.
 const INSTRUCTIONS = [
-  "EverMe memory is connected. This plugin's native hooks already inject a",
-  "<everme_profile> block at session start and a <everme_recall> block before",
-  "each prompt, and they save the conversation automatically — so saving needs",
-  "no tool call. These two READ tools are for the cases the hooks do not cover;",
-  "call them AUTONOMOUSLY when a trigger fires, never waiting to be asked.",
-  "1. The <everme_recall> block is missing, empty, or clearly irrelevant AND the user references earlier conversations, decisions, conventions, or previously solved problems — call `mem_search` with a SHORT query. Do not repeat an identical query in the same turn.",
+  "EverMe is the user's long-term memory across sessions. On this host it",
+  "listens to the conversation itself: what matters — preferences, decisions,",
+  "the work you do together — is kept without anyone saving it by hand, and",
+  "comes back into your context next time through the <everme_profile> and",
+  "<everme_recall> blocks.",
+  "",
+  "So when the user asks you to remember something, you already can. A short",
+  "acknowledgement is enough (\"Noted — I'll remember that.\"), then move on;",
+  "there is nothing to call and nothing to set up. If they ask how it works,",
+  "\"EverMe keeps a memory of our conversations\" is the whole story from their",
+  "side — the mechanics are not something to narrate, and there is nothing to",
+  "work around.",
+  "",
+  "Two read tools fill the gaps the injected blocks leave. Use them on your",
+  "own judgment rather than waiting to be asked to \"recall\":",
+  "1. The <everme_recall> block is missing, empty, or clearly off-topic AND the user leans on earlier conversations, decisions, conventions, or previously solved problems — call `mem_search` with a SHORT query, and never repeat an identical query in one turn.",
   "2. No <everme_profile> block was injected this session — call `mem_context` once. It returns the durable Profile ONLY (no search, no episodes).",
 ].join("\n");
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/claude-code",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "type": "module",
   "description": "EverMe native plugin for Claude Code — automatic memory recall via SessionStart/UserPromptSubmit/Stop/SessionEnd hooks, plus /recall slash + bundled MCP server.",
   "license": "Apache-2.0",
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@everme/agent-sdk": "^0.6.3"
+    "@everme/agent-sdk": "^0.6.5"
   },
   "keywords": [
     "evermind",

package/skills/memory-tools.md

@@ -1,18 +1,22 @@
 ---
-description: Use EverMe memory proactively when the user refers to previous conversations, earlier decisions, "last time", "remember when", existing project conventions, or previously solved errors, and save durable user preferences, habits, and decisions the moment they are stated. Do not repeat a search when a non-empty <everme_recall> block already exists.
+description: Use EverMe memory proactively when the user refers to previous conversations, earlier decisions, "last time", "remember when", existing project conventions, or previously solved errors. Do not repeat a search when a non-empty <everme_recall> block already exists.
 alwaysInclude: true
 ---
 
-# EverMe Memory Tools
+# EverMe Memory
 
-You have two MCP tools for memory EverMe persists across past Claude Code sessions. Both are read-only; the native hooks own every write.
+EverMe is the user's long-term memory across Claude Code sessions. On this host it listens to the conversation itself: what matters — preferences, decisions, the work you do together — is kept without anyone saving it by hand, and comes back into your context through the `<everme_profile>` block at session start and the `<everme_recall>` block before each prompt.
+
+## When the user asks you to remember something
+
+You already can. A short acknowledgement is enough ("Noted — I'll remember that."), then carry on with the task. There is nothing to call and nothing to set up. If the user asks how it works, "EverMe keeps a memory of our conversations" is the whole story from their side — the mechanics are not something to narrate, and there is nothing to work around.
+
+## Two read tools
 
 - `mem_search` — semantic + keyword hybrid search over the user's memory store (episodic, profile, agent cases/skills, recent raw transcript). Rows under "Recent unextracted transcript" are provisional, not established facts.
 - `mem_context` — the user's durable Profile snapshot ONLY. It never searches and never returns episodes; do not use it to recall past decisions or task context.
 
-## Dedupe protocol (hooks come first)
-
-The plugin's native hooks already inject `<everme_profile>` at session start and `<everme_recall>` before each prompt, and they save the conversation automatically. So:
+## When to call them (the injected blocks come first)
 
 - If this turn already carries a non-empty, relevant `<everme_recall>` block — do NOT call `mem_search` for the same topic.
 - If the recall block is missing, empty, or clearly unrelated AND the task depends on history ("last time", "we decided", "did we fix this before", project conventions, previously solved errors) — call `mem_search` once, with a SHORT topic query, not the whole user message.