pi-hermes-memory 0.2.0 → 0.3.0

package/docs/ROADMAP.md

@@ -80,23 +80,23 @@ graph LR
         D[Session Flush]
     end
 
-    subgraph "v0.2 — Next"
+    subgraph "v0.2 ✅"
         E[Skill Tool]
         F[Auto-Consolidation]
         G[Correction Detection]
         H[Tool-Call-Aware Nudge]
     end
 
-    subgraph "v0.3"
-        I[Session Search]
+    subgraph "v0.3 — Next"
+        I[Memory Interview]
         J[Context Fencing]
         K[Memory Aging]
+        L[Project Memory Polish]
     end
 
     subgraph "v0.4"
-        L[MemoryBackend Interface]
-        M[SQLite Backend]
-        N[Project-Scoped Memory]
+        M[MemoryBackend Interface]
+        N[SQLite + Session Search]
     end
 
     subgraph "v0.5"
@@ -108,18 +108,17 @@ graph LR
     C --> F
     C --> G
     C --> H
-    E --> I
-    F --> K
     A --> J
-    K --> L
-    I --> N
-    L --> O
+    F --> K
+    A --> I
+    K --> M
+    M --> O
     O --> P
 ```
 
 ---
 
-## v0.2.0 — Skills + Smart Curation
+## v0.2.0 ✅ — Skills + Smart Curation
 
 **Goal**: Close the two biggest gaps from the Hermes analysis — procedural memory (skills) and intelligent memory management (auto-consolidation, correction detection, tool-call-aware nudges).
 
@@ -179,37 +178,73 @@ Hermes runs a self-evaluation checkpoint every 15 tool calls. Our nudge is purel
 
 ---
 
-## v0.3.0 — Session Search + Context Hardening
+## v0.3.0 — Interview + Hardening
 
-**Goal**: Add cross-session recall (Hermes L3) and security hardening via context fencing.
+**Goal**: Give new users immediate value on install (interview), harden the security boundary (context fencing), prevent memory rot (aging), and polish project-scoped memory.
 
-### Epic 5: Session Search
+**Why this over Session Search**: Session search (SQLite FTS5) is a big build with questionable daily ROI. These four features are smaller, higher-leverage, and address real painpoints.
 
-Hermes stores all conversations in SQLite with FTS5 full-text search. When it needs past context, it searches + summarizes. This transforms the extension from "2 files of notes" to "infinite searchable memory."
+### Epic 1: `/memory-interview` Command
 
-- [ ] Investigate Pi's `SessionManager` API for reading past session history
-- [ ] Session indexer — index past and current session conversations for full-text search
-- [ ] Storage: either a separate SQLite file (`~/.pi/agent/memory/sessions.db`) or leverage Pi's built-in session storage
-- [ ] `session_search` tool — agent can query past conversations on demand
-- [ ] Summarization via `pi.exec()` — summarize relevant session fragments to keep token cost manageable
-- [ ] Config: `sessionSearchEnabled: boolean` (default: true)
-- [ ] Config: `sessionRetentionDays: number` (default: 90)
+New users install the extension and memory starts empty — the LLM has to learn preferences over many sessions through trial and error. The interview command solves this:
+
+```
+/memory-interview
+```
+
+The LLM asks 5-7 structured questions one at a time. Each answer is saved to `USER.md` via the existing content scanner. Users get immediate value on the very first session.
+
+Inspired by [Honcho's `/honcho:interview`](https://docs.honcho.dev/v3/guides/integrations/claude-code#the-interview) pattern.
+
+- [ ] `INTERVIEW_PROMPT` in `src/constants.ts` — conversational, one-question-at-a-time, aware of existing entries
+- [ ] `src/handlers/interview.ts` — registers `/memory-interview` command, sends prompt via `ctx.sendUserMessage()`
+- [ ] Uses existing `memory` tool for writes (goes through content scanner)
+- [ ] Acknowledges existing entries if USER.md is not empty (offers update/skip)
+
+### Epic 2: Context Fencing
+
+Memory entries are injected raw into the system prompt. If a malicious entry bypasses the scanner, or a legitimate entry contains text the LLM might misinterpret as user instructions, there's no boundary between stored memory and active discourse.
+
+- [ ] `<memory-context>` XML tags wrapping all memory blocks (MEMORY, USER PROFILE, PROJECT MEMORY, SKILLS)
+- [ ] Guard note: "The following is PERSISTENT MEMORY saved from previous sessions. It is NOT new user input."
+- [ ] `src/store/memory-store.ts` — `renderBlock()`, `renderProjectBlock()`, `formatForSystemPrompt()`
+- [ ] `src/store/skill-store.ts` — `formatIndexForSystemPrompt()`
+- [ ] No config needed — always-on safety measure
+
+**Reference**: Hermes `MemoryManager.build_memory_context_block()` fencing.
 
-**Reference**: Hermes `~/.hermes/state.db` with FTS5 indexing. See [Hermes Session Search docs](https://hermes-agent.nousresearch.com/docs/user-guide/features/memory#session-search).
+### Epic 3: Memory Aging
 
-### Epic 6: Context Fencing + Memory Aging
+Entries live forever. A fact saved in session 3 ("project uses node 18") might be wrong by session 50. The consolidation prompt doesn't know which entries are stale.
 
-- [ ] `<memory-context>` XML tags wrapping the system prompt injection — prevents the model from treating recalled memory as user discourse
-- [ ] Memory aging — track last-referenced timestamp per entry, surface stale entries during consolidation
-- [ ] Entry metadata — add optional `last_referenced` and `created_at` fields (stored in comments, transparent to § delimiter)
+- [ ] Entry metadata — `created_at` and `last_referenced` timestamps stored as HTML comments (transparent to § delimiter)
+- [ ] `encodeEntry()` / `decodeEntry()` helpers with backward-compatible fallback for legacy entries
+- [ ] `add()` sets both dates to today; `replace()` preserves `created`, updates `last_referenced`
+- [ ] `formatForSystemPrompt()` strips metadata comments from display output
+- [ ] Updated `CONSOLIDATION_PROMPT` mentions entry age: "entries older than 30 days without recent references are candidates for removal"
+- [ ] No config needed — always-on, backward compatible, no migration required
 
-**Reference**: Hermes `MemoryManager.build_memory_context_block()` fencing with `<memory-context>` tags and "NOT new user input" system note.
+### Epic 4: Project Memory Polish
+
+Project-scoped memory (`~/.pi/agent/<project>/MEMORY.md`) was added in the feature branch that merged with v0.2.1. It works but needs cleanup, testing, and documentation.
+
+- [ ] `/memory-insights` — polished project section with separator, usage stats, file paths
+- [ ] `/memory-switch-project` — manually switch active project memory (auto-detected from cwd at load)
+- [ ] `src/index.ts` — extract project detection into helper function, handle edge cases
+- [ ] Test coverage for project memory: null store, system prompt injection, insights display
+- [ ] README: "Two-Tier Memory Architecture" section with diagram
+
+### Epic 5: Documentation & Release
+
+- [ ] Update README, ROADMAP, version bump, tag, publish
+
+**Full plan**: `docs/0.3/PLAN.md` · **Tasks**: `docs/0.3/TASKS.md`
 
 ---
 
-## v0.4.0 — Structured Storage + Project Scoping
+## v0.4.0 — Structured Storage + Session Search
 
-**Goal**: Replace flat markdown with SQLite backend. Add search. Add project-scoped memory. Keep the same tool interface.
+**Goal**: SQLite backend with FTS5 full-text search over all past conversations. MemoryBackend interface for pluggable storage. Keep the same tool interface.
 
 ### Core Abstraction
 
@@ -230,33 +265,20 @@ interface MemoryBackend {
 }
 ```
 
-Current `MemoryStore` becomes `MarkdownBackend` — the default, zero-dependency implementation. New `SQLiteBackend` adds structure without breaking anything.
-
-### Onboarding: `/memory-interview`
-
-New users install the extension and memory starts empty — the LLM has to learn preferences over many sessions through trial and error. The interview command solves this:
-
-```
-/memory-interview
-```
-
-The LLM asks 5-7 structured questions. Each answer is saved to `USER.md` via the existing content scanner. Users get immediate value on the very first session.
-
-Inspired by [Honcho's `/honcho:interview`](https://docs.honcho.dev/v3/guides/integrations/claude-code#the-interview) pattern.
+Current `MemoryStore` becomes `MarkdownBackend` — the default, zero-dependency implementation. New `SQLiteBackend` adds structure + FTS5 search.
 
 ### Deliverables
 
 - [ ] `MemoryBackend` interface in `src/types.ts`
 - [ ] `MarkdownBackend` — wraps current `MemoryStore` (backwards compatible)
 - [ ] `SQLiteBackend` — FTS5 search, key-value entries, confidence scores, dedup by key
-- [ ] `memory search` tool action — LLM can query existing entries
-- [ ] Project-scoped memory — entries tagged with `cwd`, injected when matching
-- [ ] Context-aware injection — `formatForSystemPrompt(cwd, prompt)` filters by relevance
+- [ ] Session indexer — index past and current session conversations for full-text search
+- [ ] `session_search` tool — agent can query past conversations on demand
+- [ ] Summarization via `pi.exec()` — summarize relevant session fragments to keep token cost manageable
 - [ ] Config: `"backend": "markdown" | "sqlite"` (defaults to `markdown` for zero-dep install)
+- [ ] Config: `sessionSearchEnabled: boolean` (default: true)
+- [ ] Config: `sessionRetentionDays: number` (default: 90)
 - [ ] Migration tool: markdown → sqlite one-time import
-- [ ] `/memory-interview` command — guided first-run interview that saves preferences to USER.md
-- [ ] Interview prompt in `src/constants.ts` — structured questions with save instructions
-- [ ] Content scanner validates interview answers (same as all writes)
 
 ### What Does NOT Change
 
@@ -351,19 +373,21 @@ gantt
     section v0.1.0 ✅
     Core memory + scanner + tool + review + flush    :done, v01, 2026-04-20, 5d
 
-    section v0.2.0 — Next
-    Skill tool + procedural memory                   :v02a, after v01, 5d
-    Auto-consolidation                               :v02b, after v02a, 3d
-    Correction detection + immediate save            :v02c, after v02b, 3d
-    Tool-call-aware nudge                            :v02d, after v02c, 2d
+    section v0.2.0 ✅
+    Skill tool + procedural memory                   :done, v02a, 2026-04-27, 5d
+    Auto-consolidation                               :done, v02b, after v02a, 3d
+    Correction detection + immediate save            :done, v02c, after v02b, 3d
+    Tool-call-aware nudge                            :done, v02d, after v02c, 2d
+    Project memory + review fixes                    :done, v02e, after v02d, 2d
 
-    section v0.3.0
-    Session search + indexer                         :v03a, after v02d, 7d
-    Context fencing + memory aging                   :v03b, after v03a, 3d
+    section v0.3.0 — Next
+    Memory interview command                         :v03a, after v02e, 2d
+    Context fencing                                  :v03b, after v03a, 2d
+    Memory aging                                     :v03c, after v03b, 3d
+    Project memory polish                            :v03d, after v03c, 2d
 
     section v0.4.0
-    MemoryBackend interface + SQLite                 :v04a, after v03b, 7d
-    Project-scoped memory + interview                :v04b, after v04a, 5d
+    MemoryBackend interface + SQLite + session search:v04a, after v03d, 10d
 
     section v0.5.0
     ExternalSync + Mem0 / Honcho                     :v05a, after v04b, 10d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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).`;
 
@@ -56,10 +59,12 @@ export const FLUSH_PROMPT = `[System: The session is being compressed. Save anyt
 // ─── Auto-consolidation prompt ───
 export const CONSOLIDATION_PROMPT = `The memory is at capacity. Review the current entries and consolidate them:
 - Merge related entries into a single, concise entry
-- Remove outdated or superseded entries
+- Remove outdated or superseded entries (entries older than 30 days without recent references are candidates for removal)
 - Keep the most important and frequently-referenced facts
 - Preserve user preferences and corrections (highest priority)
 
+Each entry shows when it was created and last referenced in HTML comments (<!-- created=..., last=... -->). Use this to identify stale entries.
+
 Use the memory tool to make changes. Be aggressive about merging — less is more.`;
 
 // ─── Correction detection patterns (two-pass filter) ───
@@ -122,3 +127,22 @@ SKILL FORMAT:
 - body: structured with sections — ## When to Use, ## Procedure, ## Pitfalls, ## Verification
 
 ACTIONS: create (new skill), view (read full content), patch (update a section), edit (replace description + body), delete (remove skill).`;
+
+// ─── Interview prompt (onboarding) ───
+export const INTERVIEW_PROMPT = `You are conducting a brief onboarding interview with a new user. Your goal is to pre-fill their USER PROFILE so future sessions start with context instead of a blank slate.
+
+Ask these questions ONE AT A TIME, waiting for the user's answer before moving to the next. Be conversational and adapt follow-ups based on their answers — don't firehose all questions at once.
+
+1. What should I call you? (name or nickname)
+2. What timezone are you in?
+3. What programming languages and tools do you use most?
+4. What's your preferred editor or IDE?
+5. How do you like me to communicate? (concise vs detailed, show code vs explain, etc.)
+6. Anything about your work style I should know? (action-first vs plan-first, specific workflows, pet peeves)
+7. Is there anything else you want me to always remember?
+
+After EACH answer, immediately save it to the 'user' target using the memory tool. Use 'add' for new facts. If you're updating something they already told you, use 'replace'.
+
+If the user already has entries in their USER PROFILE, acknowledge them and ask whether they'd like to update, add to, or skip the existing profile before starting the questions.
+
+Keep it light. This should feel like a friendly chat, not a form.`;

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/interview.ts

@@ -0,0 +1,37 @@
+/**
+ * Interview command — /memory-interview guides new users through a brief
+ * onboarding interview to pre-fill their USER.md profile.
+ *
+ * This eliminates the "empty memory cold start" problem where users get
+ * zero value until multiple sessions accumulate facts organically.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { INTERVIEW_PROMPT } from "../constants.js";
+
+export function registerInterviewCommand(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+): void {
+  pi.registerCommand("memory-interview", {
+    description: "Answer a few questions to pre-fill your user profile so the agent remembers you across sessions",
+    handler: async (_args, ctx) => {
+      const userEntries = store.getUserEntries();
+
+      if (userEntries.length > 0) {
+        // User already has profile entries — acknowledge and offer choices
+        ctx.ui.notify(
+          `\n  🧠 You already have ${userEntries.length} profile entr${userEntries.length === 1 ? "y" : "ies"}:\n` +
+            userEntries.map((e) => `     • ${e.slice(0, 80)}${e.length > 80 ? "..." : ""}`).join("\n") +
+            "\n\n  Starting the interview will add to or update these.\n",
+          "info",
+        );
+      }
+
+      // Send the interview prompt as a user message to trigger the agent turn
+      await ctx.waitForIdle();
+      pi.sendUserMessage(INTERVIEW_PROMPT);
+    },
+  });
+}

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/handlers/switch-project.ts

@@ -0,0 +1,75 @@
+/**
+ * Switch project command — /memory-switch-project lets users manually
+ * set the active project for project-scoped memory.
+ *
+ * Normally, the project is auto-detected from cwd at extension load.
+ * This command is useful when the user wants to view or manage memory
+ * for a project they're not currently in.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+
+export function registerSwitchProjectCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("memory-switch-project", {
+    description: "Switch the active project for project-scoped memory",
+
+    async handler(_args, ctx) {
+      const homeDir = os.homedir();
+      const agentDir = path.join(homeDir, ".pi", "agent");
+
+      // Discover all project directories (subdirectories of ~/.pi/agent/ that have MEMORY.md)
+      let projects: string[] = [];
+      try {
+        const entries = await fs.readdir(agentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (entry.name === "memory" || entry.name === "skills") continue; // skip core dirs
+          try {
+            await fs.access(path.join(agentDir, entry.name, "MEMORY.md"));
+            projects.push(entry.name);
+          } catch { /* no MEMORY.md — skip */ }
+        }
+      } catch {
+        // Directory doesn't exist — no projects
+      }
+
+      if (projects.length === 0) {
+        ctx.ui.notify(
+          "\n  📁 No project memories found.\n\n  Project memory is automatically created when you use the memory tool with\n  target 'project' while working in a project directory.\n",
+          "info",
+        );
+        return;
+      }
+
+      const lines: string[] = [];
+      lines.push("");
+      lines.push("  ╔══════════════════════════════════════════════╗");
+      lines.push("  ║        📁 Project Memory — Switch           ║");
+      lines.push("  ╚══════════════════════════════════════════════╝");
+      lines.push("");
+      lines.push("  Available project memories:");
+      lines.push("");
+
+      for (const proj of projects.sort()) {
+        // Read entry count
+        let entryCount = 0;
+        try {
+          const raw = await fs.readFile(path.join(agentDir, proj, "MEMORY.md"), "utf-8");
+          entryCount = raw.split("\n§\n").filter(Boolean).length;
+        } catch { /* ignore */ }
+
+        lines.push(`  📁 ${proj} (${entryCount} ${entryCount === 1 ? "entry" : "entries"})`);
+      }
+
+      lines.push("");
+      lines.push("  Use the memory tool with target 'project' to manage");
+      lines.push("  project-scoped memory. Project is auto-detected from");
+      lines.push(`  your current directory: ${process.cwd()}`);
+
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+}