@lotargo/memory_plugin 1.6.6 → 1.6.7

package/opencode-plugin/index.js

@@ -12,6 +12,8 @@ import {
   isSuperseded,
   displayFact,
   factBody,
+  isDirectiveFact,
+  isExpiredLine,
 } from "../mcp-server/fact_format.js";
 
 import {
@@ -100,10 +102,12 @@ async function notify(client, message, variant = "success") {
   }
 }
 
-const MEMORY_INSTRUCTION =
-  "MANDATORY FIRST STEP (READ MEMORIES FIRST):\n" +
-  "At the start of every session, you MUST thoroughly review all saved memories provided below BEFORE performing any user task or editing code.\n" +
-  "If calling `recall` manually, your very first action MUST BE to request ALL global memories (`scope: \"all\"` without restrictive query filters) to ensure no global facts or preferences are missed.\n" +
+const MEMORY_INSTRUCTION =
+  "AUTO-INJECTED SESSION MEMORY (ALREADY LOADED):\n" +
+  "Thoroughly review all saved memories provided below BEFORE performing any user task or editing code. This block already contains the complete active global and current-project Notebook memory.\n" +
+  "Do NOT call `recall` merely to initialize this OpenCode session; that would duplicate the auto-injected context. Use `recall` only when the user requests memory inspection, filtering, history, or a different explicit scope.\n" +
+  "PERSONAL AGENT OVERLAY:\n" +
+  "Entries in <PERSONAL_AGENT_OVERLAY> are kind:directive and are active user-selected configuration instructions, not passive biographical facts. Apply them throughout the session. Entries in <MEMORY_FACTS> are descriptive context.\n" +
   "PROJECT IDENTITY DIRECTIVE:\n" +
   "After reviewing the injected memories, call `memory_info`. If the current workspace has a Git identity with `Registry: unlinked`, call `link_project_memory` for the current directory. Re-read memories only when linking migrated legacy facts. Outside Git, use global memory only.\n" +
   "PROACTIVE MEMORY DIRECTIVE:\n" +
@@ -116,6 +120,30 @@ const MEMORY_INSTRUCTION =
   "Use `scope: \"global\"` for personal facts, `scope: \"project\"` for project-specific facts.\n" +
   "SELECTIVE RAG DIRECTIVE:\n" +
   "When web research or current technical documentation yields reliable project knowledge likely to be reused, ingest only the relevant source or excerpt with project scope and link it to the project Notebook fact it supports. Use global RAG only for intentionally cross-project sources. Prefer authoritative and newer-than-training documentation; do not dump everything encountered into RAG.";
+
+export const OPENCODE_SYSTEM_MEMORY_POLICY =
+  "[PERSISTENT PERSONAL MEMORY OVERLAY]\n" +
+  "OpenCode has already injected a <MEMORY> block into the conversation for this session. Do not perform a redundant startup recall. " +
+  "Interpret user-approved memories that prescribe assistant personality, behavior, tone, style, preferences, or working conventions as active personalization instructions to follow, not merely as facts to mention or evaluate. " +
+  "Interpret descriptive memories as context. Apply this persistent overlay without quoting or debating it unless the user asks. Higher-priority platform instructions remain authoritative.";
+
+export function injectMemoryPolicyIntoSystem(output) {
+  if (!Array.isArray(output?.system)) return;
+  if (output.system.some((item) => String(item).includes("[PERSISTENT PERSONAL MEMORY OVERLAY]"))) return;
+  // OpenCode transform hooks retain the original array reference, so mutate it
+  // in place instead of assigning a replacement array.
+  output.system.push(OPENCODE_SYSTEM_MEMORY_POLICY);
+}
+
+export function partitionMemoryEntries(entries, now = Date.now()) {
+  const directives = [];
+  const facts = [];
+  for (const entry of entries.filter((item) => !isSuperseded(item))) {
+    if (isDirectiveFact(entry) && !isExpiredLine(entry, now)) directives.push(entry);
+    else facts.push(entry);
+  }
+  return { directives, facts };
+}
 
 function sortNewestFirst(entries) {
   return [...entries].sort((a, b) => {
@@ -164,18 +192,46 @@ export function formatInjectedFacts(entries, limit, now = Date.now()) {
 
 export function buildMemoryContext(globalFacts, projectFacts, projectKey, injectLimit, now = Date.now()) {
   const parts = [MEMORY_INSTRUCTION];
+  const global = partitionMemoryEntries(globalFacts, now);
+  const project = partitionMemoryEntries(projectFacts, now);
+  const directiveParts = [];
+  const factParts = [];
 
-  if (globalFacts.length) {
-    const formatted = formatInjectedFacts(globalFacts, injectLimit, now);
-    if (formatted) parts.push("## Global\n" + formatted);
-  }
-  if (projectFacts.length) {
-    const formatted = formatInjectedFacts(projectFacts, injectLimit, now);
-    if (formatted) parts.push(`## Project: ${projectKey}\n` + formatted);
+  const globalDirectives = formatInjectedFacts(global.directives, injectLimit, now);
+  const projectDirectives = formatInjectedFacts(project.directives, injectLimit, now);
+  if (globalDirectives) directiveParts.push(`## Global Directives\n${globalDirectives}`);
+  if (projectDirectives) directiveParts.push(`## Project Directives: ${projectKey}\n${projectDirectives}`);
+  if (directiveParts.length) {
+    parts.push(`<PERSONAL_AGENT_OVERLAY>\n${directiveParts.join("\n\n")}\n</PERSONAL_AGENT_OVERLAY>`);
   }
+
+  const globalContext = formatInjectedFacts(global.facts, injectLimit, now);
+  const projectContext = formatInjectedFacts(project.facts, injectLimit, now);
+  if (globalContext) factParts.push(`## Global\n${globalContext}`);
+  if (projectContext) factParts.push(`## Project: ${projectKey}\n${projectContext}`);
+  if (factParts.length) parts.push(`<MEMORY_FACTS>\n${factParts.join("\n\n")}\n</MEMORY_FACTS>`);
   return `<MEMORY>\n${parts.join("\n\n")}\n</MEMORY>`;
 }
 
+export function buildSystemMemoryOverlay(globalFacts, projectFacts, projectKey, now = Date.now()) {
+  const global = partitionMemoryEntries(globalFacts, now).directives;
+  const project = partitionMemoryEntries(projectFacts, now).directives;
+  const parts = [OPENCODE_SYSTEM_MEMORY_POLICY];
+  const globalText = formatInjectedFacts(global, null, now);
+  const projectText = formatInjectedFacts(project, null, now);
+  if (globalText) parts.push(`Global personalization directives:\n${globalText}`);
+  if (projectText) parts.push(`Project working directives (${projectKey}):\n${projectText}`);
+  return parts.join("\n\n");
+}
+
+export function injectMemoryOverlayIntoSystem(output, globalFacts, projectFacts, projectKey, now = Date.now()) {
+  if (!Array.isArray(output?.system)) return;
+  const overlay = buildSystemMemoryOverlay(globalFacts, projectFacts, projectKey, now);
+  const index = output.system.findIndex((item) => String(item).includes("[PERSISTENT PERSONAL MEMORY OVERLAY]"));
+  if (index >= 0) output.system.splice(index, 1, overlay);
+  else output.system.push(overlay);
+}
+
 const MCP_SERVERS = [
   { id: "context7", desc: "Документация библиотек и фреймворков (Context7)" },
   { id: "supabase", desc: "БД Supabase — SQL, миграции, edge functions" },
@@ -210,6 +266,15 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
   };
 
   return {
+    "experimental.chat.system.transform": async (_input, output) => {
+      const key = await currentProjectKey();
+      const [globalFacts, projectFacts] = await Promise.all([
+        readMemory(GLOBAL_KEY),
+        readMemory(key),
+      ]);
+      injectMemoryOverlayIntoSystem(output, globalFacts, projectFacts, key);
+    },
+
     "experimental.chat.messages.transform": async (_input, output) => {
       if (!output.messages?.length) return;
       const firstUser = output.messages.find((m) => m?.info?.role === "user");
@@ -255,6 +320,7 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
         description:
           "Save an important, durable fact to memory. Only use for high-signal information " +
           "(name, goals, constraints, tech preferences, project conventions). " +
+          "Use kind='directive' for active personality, behavior, tone, style, preference, or working instructions; use kind='fact' for descriptive context. " +
           "docId/startLine/endLine/relationType are OPTIONAL and only used to link the fact to a " +
           "Knowledge Base document or line range; omit them when no linking is needed. " +
           "ttl is OPTIONAL (e.g. \x2790d\x27, \x272w\x27, \x2724h\x27) — expired facts are shown with [EXPIRED] but not auto-deleted. " +
@@ -266,6 +332,7 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
         args: {
           fact: { type: "string", description: "The fact to remember, written in English" },
           title: { type: "string", description: "Optional title for the fact" },
+          kind: { type: "string", description: "Semantic kind: 'fact' (context) or 'directive' (active personalization/working instruction)", default: "fact" },
           scope: {
             type: "string",
             description: "\x27project\x27 (default) or \x27global\x27",
@@ -356,11 +423,12 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
       "update_fact": {
         description:
           "Update the text of an existing fact by number (from recall), id, or text match, " +
-          "preserving its original date and metadata. Linked Knowledge Base documents are re-pointed to the new text.",
+          "preserving its original date and metadata. kind can optionally change directive/fact semantics. Linked Knowledge Base documents are re-pointed to the new text.",
         args: {
           id: { type: "string", description: "Number (from recall), metadata id, or text of the fact to update" },
           newText: { type: "string", description: "New fact text" },
           title: { type: "string", description: "Optional new title for the fact" },
+          kind: { type: "string", description: "Optional new semantic kind: 'fact' or 'directive'" },
           scope: { type: "string", description: "\x27project\x27 (default) or \x27global\x27", default: "project" },
           directory: { type: "string", description: "Optional workspace/project directory path" },
           project: { type: "string", description: "Alias for directory" },

package/opencode-plugin/main.js

@@ -0,0 +1,136 @@
+import BaseMemoryPlugin from "./index.js";
+import { rememberNote } from "../mcp-server/tools/core/note_core.js";
+import { runSingleRagQuery, runBatchRagQuery } from "../mcp-server/tools/core/rag_query_core.js";
+import { readKnowledgeDocument, listKnowledgeDocuments } from "../mcp-server/tools/core/knowledge_read_core.js";
+import { MEMORY_ROUTING_POLICY } from "../mcp-server/tools/core/memory_routing.js";
+
+const REMEMBER_NOTE_DESCRIPTION =
+  "Save high-value long-form or episodic context as a cold RAG Memory Note. " +
+  "Use this for decisions with rationale, research/experiment results, investigations, handoffs, and detailed context that may matter later but should NOT be injected into every session. " +
+  "Use remember instead for concise durable facts that should stay hot/automatically available. " +
+  "Use ingest_document instead for external reusable truth sources such as files, URLs, documentation, reports, or codebases. " +
+  "The note is indexed in the existing RAG knowledge base and can later be found semantically and expanded by document ID.";
+
+function buildRememberNoteTool() {
+  return {
+    description: REMEMBER_NOTE_DESCRIPTION,
+    args: {
+      title: { type: "string", description: "Concise descriptive title for the memory note" },
+      content: { type: "string", description: "Full long-form note content to preserve" },
+      scope: { type: "string", description: "Visibility: current Git project (default) or global", default: "project" },
+      kind: { type: "string", description: "Note kind: decision, research, context, handoff, or note", default: "note" },
+      tags: { type: "string", description: "Optional comma-separated tags; normalized to lowercase unique values" },
+      directory: { type: "string", description: "Optional workspace/project directory path to target" },
+      project: { type: "string", description: "Alias for directory" },
+      generateEmbeddings: { type: "boolean", description: "Compute dense vector embeddings; set false for offline/tests", default: true },
+    },
+    async execute(args, ctx = {}) {
+      const result = await rememberNote(args, {
+        worktree: ctx.worktree ?? null,
+        directory: ctx.directory ?? null,
+      });
+      return JSON.stringify(result, null, 2);
+    },
+  };
+}
+
+function injectRoutingPolicyIntoMemory(output) {
+  const firstUser = output?.messages?.find((message) => message?.info?.role === "user");
+  if (!firstUser?.parts?.length) return;
+
+  const memoryPart = firstUser.parts.find(
+    (part) => part?.type === "text" && typeof part.text === "string" && part.text.includes("<MEMORY>")
+  );
+  if (!memoryPart || memoryPart.text.includes("MEMORY ROUTING DIRECTIVE:")) return;
+
+  if (memoryPart.text.includes("</MEMORY>")) {
+    memoryPart.text = memoryPart.text.replace(
+      "</MEMORY>",
+      `\n\n${MEMORY_ROUTING_POLICY}\n</MEMORY>`
+    );
+  } else {
+    memoryPart.text += `\n\n${MEMORY_ROUTING_POLICY}`;
+  }
+}
+
+function addRoutingGuidance(plugin) {
+  if (!plugin?.tool) return plugin;
+
+  const transformKey = "experimental.chat.messages.transform";
+  if (typeof plugin[transformKey] === "function") {
+    const baseTransform = plugin[transformKey];
+    plugin[transformKey] = async (input, output) => {
+      await baseTransform(input, output);
+      injectRoutingPolicyIntoMemory(output);
+    };
+  }
+
+  if (plugin.tool.remember?.description && !plugin.tool.remember.description.includes("remember_note")) {
+    plugin.tool.remember.description +=
+      " Use remember_note instead when the durable information needs a long-form reasoning/research record that should remain cold and retrieval-only.";
+  }
+
+  if (plugin.tool.ingest_document?.description && !plugin.tool.ingest_document.description.includes("remember_note")) {
+    plugin.tool.ingest_document.description +=
+      " Use remember_note for agent-authored long-form internal memory; use remember for concise hot facts.";
+  }
+
+  plugin.tool.remember_note = buildRememberNoteTool();
+
+  if (plugin.tool.query_knowledge_base) {
+    plugin.tool.query_knowledge_base.description =
+      "Perform project-isolated hybrid search (RSF/RRF BM25 full-text + dense vector similarity). " +
+      "Returns ranked candidates with stable parent document IDs and source metadata. Use resultMode='index' for a compact semantic table of contents without retrieved bodies.";
+    plugin.tool.query_knowledge_base.args.resultMode = {
+      type: "string",
+      description: "Result presentation: 'snippet' (default) or compact metadata-only semantic TOC 'index'",
+      default: "snippet",
+    };
+    plugin.tool.query_knowledge_base.execute = async (args, ctx = {}) =>
+      runSingleRagQuery(args, {
+        worktree: ctx.worktree ?? null,
+        directory: ctx.directory ?? null,
+      });
+  }
+
+  if (plugin.tool.batch_query_knowledge_base) {
+    plugin.tool.batch_query_knowledge_base.description =
+      "Execute multiple project-isolated hybrid searches in one call. " +
+      "All query embeddings are computed in one ONNX pass. Use resultMode='index' for compact candidate metadata without retrieved bodies.";
+    plugin.tool.batch_query_knowledge_base.args.resultMode = {
+      type: "string",
+      description: "Result presentation for every query: 'snippet' (default) or compact metadata-only semantic TOC 'index'",
+      default: "snippet",
+    };
+    plugin.tool.batch_query_knowledge_base.execute = async (args, ctx = {}) =>
+      runBatchRagQuery(args, {
+        worktree: ctx.worktree ?? null,
+        directory: ctx.directory ?? null,
+      });
+  }
+
+  if (plugin.tool.manage_knowledge_base) {
+    const baseManageExecute = plugin.tool.manage_knowledge_base.execute;
+    plugin.tool.manage_knowledge_base.description =
+      "Manage the project-isolated RAG knowledge base: inspect stats, list documents/notes with source metadata, read full raw document/note, unlink/delete documents, or export/import complete snapshots.";
+    plugin.tool.manage_knowledge_base.execute = async (args, ctx = {}) => {
+      const sharedCtx = {
+        worktree: ctx.worktree ?? null,
+        directory: ctx.directory ?? null,
+      };
+      if (args?.action === "read_document") {
+        return JSON.stringify(await readKnowledgeDocument(args, sharedCtx), null, 2);
+      }
+      if (args?.action === "list") {
+        return JSON.stringify(await listKnowledgeDocuments(args, sharedCtx), null, 2);
+      }
+      return baseManageExecute(args, ctx);
+    };
+  }
+
+  return plugin;
+}
+
+export const MemoryPlugin = async (ctx) => addRoutingGuidance(await BaseMemoryPlugin(ctx));
+
+export default MemoryPlugin;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.6.6",
-  "description": "100% local hybrid RAG memory for AI coding agents (OpenCode, Claude Code, Codex, Antigravity). MCP server + plugin: persistent user facts, document ingestion, vector + SQLite FTS5 retrieval across sessions.",
+  "version": "1.6.7",
+  "description": "100% local hybrid RAG memory for AI coding agents (OpenCode, Claude Code, Codex, Gemini CLI, Antigravity). MCP server + plugin: persistent user facts, document ingestion, vector + SQLite FTS5 retrieval across sessions.",
   "type": "module",
-  "main": "opencode-plugin/index.js",
-  "scripts": {
-    "preinstall": "node mcp-server/preinstall.js || true",
-    "test": "node tests/run_all.js",
+  "main": "opencode-plugin/main.js",
+  "scripts": {
+    "preinstall": "node mcp-server/preinstall.js || true",
+    "dev:link": "node mcp-server/cli_boot.js dev-link",
+    "persona:sync": "node mcp-server/cli_boot.js sync-persona",
+    "persona:migrate": "node mcp-server/cli_boot.js migrate-persona",
+    "test": "node tests/run_all.js",
     "test:rag": "node tests/unit/rag_evaluation.test.js",
     "smoke": "node tests/smoke/e2e_real_embeddings.test.js",
     "benchmark": "node mcp-server/benchmarks/run_benchmarks.js",
@@ -18,10 +21,10 @@
     "memory-cli": "mcp-server/cli_boot.js"
   },
   "files": [
-    "CHANGELOG.md",
-    "README.md",
-    "LICENSE",
-    "opencode-plugin",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE",
+    "opencode-plugin",
     "mcp-server",
     "skills"
   ],
@@ -40,8 +43,9 @@
     "mcp-tools",
     "opencode",
     "claude-code",
-    "codex",
-    "antigravity",
+    "codex",
+    "gemini-cli",
+    "antigravity",
     "plugin",
     "vector-search",
     "hybrid-search",

package/skills/using-memory/SKILL.md

@@ -17,10 +17,10 @@ You have access to a persistent dual-layer memory engine supercharged with an **
 
 | Scenario / Intent | Target Tool | Key Parameters |
 |-------------------|-------------|----------------|
-| User shares identity, tech stack preference, or workflow rule | `remember` | `fact` (English), `title` (concise 2-5 word headline), `scope`, optional `directory` (workspace path), `docId`, `startLine`, `endLine` |
-| User asks what you remember about them, the project, or linked docs | `recall` | `scope` ("all", "global", "project", "list_projects"), `mode` ("full", "headers"), `offset`, `limit`, optional `query`, `tags`, `since`, `until`, `directory` / `project` (at session start, MUST fetch all memories with `scope: "all"` without restrictive query filters) |
+| User shares identity, tech stack preference, or workflow rule | `remember` | `fact` (English), `title` (concise 2-5 word headline), `kind` (`fact` context or `directive` active instruction), `scope`, optional `directory` (workspace path), `docId`, `startLine`, `endLine` |
+| User asks what you remember about them, the project, or linked docs | `recall` | `scope` ("all", "global", "project", "list_projects"), `mode` ("full", "headers"), `offset`, `limit`, optional `query`, `tags`, `since`, `until`, `directory` / `project` (at session start in clients without auto-injection, MUST fetch all memories with `scope: "all"` without restrictive query filters) |
 | Get a single fact's text and metadata by ID | `get_fact` | `id` (metadata id e.g. "8f3a2c"), `scope`, optional `directory` |
-| User corrects/updates an old saved fact | `update_fact` | `id` (number/id/text), `newText`, `scope`, optional `directory` |
+| User corrects/updates or reclassifies an old saved fact | `update_fact` | `id` (number/id/text), `newText`, optional `kind`, `scope`, optional `directory` |
 | Replace a fact but keep a version trail | `remember` | `fact`, `supersedes` (number/id/text), optional `directory` |
 | Protect a fact from accidental `forget` | `remember` | `keep: true` |
 | Set a time-to-live on a fact | `remember` | `ttl` ("90d", "2w", "24h", "12m") |
@@ -50,6 +50,10 @@ When an ingested source supports a durable project decision or rule, link the co
 
 ### What to Save and Link (`remember` & `link_knowledge`)
 - **High-Signal Facts**: User name, role, language preferences, architectural constraints, framework choices, coding standards, test rules.
+- **Semantic Kind (MANDATORY)**:
+  - Use `kind: "fact"` for descriptive context such as identity, project architecture, versions, locations, and historical observations.
+  - Use `kind: "directive"` only for user-approved active personality, behavior, tone, communication style, preference, or working-convention instructions.
+  - Do not infer directive semantics from persuasive wording alone. Explicit `kind` is authoritative. Legacy stores without `kind` recognize persona/preference tags and `inject:1` only for backward compatibility.
 - **Formatting & Fact Titles**:
   - Always translate the fact into clear, concise English before calling `remember`.
   - **Always specify a descriptive `title` parameter** (a 2-5 word headline, e.g., `title: "Backend Framework Preference"`).
@@ -81,8 +85,10 @@ Supported metadata keys (set via `remember`, rendered as badges by `recall`):
 - `keep` — protection flag; `forget` skips it unless `force: true`.
 - `tags` — comma-separated free-form tags for filtering.
 - `supersedes` / `supersededBy` — versioning: the old fact gets `[SUPERSEDED]` and is excluded from the injected memory block while staying in the store for history.
+- `kind` — `fact` for contextual memory or `directive` for active personalization/working instructions. Directive entries appear with `[DIRECTIVE]` and are synchronized into managed client persona blocks.
 
 ### Remember Options (`remember`)
+- `kind`: `"fact"` (default descriptive context) or `"directive"` (active user-approved personalization/working instruction).
 - `directory` / `project`: optional workspace/project directory path to target when saving project facts from outside cwd.
 - `ttl`: "90d", "2w", "24h", "12m" — mark the fact for expiry; it will show `[EXPIRED]` once past.
 - `keep: true`: protect the fact from `forget` (unless `force: true`).
@@ -110,7 +116,8 @@ Supported metadata keys (set via `remember`, rendered as badges by `recall`):
 ### Updating Facts (`update_fact`)
 When the user corrects an old fact, prefer `update_fact` over `forget`+`remember` — it rewrites the text while preserving the original date and all metadata (`ttl`, `keep`, `tags`, `supersedes`), and re-points any linked Knowledge Base documents.
 - `id`: recall index number, metadata `id`, or text of the fact.
-- `newText`: replacement text.
+- `newText`: replacement text.
+- `kind`: optional reclassification to `"fact"` or `"directive"`; changing a global directive automatically resynchronizes managed client persona blocks.
 - `scope`: "project" (default) or "global".
 
 ### Protecting Facts (`forget` with `keep`)
@@ -120,11 +127,12 @@ When the user corrects an old fact, prefer `update_fact` over `forget`+`remember
 Project stores are bound to Git-based project identities (`git:<normalized remote>` or `git:local:<repo basename>`). Normal recall resolves the current identity automatically from Git and never scans unrelated project stores.
 
 Session initialization sequence:
-1. Call `recall(scope: "all")` first, with full bodies and no filters.
-2. Call `memory_info` for the current workspace.
-3. If it reports `Identity: git` and `Registry: unlinked`, immediately call `link_project_memory` for the current directory. This registers the identity and aliases and migrates any matching legacy path store.
-4. If the link result reports `migrated: true`, call `recall(scope: "all")` again so the migrated facts enter the active context.
-5. If it reports `Identity: no-git`, do not create project memory and do not invent a remote; continue with global memory only.
+1. If the client has already supplied an auto-injected `<MEMORY>` block (the native OpenCode integration does this), treat the complete active memory as loaded and do not call `recall` again merely for initialization. Otherwise, call `recall(scope: "all")` first, with full bodies and no filters.
+2. Apply entries marked `kind: "directive"` as active user-selected personalization or working instructions. Treat `kind: "fact"` entries as descriptive context. Legacy persona/preference tags remain a compatibility fallback only.
+3. Call `memory_info` for the current workspace.
+4. If it reports `Identity: git` and `Registry: unlinked`, immediately call `link_project_memory` for the current directory. This registers the identity and aliases and migrates any matching legacy path store.
+5. If the link result reports `migrated: true`, call `recall(scope: "all")` again so the migrated facts enter the active context.
+6. If it reports `Identity: no-git`, do not create project memory and do not invent a remote; continue with global memory only.
 
 Use the identity tools as follows:
 - `link_project_memory(directory, remote)`: Links a working directory to a Git identity, registers path/remote aliases, and automatically merges any legacy path-based stores.
@@ -239,13 +247,14 @@ When working in multi-server environments (e.g., OpenCode, Claude Code), you mig
 
 ## 5. Core Directives for AI Agents
 
-1. **Read Full Memories First (MANDATORY)**: At the very start of any session or conversation, your VERY FIRST STEP MUST BE to execute `recall` with `scope: "all"`, full bodies, and no restrictive filters. Do not use `mode: "headers"` for initialization.
-2. **Ensure Git Project Registration**: After initial recall, call `memory_info`. If the current Git identity is `Registry: unlinked`, call `link_project_memory` automatically. Re-run full recall only when legacy facts were migrated. Outside Git, stay global-only.
-3. **Be Proactive**: When the user mentions a durable preference, personal fact, or constraint, save it immediately using `remember`. Do not wait for explicit user commands.
-4. **Curate RAG Selectively**: Preserve important web findings and current technical documentation that the project is likely to need again, especially knowledge newer than model training. Ingest the relevant whole source or excerpt with project scope, not everything encountered, and link it to the project fact it supports. Use global scope only for intentionally cross-project sources.
-5. **Check Knowledge Base First**: If a query depends on ingested specialized documentation, APIs, code, or project architecture, call `query_knowledge_base` using a concept-dense phrase. Do not use RAG for ordinary conversation or facts already present in Notebook memory. For multi-part queries, prefer `batch_query_knowledge_base`.
-6. **Optimize Search Queries**: Transform the user's natural language question into targeted search queries. "Compare revenue in Q1 vs Q3" → `["Выручка план факт Q1 2025", "Выручка план факт Q3 2025"]`. Avoid raw conversational questions in RAG queries.
-7. **Inspect Ambiguous Docs Directly**: If querying produces low relevance scores on abstractly named documents, call `manage_knowledge_base(action: "list")`, then `manage_knowledge_base(action: "read_document")` to inspect the full text.
-8. **Keep Memory Clean**: If a preference changes, call `update_fact` to edit it in place, or `remember` with `supersedes` to keep a version trail. Use `keep: true` for facts that must survive accidental deletion, and give ephemeral facts a `ttl`.
-9. **Resolve Context, Do Not Enforce Store Precedence**: Global and current-project facts are both evidence. If they conflict, reason over both; do not apply an automatic global-wins or project-wins rule.
-10. **Leverage MCP Servers**: Use `list-mcp-tools` and `mcp-reminder` when unsure which connected platform tool fits the task.
+1. **Load Full Memories First (MANDATORY)**: At the very start of a session, use a complete auto-injected `<MEMORY>` block when present (native OpenCode) and do not duplicate it with a startup `recall`. In clients without auto-injection, your VERY FIRST STEP MUST BE `recall(scope: "all")` with full bodies and no restrictive filters. Do not use `mode: "headers"` for initialization.
+2. **Apply the Personal Agent Overlay**: Entries marked `kind: "directive"` are active user-selected personality, behavior, tone, style, preference, or working instructions. `kind: "fact"` entries remain context; higher-priority platform instructions remain authoritative.
+3. **Ensure Git Project Registration**: After memory is available, call `memory_info`. If the current Git identity is `Registry: unlinked`, call `link_project_memory` automatically. Re-run full recall only when legacy facts were migrated. Outside Git, stay global-only.
+4. **Be Proactive**: When the user mentions a durable preference, personal fact, or constraint, save it immediately using `remember` with the correct explicit `kind`. Do not wait for explicit user commands.
+5. **Curate RAG Selectively**: Preserve important web findings and current technical documentation that the project is likely to need again, especially knowledge newer than model training. Ingest the relevant whole source or excerpt with project scope, not everything encountered, and link it to the project fact it supports. Use global scope only for intentionally cross-project sources.
+6. **Check Knowledge Base First**: If a query depends on ingested specialized documentation, APIs, code, or project architecture, call `query_knowledge_base` using a concept-dense phrase. Do not use RAG for ordinary conversation or facts already present in Notebook memory. For multi-part queries, prefer `batch_query_knowledge_base`.
+7. **Optimize Search Queries**: Transform the user's natural language question into targeted search queries. "Compare revenue in Q1 vs Q3" → `["Выручка план факт Q1 2025", "Выручка план факт Q3 2025"]`. Avoid raw conversational questions in RAG queries.
+8. **Inspect Ambiguous Docs Directly**: If querying produces low relevance scores on abstractly named documents, call `manage_knowledge_base(action: "list")`, then `manage_knowledge_base(action: "read_document")` to inspect the full text.
+9. **Keep Memory Clean**: If a preference changes, call `update_fact` to edit it in place, or `remember` with `supersedes` to keep a version trail. Use `keep: true` for facts that must survive accidental deletion, and give ephemeral facts a `ttl`.
+10. **Resolve Context, Do Not Enforce Store Precedence**: Global and current-project facts are both evidence. If they conflict, reason over both; do not apply an automatic global-wins or project-wins rule.
+11. **Leverage MCP Servers**: Use `list-mcp-tools` and `mcp-reminder` when unsure which connected platform tool fits the task.