pi-hermes-memory 0.2.0 → 0.2.1

package/README.md

@@ -305,6 +305,8 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 {
   "memoryCharLimit": 2200,
   "userCharLimit": 1375,
+  "projectCharLimit": 2200,
+  "memoryDir": "~/.pi/agent/memory",
   "nudgeInterval": 10,
   "nudgeToolCalls": 15,
   "reviewEnabled": true,
@@ -320,6 +322,8 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 |---|---|---|
 | `memoryCharLimit` | `2200` | Max characters in MEMORY.md |
 | `userCharLimit` | `1375` | Max characters in USER.md |
+| `projectCharLimit` | `2200` | Max characters in project-scoped MEMORY.md |
+| `memoryDir` | `~/.pi/agent/memory` | Custom directory for memory files |
 | `nudgeInterval` | `10` | Turns between auto-reviews |
 | `nudgeToolCalls` | `15` | Tool calls between auto-reviews (OR with turns) |
 | `reviewEnabled` | `true` | Enable/disable background learning loop |

package/docs/0.2/TASKS.md

@@ -118,8 +118,8 @@ _Done when: v0.2.0 is tagged and released with updated docs._
 - [x] Update `docs/ROADMAP.md` — v0.2 roadmap documented (`d5b7518`)
 - [x] `npm run check` passes with zero errors (`c6317dd`)
 - [x] `npm test` — all 218 tests pass (`83e7c46`)
-- [ ] Bump `package.json` version to `0.2.0`
-- [ ] Tag v0.2.0 release
+- [x] Bump `package.json` version to `0.2.0`
+- [x] Tag v0.2.0 release
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Your Pi agent remembers everything across sessions — your preferences, your stack, your corrections, and even how it solved problems. Zero-config install, works immediately. Persistent memory + procedural skills + auto-correction detection + security-first content scanning.",
   "type": "module",
   "main": "src/index.ts",
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "test": "npx tsx --test 'tests/**/*.test.ts' --test-concurrency=1"
+    "test": "tests/run-all.sh"
   },
   "keywords": [
     "pi-package",
@@ -38,11 +38,12 @@
     "url": "https://github.com/chandra447/pi-hermes-memory"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@mariozechner/pi-coding-agent": ">=0.70.0"
   },
   "devDependencies": {
     "@mariozechner/pi-ai": "^0.70.0",
     "@mariozechner/pi-coding-agent": "^0.70.0",
+    "tsx": "^4.21.0",
     "typebox": "^1.1.33",
     "typescript": "^6.0.3"
   }

package/src/config.ts

@@ -5,6 +5,7 @@ import type { MemoryConfig } from "./types.js";
 import {
   DEFAULT_MEMORY_CHAR_LIMIT,
   DEFAULT_USER_CHAR_LIMIT,
+  DEFAULT_PROJECT_CHAR_LIMIT,
   DEFAULT_NUDGE_INTERVAL,
   DEFAULT_FLUSH_MIN_TURNS,
   DEFAULT_NUDGE_TOOL_CALLS,
@@ -13,6 +14,7 @@ import {
 const DEFAULT_CONFIG: MemoryConfig = {
   memoryCharLimit: DEFAULT_MEMORY_CHAR_LIMIT,
   userCharLimit: DEFAULT_USER_CHAR_LIMIT,
+  projectCharLimit: DEFAULT_PROJECT_CHAR_LIMIT,
   nudgeInterval: DEFAULT_NUDGE_INTERVAL,
   reviewEnabled: true,
   flushOnCompact: true,
@@ -47,6 +49,8 @@ export function loadConfig(): MemoryConfig {
       if (typeof parsed.autoConsolidate === "boolean") config.autoConsolidate = parsed.autoConsolidate;
       if (typeof parsed.correctionDetection === "boolean") config.correctionDetection = parsed.correctionDetection;
       if (typeof parsed.nudgeToolCalls === "number") config.nudgeToolCalls = parsed.nudgeToolCalls;
+      if (typeof parsed.projectCharLimit === "number") config.projectCharLimit = parsed.projectCharLimit;
+      if (typeof parsed.memoryDir === "string") config.memoryDir = parsed.memoryDir;
       return config;
     }
   } catch {

package/src/constants.ts

@@ -12,6 +12,8 @@ export const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
 export const DEFAULT_USER_CHAR_LIMIT = 1375;
 
 // ─── Learning loop defaults ───
+export const DEFAULT_PROJECT_CHAR_LIMIT = 2200;
+
 export const DEFAULT_NUDGE_INTERVAL = 10;
 export const DEFAULT_FLUSH_MIN_TURNS = 6;
 export const DEFAULT_NUDGE_TOOL_CALLS = 15;
@@ -35,9 +37,10 @@ PRIORITY: User preferences and corrections > environment facts > procedural know
 
 Do NOT save task progress, session outcomes, completed-work logs, or temporary TODO state.
 
-TWO TARGETS:
+THREE TARGETS:
 - 'user': who the user is -- name, role, preferences, communication style, pet peeves
-- 'memory': your notes -- environment facts, project conventions, tool quirks, lessons learned
+- 'memory': your global notes -- environment facts, tool quirks, lessons learned (shared across all projects)
+- 'project': project-specific notes -- architecture decisions, API quirks, team norms, codebase conventions (scoped to current project)
 
 ACTIONS: add (new entry), replace (update existing -- old_text identifies it), remove (delete -- old_text identifies it).`;
 

package/src/handlers/background-review.ts

@@ -16,6 +16,7 @@ import { getMessageText } from "../types.js";
 export function setupBackgroundReview(
   pi: ExtensionAPI,
   store: MemoryStore,
+  projectStore: MemoryStore | null,
   config: MemoryConfig,
 ): void {
   let turnsSinceReview = 0;
@@ -35,17 +36,17 @@ export function setupBackgroundReview(
     if (!config.reviewEnabled) return;
     if (reviewInProgress) return;
 
-    // Count tool-use entries from the branch for tool-call-aware nudge
+    // Count tool calls from this turn's message only (not cumulative branch scan —
+    // otherwise the counter resets to 0 at review, then immediately re-counts all
+    // historical tool calls and re-triggers on every subsequent turn).
     try {
-      const branch = ctx.sessionManager.getBranch();
-      for (const entry of branch) {
-        if (entry.type === "message" && entry.message?.role === "assistant") {
-          const content = entry.message?.content;
-          if (Array.isArray(content)) {
-            for (const block of content) {
-              if (block && typeof block === "object" && block.type === "toolCall") {
-                toolCallsSinceReview++;
-              }
+      const msg = event.message;
+      if (msg?.role === "assistant") {
+        const content = msg?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && typeof block === "object" && block.type === "toolCall") {
+              toolCallsSinceReview++;
             }
           }
         }
@@ -82,6 +83,7 @@ export function setupBackgroundReview(
 
       const currentMemory = store.getMemoryEntries().join("\n§\n");
       const currentUser = store.getUserEntries().join("\n§\n");
+      const currentProject = projectStore ? projectStore.getMemoryEntries().join("\n§\n") : null;
 
       const reviewPrompt = [
         COMBINED_REVIEW_PROMPT,
@@ -91,12 +93,23 @@ export function setupBackgroundReview(
         "",
         "--- Current User Profile ---",
         currentUser || "(empty)",
+      ];
+
+      if (currentProject !== null) {
+        reviewPrompt.push(
+          "",
+          "--- Current Project Memory ---",
+          currentProject || "(empty)",
+        );
+      }
+
+      reviewPrompt.push(
         "",
         "--- Conversation to Review ---",
         parts.join("\n\n"),
-      ].join("\n");
+      );
 
-      const result = await pi.exec("pi", ["-p", "--no-session", reviewPrompt], {
+      const result = await pi.exec("pi", ["-p", "--no-session", reviewPrompt.join("\n")], {
         signal: ctx.signal,
         timeout: 60000,
       });

package/src/handlers/correction-detector.ts

@@ -57,6 +57,7 @@ export function isCorrection(text: string): boolean {
 export function setupCorrectionDetector(
   pi: ExtensionAPI,
   store: MemoryStore,
+  projectStore: MemoryStore | null,
   config: MemoryConfig,
 ): void {
   if (!config.correctionDetection) return;
@@ -109,6 +110,7 @@ export function setupCorrectionDetector(
 
       const currentMemory = store.getMemoryEntries().join(ENTRY_DELIMITER);
       const currentUser = store.getUserEntries().join(ENTRY_DELIMITER);
+      const currentProject = projectStore ? projectStore.getMemoryEntries().join(ENTRY_DELIMITER) : null;
 
       const prompt = [
         CORRECTION_SAVE_PROMPT,
@@ -118,12 +120,23 @@ export function setupCorrectionDetector(
         "",
         "--- Current User Profile ---",
         currentUser || "(empty)",
+      ];
+
+      if (currentProject !== null) {
+        prompt.push(
+          "",
+          "--- Current Project Memory ---",
+          currentProject || "(empty)",
+        );
+      }
+
+      prompt.push(
         "",
         "--- Recent Conversation ---",
         recentParts.join("\n\n"),
-      ].join("\n");
+      );
 
-      const result = await pi.exec("pi", ["-p", "--no-session", prompt], {
+      const result = await pi.exec("pi", ["-p", "--no-session", prompt.join("\n")], {
         signal: ctx.signal,
         timeout: 30000,
       });

package/src/handlers/insights.ts

@@ -5,12 +5,13 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { MemoryStore } from "../store/memory-store.js";
 
-export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore): void {
+export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore, projectStore: MemoryStore | null, projectName: string): void {
   pi.registerCommand("memory-insights", {
     description: "Show what's stored in persistent memory",
     handler: async (_args, ctx) => {
       const memoryEntries = store.getMemoryEntries();
       const userEntries = store.getUserEntries();
+      const projectEntries = projectStore ? projectStore.getMemoryEntries() : null;
 
       const lines: string[] = [];
       lines.push("");
@@ -51,6 +52,24 @@ export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore): v
       }
       lines.push("");
 
+      // Project section
+      if (projectEntries !== null) {
+        lines.push(`  📁 PROJECT MEMORY: ${projectName}`);
+        lines.push("  " + "─".repeat(44));
+        if (projectEntries.length === 0) {
+          lines.push("  (empty)");
+        } else {
+          for (let i = 0; i < projectEntries.length; i++) {
+            const preview =
+              projectEntries[i].length > 100
+                ? projectEntries[i].slice(0, 100) + "..."
+                : projectEntries[i];
+            lines.push(`  ${i + 1}. ${preview}`);
+          }
+        }
+        lines.push("");
+      }
+
       ctx.ui.notify(lines.join("\n"), "info");
     },
   });

package/src/handlers/session-flush.ts

@@ -13,6 +13,7 @@ import { getMessageText } from "../types.js";
 export function setupSessionFlush(
   pi: ExtensionAPI,
   store: MemoryStore,
+  projectStore: MemoryStore | null,
   config: MemoryConfig,
 ): void {
   let userTurnCount = 0;

package/src/handlers/skill-auto-trigger.ts

@@ -20,24 +20,24 @@ export function setupSkillAutoTrigger(
 ): void {
   let triggeredThisSession = false;
 
+  // Accumulate tool calls across turns (reset on trigger)
+  let toolCallCount = 0;
+  const toolTypes = new Set<string>();
+
   pi.on("turn_end", async (event, ctx) => {
     if (triggeredThisSession) return;
 
-    // Count tool-use entries from this turn's branch
-    let toolCallCount = 0;
-    const toolTypes = new Set<string>();
-
+    // Count tool calls from this turn's message only (not cumulative branch scan —
+    // otherwise the counter accumulates historical tool calls and fires prematurely).
     try {
-      const branch = ctx.sessionManager.getBranch();
-      for (const entry of branch) {
-        if (entry.type === "message" && entry.message?.role === "assistant") {
-          const content = entry.message?.content;
-          if (Array.isArray(content)) {
-            for (const block of content) {
-              if (block && typeof block === "object" && block.type === "toolCall") {
-                toolCallCount++;
-                if ((block as { name?: string }).name) toolTypes.add((block as { name: string }).name);
-              }
+      const msg = event.message;
+      if (msg?.role === "assistant") {
+        const content = msg?.content;
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && typeof block === "object" && block.type === "toolCall") {
+              toolCallCount++;
+              if ((block as { name?: string }).name) toolTypes.add((block as { name: string }).name);
             }
           }
         }

package/src/index.ts

@@ -37,22 +37,37 @@ import { loadConfig } from "./config.js";
 export default function (pi: ExtensionAPI) {
   const config = loadConfig();
 
-  const memoryDir = config.memoryDir ?? path.join(os.homedir(), ".pi", "agent", "memory");
+  const globalDir = config.memoryDir ?? path.join(os.homedir(), ".pi", "agent", "memory");
   const store = new MemoryStore(config);
-  const skillStore = new SkillStore(path.join(memoryDir, "skills"));
+  const skillStore = new SkillStore(path.join(globalDir, "skills"));
+
+  // Detect project name from cwd — skip if running from home directory
+  const cwd = process.cwd();
+  const homeDir = os.homedir();
+  const projectName = path.basename(cwd);
+  const hasProject = cwd !== homeDir;
+
+  // Project-scoped store: ~/.pi/agent/<project_name>/
+  // Uses memoryCharLimit overridden to projectCharLimit for the "memory" target
+  const projectDir = hasProject ? path.join(homeDir, ".pi", "agent", projectName) : null;
+  const projectConfig = { ...config, memoryCharLimit: config.projectCharLimit, memoryDir: projectDir ?? undefined };
+  const projectStore = hasProject ? new MemoryStore(projectConfig) : null;
 
   // ── 1. Load memory from disk on session start ──
   pi.on("session_start", async (_event, _ctx) => {
     await store.loadFromDisk();
+    if (projectStore) await projectStore.loadFromDisk();
   });
 
-  // ── 2. Inject frozen snapshot + skill index into system prompt ──
+  // ── 2. Inject frozen snapshot + skill index + project memory into system prompt ──
   pi.on("before_agent_start", async (event, _ctx) => {
     const memoryBlock = store.formatForSystemPrompt();
     const skillIndex = await skillStore.formatIndexForSystemPrompt();
+    const projectBlock = projectStore ? projectStore.formatProjectBlock(projectName) : "";
 
     const parts: string[] = [];
     if (memoryBlock) parts.push(memoryBlock);
+    if (projectBlock) parts.push(projectBlock);
     if (skillIndex) parts.push(skillIndex);
 
     if (parts.length > 0) {
@@ -62,17 +77,17 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // ── 3. Register the memory tool ──
-  registerMemoryTool(pi, store);
+  // ── 3. Register the memory tool (with project store) ──
+  registerMemoryTool(pi, store, projectStore);
 
   // ── 4. Register the skill tool ──
   registerSkillTool(pi, skillStore);
 
   // ── 5. Setup background learning loop (with tool-call-aware nudge) ──
-  setupBackgroundReview(pi, store, config);
+  setupBackgroundReview(pi, store, projectStore, config);
 
   // ── 6. Setup session-end flush ──
-  setupSessionFlush(pi, store, config);
+  setupSessionFlush(pi, store, projectStore, config);
 
   // ── 7. Setup auto-consolidation (inject consolidator into store) ──
   store.setConsolidator(async (target, signal) => {
@@ -81,12 +96,12 @@ export default function (pi: ExtensionAPI) {
   registerConsolidateCommand(pi, store);
 
   // ── 8. Setup correction detection ──
-  setupCorrectionDetector(pi, store, config);
+  setupCorrectionDetector(pi, store, projectStore, config);
 
   // ── 9. Setup skill auto-trigger ──
   setupSkillAutoTrigger(pi, store, skillStore, config);
 
   // ── 10. Register commands ──
-  registerInsightsCommand(pi, store);
+  registerInsightsCommand(pi, store, projectStore, projectName);
   registerSkillsCommand(pi, skillStore);
 }

package/src/store/memory-store.ts

@@ -106,11 +106,23 @@ export class MemoryStore {
     if (newTotal > limit) {
       // Auto-consolidate if configured and consolidator available
       if (this.config.autoConsolidate && this.consolidator) {
+        // Track consolidation attempts to prevent infinite recursion
+        // when the consolidator fails to free enough space
+        const beforeCount = entries.length;
         try {
           const result = await this.consolidator(target, signal);
           if (result.consolidated) {
             // CRITICAL: reload from disk — child process modified files, our arrays are stale
             await this.loadFromDisk();
+            // Guard: if consolidation didn't reduce entries, stop recursing
+            const afterEntries = this.entriesFor(target);
+            const afterCount = afterEntries.length;
+            if (afterCount >= beforeCount && afterCount > 0) {
+              return {
+                success: false,
+                error: `Memory at capacity and consolidation did not free enough space. Entry count unchanged at ${afterCount}.`,
+              };
+            }
             // Retry the add with fresh data
             return this.add(target, content, signal);
           }
@@ -127,12 +139,12 @@ export class MemoryStore {
 
     entries.push(content);
     this.setEntries(target, entries);
-    this.saveToDisk(target);
+    await this.saveToDisk(target);
 
     return this.successResponse(target, "Entry added.");
   }
 
-  replace(target: "memory" | "user", oldText: string, newContent: string): MemoryResult {
+  async replace(target: "memory" | "user", oldText: string, newContent: string): Promise<MemoryResult> {
     oldText = oldText.trim();
     newContent = newContent.trim();
     if (!oldText) return { success: false, error: "old_text cannot be empty." };
@@ -167,12 +179,12 @@ export class MemoryStore {
 
     entries[idx] = newContent;
     this.setEntries(target, entries);
-    this.saveToDisk(target);
+    await this.saveToDisk(target);
 
     return this.successResponse(target, "Entry replaced.");
   }
 
-  remove(target: "memory" | "user", oldText: string): MemoryResult {
+  async remove(target: "memory" | "user", oldText: string): Promise<MemoryResult> {
     oldText = oldText.trim();
     if (!oldText) return { success: false, error: "old_text cannot be empty." };
 
@@ -191,7 +203,7 @@ export class MemoryStore {
     const idx = entries.indexOf(matches[0]);
     entries.splice(idx, 1);
     this.setEntries(target, entries);
-    this.saveToDisk(target);
+    await this.saveToDisk(target);
 
     return this.successResponse(target, "Entry removed.");
   }
@@ -205,6 +217,14 @@ export class MemoryStore {
     return parts.join("\n\n");
   }
 
+  /**
+   * Render a project-specific memory block for system prompt injection.
+   * Uses only the memory entries (no user split) with a project-labelled header.
+   */
+  formatProjectBlock(projectName: string): string {
+    return this.renderProjectBlock(projectName, this.memoryEntries);
+  }
+
   getMemoryEntries(): string[] {
     return [...this.memoryEntries];
   }
@@ -247,6 +267,18 @@ export class MemoryStore {
     return `${separator}\n${header}\n${separator}\n${content}`;
   }
 
+  private renderProjectBlock(projectName: string, entries: string[]): string {
+    if (!entries.length) return "";
+    const limit = this.config.memoryCharLimit;
+    const content = entries.join(ENTRY_DELIMITER);
+    const current = content.length;
+    const pct = limit > 0 ? Math.min(100, Math.floor((current / limit) * 100)) : 0;
+
+    const header = `PROJECT MEMORY: ${projectName} [${pct}% — ${current}/${limit} chars]`;
+    const separator = "═".repeat(46);
+    return `${separator}\n${header}\n${separator}\n${content}`;
+  }
+
   private async readFile(filePath: string): Promise<string[]> {
     try {
       const raw = await fs.readFile(filePath, "utf-8");
@@ -258,23 +290,22 @@ export class MemoryStore {
   }
 
   /** Atomic write: temp file + fs.rename() — same crash-safety as Hermes. */
-  private saveToDisk(target: "memory" | "user"): void {
+  private async saveToDisk(target: "memory" | "user"): Promise<void> {
     const filePath = this.pathFor(target);
     const entries = this.entriesFor(target);
     const content = entries.length ? entries.join(ENTRY_DELIMITER) : "";
 
-    // Fire-and-forget atomic write
-    fs.mkdtemp(path.join(os.tmpdir(), "pi-memory-")).then((tmpDir) => {
-      const tmpPath = path.join(tmpDir, "write.tmp");
-      return fs
-        .writeFile(tmpPath, content, "utf-8")
-        .then(() => fs.rename(tmpPath, filePath))
-        .catch(async () => {
-          try { await fs.unlink(tmpPath); } catch { /* ignore */ }
-        })
-        .finally(async () => {
-          try { await fs.rmdir(tmpDir); } catch { /* ignore */ }
-        });
-    });
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pi-memory-"));
+    const tmpPath = path.join(tmpDir, "write.tmp");
+
+    try {
+      await fs.writeFile(tmpPath, content, "utf-8");
+      await fs.rename(tmpPath, filePath);
+    } catch (err) {
+      try { await fs.unlink(tmpPath); } catch { /* ignore */ }
+      throw err;
+    } finally {
+      try { await fs.rmdir(tmpDir); } catch { /* ignore */ }
+    }
   }
 }

package/src/tools/memory-tool.ts

@@ -10,7 +10,7 @@ import { StringEnum } from "@mariozechner/pi-ai";
 import { MemoryStore } from "../store/memory-store.js";
 import { MEMORY_TOOL_DESCRIPTION } from "../constants.js";
 
-export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
+export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore, projectStore: MemoryStore | null): void {
   pi.registerTool({
     name: "memory",
     label: "Memory",
@@ -24,7 +24,7 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
     ],
     parameters: Type.Object({
       action: StringEnum(["add", "replace", "remove"] as const),
-      target: StringEnum(["memory", "user"] as const),
+      target: StringEnum(["memory", "user", "project"] as const),
       content: Type.Optional(
         Type.String({ description: "Entry content for add/replace" })
       ),
@@ -36,7 +36,21 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
       ),
     }),
     async execute(toolCallId, params, signal, onUpdate, ctx) {
-      const { action, target, content, old_text } = params;
+      const { action, target: rawTarget, content, old_text } = params;
+
+      // Route 'project' to projectStore (internal target 'memory')
+      const target = rawTarget as "memory" | "user";
+      const activeStore = rawTarget === "project" ? projectStore : store;
+
+      if (rawTarget === "project" && !projectStore) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: false, error: "Project memory is not available (no project detected)." }) }],
+          details: {},
+        };
+      }
+
+      // After the guard above, activeStore is guaranteed non-null when rawTarget === 'project'
+      const store_ = activeStore!;
 
       let result;
       switch (action) {
@@ -55,7 +69,7 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
               details: {},
             };
           }
-          result = await store.add(target, content);
+          result = await store_.add(target, content);
           break;
 
         case "replace":
@@ -87,7 +101,7 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
               details: {},
             };
           }
-          result = store.replace(target, old_text, content);
+          result = await store_.replace(target, old_text, content);
           break;
 
         case "remove":
@@ -105,7 +119,7 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
               details: {},
             };
           }
-          result = store.remove(target, old_text);
+          result = await store_.remove(target, old_text);
           break;
 
         default:
@@ -115,6 +129,11 @@ export function registerMemoryTool(pi: ExtensionAPI, store: MemoryStore): void {
           };
       }
 
+      // Tag project results so the caller knows the scope
+      if (rawTarget === "project" && result.success) {
+        (result as any).target = "project";
+      }
+
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         details: result,

package/src/types.ts

@@ -9,6 +9,8 @@ export interface MemoryConfig {
   memoryCharLimit: number;
   /** Max chars for USER.md (user profile). Default: 1375 */
   userCharLimit: number;
+  /** Max chars for project-level MEMORY.md. Default: 2200 */
+  projectCharLimit: number;
   /** Turns between background auto-reviews. Default: 10 */
   nudgeInterval: number;
   /** Enable background learning loop. Default: true */