pi-hermes-memory 0.6.5 → 0.6.7

package/README.md

@@ -363,6 +363,9 @@ Create `~/.pi/agent/hermes-memory-config.json`:
   "reviewEnabled": true,
   "autoConsolidate": true,
   "correctionDetection": true,
+  "failureInjectionEnabled": true,
+  "failureInjectionMaxAgeDays": 7,
+  "failureInjectionMaxEntries": 5,
   "flushOnCompact": true,
   "flushOnShutdown": true,
   "flushMinTurns": 6
@@ -380,6 +383,9 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 | `reviewEnabled` | `true` | Enable/disable background learning loop |
 | `autoConsolidate` | `true` | Auto-merge when memory hits capacity |
 | `correctionDetection` | `true` | Detect user corrections and save immediately |
+| `failureInjectionEnabled` | `true` | Enable/disable injecting recent failure memories into the system prompt |
+| `failureInjectionMaxAgeDays` | `7` | Maximum age in days for injected failure memories |
+| `failureInjectionMaxEntries` | `5` | Maximum number of failure memories to inject |
 | `flushOnCompact` | `true` | Flush memories before Pi compacts context |
 | `flushOnShutdown` | `true` | Flush memories when session ends |
 | `flushMinTurns` | `6` | Minimum turns before flush triggers |

package/docs/0.6/CHANGELOG.md

@@ -1,3 +1,28 @@
+# v0.6.6 Changelog
+
+## Bug Fixes
+
+### Fix legacy SQLite upgrade error: `no such column: category`
+
+Some users upgrading from older versions had an existing `sessions.db` with a legacy
+`memories` table that did not include v0.6 failure-memory columns. During schema init,
+creating `idx_memories_category` failed and `/memory-index-sessions` crashed with:
+
+`❌ Session indexing failed: no such column: category`
+
+Fix:
+
+- Added automatic legacy schema migration in `DatabaseManager`
+- Detects missing `memories` columns and adds them idempotently:
+  - `category`
+  - `failure_reason`
+  - `tool_state`
+  - `corrected_to`
+- Retries schema initialization after migration
+- Added regression test: `should migrate legacy memories table without category column`
+
+---
+
 # v0.6.5 Changelog
 
 ## Bug Fixes

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

@@ -0,0 +1,112 @@
+# 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "🧠 Persistent memory + 🔍 session search + 🛡️ secret scanning for Pi. SQLite FTS5 search across every conversation, auto-consolidation, memory aging, procedural skills. 272 tests. Ported from Hermes agent.",
   "type": "module",
   "main": "src/index.ts",

package/src/config.ts

@@ -9,6 +9,8 @@ import {
   DEFAULT_NUDGE_INTERVAL,
   DEFAULT_FLUSH_MIN_TURNS,
   DEFAULT_NUDGE_TOOL_CALLS,
+  DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
 } from "./constants.js";
 
 const DEFAULT_CONFIG: MemoryConfig = {
@@ -22,6 +24,9 @@ const DEFAULT_CONFIG: MemoryConfig = {
   flushMinTurns: DEFAULT_FLUSH_MIN_TURNS,
   autoConsolidate: true,
   correctionDetection: true,
+  failureInjectionEnabled: true,
+  failureInjectionMaxAgeDays: DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  failureInjectionMaxEntries: DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
   nudgeToolCalls: DEFAULT_NUDGE_TOOL_CALLS,
 };
 
@@ -48,6 +53,9 @@ export function loadConfig(): MemoryConfig {
       if (typeof parsed.flushMinTurns === "number") config.flushMinTurns = parsed.flushMinTurns;
       if (typeof parsed.autoConsolidate === "boolean") config.autoConsolidate = parsed.autoConsolidate;
       if (typeof parsed.correctionDetection === "boolean") config.correctionDetection = parsed.correctionDetection;
+      if (typeof parsed.failureInjectionEnabled === "boolean") config.failureInjectionEnabled = parsed.failureInjectionEnabled;
+      if (typeof parsed.failureInjectionMaxAgeDays === "number") config.failureInjectionMaxAgeDays = parsed.failureInjectionMaxAgeDays;
+      if (typeof parsed.failureInjectionMaxEntries === "number") config.failureInjectionMaxEntries = parsed.failureInjectionMaxEntries;
       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;

package/src/constants.ts

@@ -18,6 +18,8 @@ export const DEFAULT_NUDGE_INTERVAL = 10;
 export const DEFAULT_FLUSH_MIN_TURNS = 6;
 export const DEFAULT_NUDGE_TOOL_CALLS = 15;
 export const DEFAULT_SKILL_TRIGGER_TOOL_CALLS = 8;
+export const DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS = 7;
+export const DEFAULT_FAILURE_INJECTION_MAX_ENTRIES = 5;
 
 // ─── File names ───
 export const MEMORY_FILE = "MEMORY.md";

package/src/store/db.ts

@@ -38,11 +38,53 @@ export class DatabaseManager {
     db.pragma('foreign_keys = ON');
 
     // Create tables and triggers
-    db.exec(SCHEMA_SQL);
+    try {
+      db.exec(SCHEMA_SQL);
+    } catch (err) {
+      if (!this.isLegacyMemoriesCategoryError(err)) {
+        throw err;
+      }
+
+      // Legacy DB from pre-v0.6 can have memories table without the category
+      // and failure metadata columns. Add missing columns, then retry schema.
+      this.ensureMemoriesColumns(db);
+      db.exec(SCHEMA_SQL);
+    }
+
+    // Extra safety: always ensure the legacy memories columns exist, even when
+    // schema execution succeeds (idempotent on upgraded DBs).
+    this.ensureMemoriesColumns(db);
 
     return db;
   }
 
+  private isLegacyMemoriesCategoryError(err: unknown): boolean {
+    if (!(err instanceof Error)) return false;
+    const msg = err.message.toLowerCase();
+    return msg.includes('no such column: category') || msg.includes('memories(category)');
+  }
+
+  private ensureMemoriesColumns(db: Database.Database): void {
+    const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get() as { name: string } | undefined;
+    if (!tableExists) return;
+
+    const columns = db.prepare('PRAGMA table_info(memories)').all() as { name: string }[];
+    const names = new Set(columns.map((c) => c.name));
+
+    if (!names.has('category')) {
+      db.exec('ALTER TABLE memories ADD COLUMN category TEXT');
+    }
+    if (!names.has('failure_reason')) {
+      db.exec('ALTER TABLE memories ADD COLUMN failure_reason TEXT');
+    }
+    if (!names.has('tool_state')) {
+      db.exec('ALTER TABLE memories ADD COLUMN tool_state TEXT');
+    }
+    if (!names.has('corrected_to')) {
+      db.exec('ALTER TABLE memories ADD COLUMN corrected_to TEXT');
+    }
+  }
+
   /**
    * Close the database connection.
    */

package/src/store/memory-store.ts

@@ -19,6 +19,8 @@ import {
   ENTRY_DELIMITER,
   DEFAULT_MEMORY_CHAR_LIMIT,
   DEFAULT_USER_CHAR_LIMIT,
+  DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
   MEMORY_FILE,
   USER_FILE,
 } from "../constants.js";
@@ -280,12 +282,17 @@ export class MemoryStore {
     if (this.snapshot.user) parts.push(this.fenceBlock(this.snapshot.user));
 
     // Add recent failure memories
-    const recentFailures = this.getFailureEntries(7);
-    if (recentFailures.length > 0) {
-      const maxFailures = 5;
-      const failures = recentFailures.slice(0, maxFailures);
-      const failureBlock = this.renderFailureBlock(failures);
-      parts.push(this.fenceBlock(failureBlock));
+    if (this.config.failureInjectionEnabled !== false) {
+      const maxAgeDays = this.config.failureInjectionMaxAgeDays ?? DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS;
+      const maxFailures = this.config.failureInjectionMaxEntries ?? DEFAULT_FAILURE_INJECTION_MAX_ENTRIES;
+      const recentFailures = this.getFailureEntries(maxAgeDays);
+      if (recentFailures.length > 0) {
+        const failures = recentFailures.slice(0, maxFailures);
+        if (failures.length > 0) {
+          const failureBlock = this.renderFailureBlock(failures);
+          parts.push(this.fenceBlock(failureBlock));
+        }
+      }
     }
 
     return parts.join("\n\n");

package/src/types.ts

@@ -27,6 +27,12 @@ export interface MemoryConfig {
   autoConsolidate: boolean;
   /** Detect user corrections and trigger immediate memory save. Default: true */
   correctionDetection: boolean;
+  /** Inject recent failure memories into the system prompt. Default: true */
+  failureInjectionEnabled: boolean;
+  /** Maximum age in days for injected failure memories. Default: 7 */
+  failureInjectionMaxAgeDays: number;
+  /** Maximum number of failure memories to inject. Default: 5 */
+  failureInjectionMaxEntries: number;
   /** Tool calls before triggering background review (in addition to turn count). Default: 15 */
   nudgeToolCalls: number;
   /** Enable session history search via SQLite FTS5. Default: true */