pi-hermes-memory 0.6.9 → 0.7.2

package/src/handlers/sync-markdown-memories.ts

@@ -13,7 +13,7 @@ import {
 } from '../store/sqlite-memory-store.js';
 import { ENTRY_DELIMITER, MEMORY_FILE, USER_FILE } from '../constants.js';
 
-interface BackfillCounters {
+export interface BackfillCounters {
   filesScanned: number;
   entriesScanned: number;
   imported: number;
@@ -50,60 +50,92 @@ function importEntries(
   }
 }
 
-function scanProjectDirs(agentRoot: string, globalDir: string): Array<{ name: string; memoryFile: string }> {
-  if (!fs.existsSync(agentRoot)) return [];
+function scanProjectDirs(agentRoot: string, globalDir: string, projectsMemoryDir = "projects-memory"): Array<{ name: string; memoryFile: string }> {
+  const projectsRoot = path.join(agentRoot, projectsMemoryDir);
+  const projects = new Map<string, string>();
+
+  if (fs.existsSync(projectsRoot)) {
+    for (const name of fs.readdirSync(projectsRoot)) {
+      const dir = path.join(projectsRoot, name);
+      const memoryFile = path.join(dir, MEMORY_FILE);
+      if (fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(memoryFile)) {
+        projects.set(name, memoryFile);
+      }
+    }
+  }
+
   const globalDirName = path.basename(globalDir);
+  if (fs.existsSync(agentRoot)) {
+    for (const name of fs.readdirSync(agentRoot)) {
+      if (name === globalDirName || name === projectsMemoryDir || name === 'skills' || name.startsWith('.')) continue;
+      if (projects.has(name)) continue;
+      const dir = path.join(agentRoot, name);
+      const memoryFile = path.join(dir, MEMORY_FILE);
+      if (fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(memoryFile)) {
+        projects.set(name, memoryFile);
+      }
+    }
+  }
 
-  return fs.readdirSync(agentRoot)
-    .map((name) => ({ name, dir: path.join(agentRoot, name) }))
-    .filter(({ name, dir }) => name !== globalDirName && fs.existsSync(dir) && fs.statSync(dir).isDirectory())
-    .map(({ name, dir }) => ({ name, memoryFile: path.join(dir, MEMORY_FILE) }))
+  return [...projects.entries()]
+    .map(([name, memoryFile]) => ({ name, memoryFile }))
     .filter(({ memoryFile }) => fs.existsSync(memoryFile));
 }
 
+export function syncMarkdownMemoriesToSqlite(
+  dbManager: DatabaseManager,
+  globalDir: string,
+  projectsMemoryDir?: string,
+): BackfillCounters & { projectCount: number } {
+  const counters: BackfillCounters = {
+    filesScanned: 0,
+    entriesScanned: 0,
+    imported: 0,
+    skipped: 0,
+    warnings: [],
+  };
+
+  const globalMemoryFile = path.join(globalDir, MEMORY_FILE);
+  const globalUserFile = path.join(globalDir, USER_FILE);
+  const globalFailureFile = path.join(globalDir, 'failures.md');
+
+  const importFile = (
+    filePath: string,
+    target: 'memory' | 'user' | 'failure',
+    project: string | null = null,
+  ) => {
+    if (!fs.existsSync(filePath)) return;
+    counters.filesScanned++;
+    const entries = readEntries(filePath);
+    importEntries(dbManager, counters, entries, target, project);
+  };
+
+  importFile(globalMemoryFile, 'memory');
+  importFile(globalUserFile, 'user');
+  importFile(globalFailureFile, 'failure');
+
+  const agentRoot = path.dirname(globalDir);
+  const projects = scanProjectDirs(agentRoot, globalDir, projectsMemoryDir);
+  for (const project of projects) {
+    importFile(project.memoryFile, 'memory', project.name);
+  }
+
+  return { ...counters, projectCount: projects.length };
+}
+
 export function registerSyncMarkdownMemoriesCommand(
   pi: ExtensionAPI,
   dbManager: DatabaseManager,
   globalDir: string,
+  projectsMemoryDir?: string,
 ): void {
   pi.registerCommand('memory-sync-markdown', {
     description: 'Backfill Markdown memories into the SQLite search store',
     handler: async (_args, ctx: ExtensionCommandContext) => {
-      const counters: BackfillCounters = {
-        filesScanned: 0,
-        entriesScanned: 0,
-        imported: 0,
-        skipped: 0,
-        warnings: [],
-      };
-
       ctx.ui.notify('🔄 Scanning Markdown memory files for SQLite backfill...', 'info');
 
       try {
-        const globalMemoryFile = path.join(globalDir, MEMORY_FILE);
-        const globalUserFile = path.join(globalDir, USER_FILE);
-        const globalFailureFile = path.join(globalDir, 'failures.md');
-
-        const importFile = (
-          filePath: string,
-          target: 'memory' | 'user' | 'failure',
-          project: string | null = null,
-        ) => {
-          if (!fs.existsSync(filePath)) return;
-          counters.filesScanned++;
-          const entries = readEntries(filePath);
-          importEntries(dbManager, counters, entries, target, project);
-        };
-
-        importFile(globalMemoryFile, 'memory');
-        importFile(globalUserFile, 'user');
-        importFile(globalFailureFile, 'failure');
-
-        const agentRoot = path.dirname(globalDir);
-        const projects = scanProjectDirs(agentRoot, globalDir);
-        for (const project of projects) {
-          importFile(project.memoryFile, 'memory', project.name);
-        }
+        const counters = syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir);
 
         let output = `\n✅ Markdown → SQLite sync complete!\n\n`;
         output += `📊 Results:\n`;
@@ -112,8 +144,8 @@ export function registerSyncMarkdownMemoriesCommand(
         output += `├─ Imported into SQLite: ${counters.imported}\n`;
         output += `└─ Skipped as duplicates: ${counters.skipped}\n`;
 
-        if (projects.length > 0) {
-          output += `\n📁 Project memories scanned: ${projects.length}\n`;
+        if (counters.projectCount > 0) {
+          output += `\n📁 Project memories scanned: ${counters.projectCount}\n`;
         }
 
         if (counters.warnings.length > 0) {

package/src/index.ts

@@ -45,10 +45,12 @@ import { registerInterviewCommand } from "./handlers/interview.js";
 import { registerSwitchProjectCommand } from "./handlers/switch-project.js";
 import { registerIndexSessionsCommand } from "./handlers/index-sessions.js";
 import { registerLearnMemoryCommand } from "./handlers/learn-memory.js";
-import { registerSyncMarkdownMemoriesCommand } from "./handlers/sync-markdown-memories.js";
+import { registerSyncMarkdownMemoriesCommand, syncMarkdownMemoriesToSqlite } from "./handlers/sync-markdown-memories.js";
 import { registerPreviewContextCommand } from "./handlers/preview-context.js";
 import { loadConfig } from "./config.js";
 import { detectProject } from "./project.js";
+import { buildPromptContext } from "./prompt-context.js";
+import { migrateLegacyProjectMemoryDirs } from "./project-memory-migration.js";
 
 export default function (pi: ExtensionAPI) {
   const config = loadConfig();
@@ -58,10 +60,20 @@ export default function (pi: ExtensionAPI) {
   const skillStore = new SkillStore(path.join(globalDir, "skills"));
   const dbManager = new DatabaseManager(globalDir);
 
+  // Keep project memory available for users upgrading from the old
+  // ~/.pi/agent/<project>/ layout. This is non-destructive: legacy folders
+  // remain in place while entries are copied/merged into projects-memory/.
+  migrateLegacyProjectMemoryDirs(globalDir, config.projectsMemoryDir);
+  try {
+    syncMarkdownMemoriesToSqlite(dbManager, globalDir, config.projectsMemoryDir);
+  } catch {
+    // Best-effort only: failed SQLite backfill should not block extension startup.
+  }
+
   // Detect project from cwd using shared helper
-  const project = detectProject();
+  const project = detectProject(config.projectsMemoryDir);
 
-  // Project-scoped store: ~/.pi/agent/<project_name>/
+  // Project-scoped store: ~/.pi/agent/<projectsMemoryDir>/<project_name>/
   const projectConfig = project.memoryDir
     ? { ...config, memoryCharLimit: config.projectCharLimit, memoryDir: project.memoryDir }
     : { ...config, memoryDir: undefined };
@@ -74,20 +86,13 @@ export default function (pi: ExtensionAPI) {
     if (projectStore) await projectStore.loadFromDisk();
   });
 
-  // ── 2. Inject frozen snapshot + skill index + project memory into system prompt ──
+  // ── 2. Inject memory policy by default; legacy mode keeps full frozen memory blocks ──
   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);
+    const promptContext = await buildPromptContext(config, store, projectStore, skillStore, projectName);
 
-    if (parts.length > 0) {
+    if (promptContext) {
       return {
-        systemPrompt: event.systemPrompt + "\n\n" + parts.join("\n\n"),
+        systemPrompt: event.systemPrompt + "\n\n" + promptContext,
       };
     }
   });
@@ -111,7 +116,7 @@ export default function (pi: ExtensionAPI) {
   registerConsolidateCommand(pi, store);
 
   // ── 8. Setup correction detection ──
-  setupCorrectionDetector(pi, store, projectStore, config, dbManager);
+  setupCorrectionDetector(pi, store, projectStore, config, dbManager, projectName);
 
   // ── 9. Setup skill auto-trigger ──
   setupSkillAutoTrigger(pi, store, skillStore, config);
@@ -120,10 +125,10 @@ export default function (pi: ExtensionAPI) {
   registerInsightsCommand(pi, store, projectStore, projectName);
   registerSkillsCommand(pi, skillStore);
   registerInterviewCommand(pi, store);
-  registerSwitchProjectCommand(pi);
+  registerSwitchProjectCommand(pi, config);
   registerLearnMemoryCommand(pi);
-  registerSyncMarkdownMemoriesCommand(pi, dbManager, globalDir);
-  registerPreviewContextCommand(pi, store, projectStore, skillStore, projectName);
+  registerSyncMarkdownMemoriesCommand(pi, dbManager, globalDir, config.projectsMemoryDir);
+  registerPreviewContextCommand(pi, store, projectStore, skillStore, projectName, config.memoryMode);
 
   // ── 11. SQLite session search + extended memory ──
   registerSessionSearchTool(pi, dbManager);

package/src/project-memory-migration.ts

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ENTRY_DELIMITER, MEMORY_FILE } from "./constants.js";
+
+export interface ProjectMemoryMigrationResult {
+  scanned: number;
+  copied: number;
+  merged: number;
+  skipped: number;
+  warnings: string[];
+}
+
+function readEntries(filePath: string): string[] {
+  if (!fs.existsSync(filePath)) return [];
+  const raw = fs.readFileSync(filePath, "utf-8").trim();
+  if (!raw) return [];
+  return raw.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+}
+
+function writeEntries(filePath: string, entries: string[]): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, entries.join(ENTRY_DELIMITER), "utf-8");
+}
+
+function isLegacyProjectDir(agentRoot: string, projectsMemoryDir: string, name: string): boolean {
+  if (name === "memory" || name === "skills" || name === projectsMemoryDir) return false;
+  if (name.startsWith(".")) return false;
+
+  const dir = path.join(agentRoot, name);
+  return fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(path.join(dir, MEMORY_FILE));
+}
+
+export function migrateLegacyProjectMemoryDirs(
+  globalDir: string,
+  projectsMemoryDir = "projects-memory",
+): ProjectMemoryMigrationResult {
+  const result: ProjectMemoryMigrationResult = {
+    scanned: 0,
+    copied: 0,
+    merged: 0,
+    skipped: 0,
+    warnings: [],
+  };
+
+  const agentRoot = path.dirname(globalDir);
+  if (!fs.existsSync(agentRoot)) return result;
+
+  const projectsRoot = path.join(agentRoot, projectsMemoryDir);
+
+  for (const name of fs.readdirSync(agentRoot)) {
+    if (!isLegacyProjectDir(agentRoot, projectsMemoryDir, name)) continue;
+    result.scanned++;
+
+    const legacyFile = path.join(agentRoot, name, MEMORY_FILE);
+    const targetFile = path.join(projectsRoot, name, MEMORY_FILE);
+
+    try {
+      const legacyEntries = readEntries(legacyFile);
+      if (legacyEntries.length === 0) {
+        result.skipped++;
+        continue;
+      }
+
+      if (!fs.existsSync(targetFile)) {
+        writeEntries(targetFile, legacyEntries);
+        result.copied++;
+        continue;
+      }
+
+      const targetEntries = readEntries(targetFile);
+      const mergedEntries = [...targetEntries];
+      const seen = new Set(targetEntries);
+
+      for (const entry of legacyEntries) {
+        if (!seen.has(entry)) {
+          seen.add(entry);
+          mergedEntries.push(entry);
+        }
+      }
+
+      if (mergedEntries.length === targetEntries.length) {
+        result.skipped++;
+        continue;
+      }
+
+      writeEntries(targetFile, mergedEntries);
+      result.merged++;
+    } catch (err) {
+      result.warnings.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return result;
+}

package/src/project.ts

@@ -18,9 +18,9 @@ export interface ProjectInfo {
  *
  * A "project" is any directory that is not the user's home directory.
  * The project name is the directory's basename.
- * Project-scoped memory is stored at ~/.pi/agent/<projectName>/.
+ * Project-scoped memory is stored at ~/.pi/agent/<projectsMemoryDir>/<projectName>/.
  */
-export function detectProject(cwd?: string): ProjectInfo {
+export function detectProject(projectsMemoryDir = "projects-memory", cwd?: string): ProjectInfo {
   const dir = cwd ?? process.cwd();
   const homeDir = os.homedir();
 
@@ -39,6 +39,6 @@ export function detectProject(cwd?: string): ProjectInfo {
 
   return {
     name,
-    memoryDir: path.join(homeDir, ".pi", "agent", name),
+    memoryDir: path.join(homeDir, ".pi", "agent", projectsMemoryDir, name),
   };
 }

package/src/prompt-context.ts

@@ -0,0 +1,27 @@
+import { MEMORY_POLICY_PROMPT } from "./constants.js";
+import type { MemoryConfig } from "./types.js";
+import type { MemoryStore } from "./store/memory-store.js";
+import type { SkillStore } from "./store/skill-store.js";
+
+export async function buildPromptContext(
+  config: Pick<MemoryConfig, "memoryMode">,
+  store: MemoryStore,
+  projectStore: MemoryStore | null,
+  skillStore: SkillStore,
+  projectName: string,
+): Promise<string> {
+  if (config.memoryMode === "policy-only") {
+    return MEMORY_POLICY_PROMPT;
+  }
+
+  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);
+
+  return parts.join("\n\n");
+}

package/src/store/content-scanner.ts

@@ -71,7 +71,7 @@ export function scanContent(content: string): string | null {
   // Check threat patterns
   for (const { pattern, id } of MEMORY_THREAT_PATTERNS) {
     if (pattern.test(content)) {
-      return `Blocked: content matches threat pattern '${id}'. Memory entries are injected into the system prompt and must not contain injection or exfiltration payloads.`;
+      return `Blocked: content matches threat pattern '${id}'. Memory entries may be surfaced through search or legacy prompt injection and must not contain injection or exfiltration payloads.`;
     }
   }
 

package/src/store/memory-store.ts

@@ -424,13 +424,19 @@ export class MemoryStore {
     }
   }
 
-  /** Atomic write: temp file + fs.rename() — same crash-safety as Hermes. */
+  /**
+   * Atomic write: temp file + fs.rename().
+   * Creates temp files in the same directory as the target to avoid
+   * cross-device rename errors (EXDEV) when os.tmpdir() is on a different
+   * drive than the memory directory (common on Windows).
+   */
   private async saveToDisk(target: "memory" | "user" | "failure"): Promise<void> {
     const filePath = this.pathFor(target);
     const entries = this.entriesFor(target);
     const content = entries.length ? entries.join(ENTRY_DELIMITER) : "";
 
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pi-memory-"));
+    // Use the memory directory for temp files so rename stays on the same device
+    const tmpDir = await fs.mkdtemp(path.join(this.memoryDir, ".tmp-"));
     const tmpPath = path.join(tmpDir, "write.tmp");
 
     try {
@@ -440,7 +446,7 @@ export class MemoryStore {
       try { await fs.unlink(tmpPath); } catch { /* ignore */ }
       throw err;
     } finally {
-      try { await fs.rmdir(tmpDir); } catch { /* ignore */ }
+      try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
 }

package/src/store/skill-store.ts

@@ -283,10 +283,14 @@ export class SkillStore {
 
   // ─── Internal helpers ───
 
-  /** Atomic write: temp file + rename (same crash-safety as MemoryStore) */
+  /**
+   * Atomic write: temp file + rename.
+   * Creates temp files in the skills directory to avoid cross-device
+   * rename errors (EXDEV) on Windows when os.tmpdir() is on a different drive.
+   */
   private async atomicWrite(fileName: string, content: string): Promise<void> {
     const filePath = path.join(this.skillsDir, fileName);
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pi-skill-"));
+    const tmpDir = await fs.mkdtemp(path.join(this.skillsDir, ".tmp-"));
     const tmpPath = path.join(tmpDir, "write.tmp");
 
     try {
@@ -296,7 +300,7 @@ export class SkillStore {
       try { await fs.unlink(tmpPath); } catch { /* ignore */ }
       throw err;
     } finally {
-      try { await fs.rmdir(tmpDir); } catch { /* ignore */ }
+      try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
 }

package/src/tools/memory-tool.ts

@@ -179,8 +179,8 @@ export function registerMemoryTool(
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       const { action, target: rawTarget, content, old_text, category, failure_reason } = params;
 
-      // Route 'project' to projectStore (internal target 'memory')
-      const target = rawTarget as "memory" | "user" | "failure";
+      // Route 'project' to projectStore using the normal MEMORY.md target.
+      const target = rawTarget === "project" ? "memory" : rawTarget as "memory" | "user" | "failure";
       const activeStore = rawTarget === "project" ? projectStore : store;
 
       if (rawTarget === "project" && !projectStore) {

package/src/types.ts

@@ -5,6 +5,8 @@
 import type { TextContent } from "@mariozechner/pi-ai";
 
 export interface MemoryConfig {
+  /** Prompt memory mode. Default: policy-only */
+  memoryMode: "policy-only" | "legacy-inject";
   /** Max chars for MEMORY.md (agent notes). Default: 5000 */
   memoryCharLimit: number;
   /** Max chars for USER.md (user profile). Default: 5000 */
@@ -13,6 +15,8 @@ export interface MemoryConfig {
   projectCharLimit: number;
   /** Turns between background auto-reviews. Default: 10 */
   nudgeInterval: number;
+  /** Recent conversation messages included in background review. 0 = all. Default: 0 */
+  reviewRecentMessages?: number;
   /** Enable background learning loop. Default: true */
   reviewEnabled: boolean;
   /** Flush memories before compaction. Default: true */
@@ -21,8 +25,12 @@ export interface MemoryConfig {
   flushOnShutdown: boolean;
   /** Minimum user turns before flush triggers. Default: 6 */
   flushMinTurns: number;
+  /** Recent conversation messages included in session flush. 0 = all. Default: 0 */
+  flushRecentMessages?: number;
   /** Override memory directory. Default: ~/.pi/agent/memory */
   memoryDir?: string;
+  /** Directory for project-scoped memory (relative to ~/.pi/agent). Default: "projects-memory" */
+  projectsMemoryDir?: string;
   /** Auto-consolidate when memory is full instead of returning error. Default: true */
   autoConsolidate: boolean;
   /** Detect user corrections and trigger immediate memory save. Default: true */

package/docs/0.7/TAGGED-SESSION-SKILL-REVIEW.md

@@ -1,112 +0,0 @@
-# v0.7 Proposal: Tagged Session Review → Skill Creation
-
-## Why
-
-Community feedback highlighted a real gap:
-- quick correction capture is useful,
-- but **durable behavior should be promoted to skills intentionally**,
-- and that flow should be reviewable in the TUI.
-
-## Goal
-
-Add a deterministic review workflow:
-1. collect candidate learnings from session messages,
-2. review them in a TUI modal,
-3. promote selected items into a draft skill,
-4. save via existing `skill` tool.
-
-## Non-goals
-
-- Auto-creating skills without user review.
-- Replacing core memory entirely.
-- Requiring git history for extraction.
-
-## UX (Target)
-
-### Command
-- `/memory-review-candidates`
-
-### Modal flow
-1. **Candidate list** (tag, source session, snippet, confidence)
-2. Actions per candidate: `approve`, `reject`, `edit`, `merge with...`
-3. Multi-select candidates and choose `Create skill draft`
-4. Draft editor with sections:
-   - `## When to Use`
-   - `## Procedure`
-   - `## Pitfalls`
-   - `## Verification`
-5. Save with `skill.create`
-
-## Candidate Sources
-
-Priority order:
-1. Explicit message tags from Pi sessions (when available)
-2. Heuristic extraction from conversation patterns:
-   - repeated corrections,
-   - multi-step successful runs,
-   - repeated tool sequences,
-   - resolved failures with clear fix.
-
-## Data Model (SQLite)
-
-New table (proposal): `memory_candidates`
-
-Columns:
-- `id` INTEGER PK
-- `session_id` TEXT
-- `message_id` TEXT
-- `project` TEXT
-- `tag` TEXT
-- `snippet` TEXT
-- `rationale` TEXT
-- `status` TEXT CHECK (`pending`,`approved`,`rejected`,`promoted`)
-- `created_at` TEXT
-- `updated_at` TEXT
-- `promoted_skill` TEXT NULL
-
-## Integration with Existing System
-
-- Keep current memory + failure capture.
-- Add a **promotion path** from memory/candidates to skills.
-- Use existing `skill` tool as persistence layer.
-- Use existing `session_search`/indexing infra for candidate discovery context.
-
-## Rollout Plan
-
-### Phase 1: Candidate staging (no modal)
-- Create `memory_candidates` table
-- Add extraction + `/memory-candidates` list command
-- Add approve/reject commands
-
-### Phase 2: TUI review modal
-- Interactive candidate triage in one place
-- Batch select + merge + edit
-
-### Phase 3: Skill draft + save
-- Generate skill draft from approved candidates
-- Edit + save with `skill.create`
-
-### Phase 4: Quality controls
-- duplicate candidate suppression
-- confidence thresholds
-- weekly reminder: pending candidates review
-
-## Success Criteria
-
-- Lower noisy memory growth in `MEMORY.md`
-- Higher percentage of reusable knowledge landing in `skills/`
-- Fewer repeated correction loops across sessions
-- Users report that learning feels intentional, not "whack-a-mole"
-
-## Open Questions
-
-1. Should candidates be extracted turn-by-turn or session-end only?
-2. Should approved candidates auto-expire if not promoted in N days?
-3. Should skill drafts include linked source message IDs for traceability?
-4. Should project scope be default-on with optional cross-project merge mode?
-
-## Notes
-
-This proposal complements (not replaces) core memory.
-Memory remains fast capture; skills remain durable procedure.
-The new modal creates the missing bridge between them.