@everme/claude-code 0.6.4 → 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.4",
+      "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.4",
+  "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

@@ -4,6 +4,7 @@ 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",
@@ -11,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");
@@ -18,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 || "",
@@ -42,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]);
@@ -56,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);
     }
@@ -66,10 +74,16 @@ 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)
@@ -113,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/claude-code",
-  "version": "0.6.4",
+  "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.4"
+    "@everme/agent-sdk": "^0.6.5"
   },
   "keywords": [
     "evermind",