pi-hermes-memory 0.7.13 → 0.7.14

package/README.md

@@ -424,6 +424,8 @@ Create `~/.pi/agent/hermes-memory-config.json`:
   "memoryDir": "~/.pi/agent/pi-hermes-memory",
   "projectsMemoryDir": "projects-memory",
   "sessionSearch": { "variant": "legacy" },
+  "llmModelOverride": "openrouter/deepseek/deepseek-v4-flash",
+  "llmThinkingOverride": "off",
   "nudgeInterval": 10,
   "nudgeToolCalls": 15,
   "reviewRecentMessages": 0,
@@ -453,6 +455,8 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 | `memoryDir` | `~/.pi/agent/pi-hermes-memory` | Custom directory for extension storage files |
 | `projectsMemoryDir` | `projects-memory` | Subdirectory under `~/.pi/agent/` for project-scoped memory |
 | `sessionSearch` | `{ "variant": "legacy" }` | Session search implementation: `legacy` keeps the existing SQLite/FTS snippet search; `anchors` uses the opt-in Markdown request surface and returns compact JSONL line-range anchors from `~/.pi/agent/sessions/` |
+| `llmModelOverride` | unset | Optional model override for child `pi -p` subprocess calls used by background review, correction save, session flush, and consolidation |
+| `llmThinkingOverride` | unset | Optional thinking override for those child subprocess calls; valid values are `off`, `minimal`, `low`, `medium`, `high`, and `xhigh`. If `llmModelOverride` is set and this is omitted, child calls default to `off` |
 | `nudgeInterval` | `10` | Turns between auto-reviews |
 | `nudgeToolCalls` | `15` | Tool calls between auto-reviews (OR with turns) |
 | `reviewRecentMessages` | `0` | Recent messages included in background review (`0` = all) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "🧠 Persistent memory + 🔍 session search + 🛡️ secret scanning for Pi. Token-aware policy-only memory by default, SQLite FTS5 search, auto-consolidation, procedural skills. 368 tests. Ported from Hermes agent.",
   "type": "module",
   "main": "src/index.ts",

package/src/config.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-import type { MemoryConfig, MemoryOverflowStrategy, SessionSearchVariant } from "./types.js";
+import type { MemoryConfig, MemoryOverflowStrategy, SessionSearchVariant, ThinkingLevel } from "./types.js";
 import {
   DEFAULT_MEMORY_CHAR_LIMIT,
   DEFAULT_USER_CHAR_LIMIT,
@@ -20,6 +20,7 @@ import { normalizeConfiguredMemoryDir, normalizeProjectsMemoryDir } from "./path
 
 const MEMORY_OVERFLOW_STRATEGIES: readonly MemoryOverflowStrategy[] = ["auto-consolidate", "reject", "fifo-evict"];
 const SESSION_SEARCH_VARIANTS: readonly SessionSearchVariant[] = ["legacy", "anchors"];
+const THINKING_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
 
 function isMemoryOverflowStrategy(value: unknown): value is MemoryOverflowStrategy {
   return typeof value === "string" && MEMORY_OVERFLOW_STRATEGIES.includes(value as MemoryOverflowStrategy);
@@ -29,6 +30,10 @@ function isSessionSearchVariant(value: unknown): value is SessionSearchVariant {
   return typeof value === "string" && SESSION_SEARCH_VARIANTS.includes(value as SessionSearchVariant);
 }
 
+function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return typeof value === "string" && THINKING_LEVELS.includes(value as ThinkingLevel);
+}
+
 const DEFAULT_CONFIG: MemoryConfig = {
   memoryMode: "policy-only",
   memoryPolicyStyle: "full",
@@ -127,6 +132,11 @@ export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
       ) {
         config.sessionSearch = { variant: parsed.sessionSearch.variant };
       }
+      if (typeof parsed.llmModelOverride === "string") {
+        const trimmed = parsed.llmModelOverride.trim();
+        if (trimmed.length > 0) config.llmModelOverride = trimmed;
+      }
+      if (isThinkingLevel(parsed.llmThinkingOverride)) config.llmThinkingOverride = parsed.llmThinkingOverride;
       if (hasMemoryOverflowStrategy) {
         config.autoConsolidate = config.memoryOverflowStrategy === "auto-consolidate";
       } else if (hasLegacyAutoConsolidate) {

package/src/handlers/auto-consolidate.ts

@@ -10,7 +10,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { MemoryStore } from "../store/memory-store.js";
 import { CONSOLIDATION_PROMPT, ENTRY_DELIMITER } from "../constants.js";
-import type { ConsolidationResult } from "../types.js";
+import type { ConsolidationResult, MemoryConfig } from "../types.js";
+import { execChildPrompt } from "./pi-child-process.js";
 
 type MemoryTarget = "memory" | "user" | "failure";
 type ToolMemoryTarget = MemoryTarget | "project";
@@ -26,6 +27,20 @@ function labelForTarget(target: MemoryTarget, toolTarget: ToolMemoryTarget): str
   return "Memory";
 }
 
+function describeConsolidationFailure(
+  result: { code: number; stderr?: string; killed?: boolean },
+  timeoutMs: number,
+): string {
+  const stderr = result.stderr?.trim();
+  const terminated = result.killed || result.code === 143;
+
+  if (terminated) {
+    return `Consolidation subprocess was terminated (likely timeout or cancellation). Timeout: ${timeoutMs}ms. Consider increasing consolidationTimeoutMs if this is a manual run.`;
+  }
+
+  return `Consolidation process exited with code ${result.code}: ${stderr?.slice(0, 200) || "unknown error"}`;
+}
+
 export async function triggerConsolidation(
   pi: ExtensionAPI,
   store: MemoryStore,
@@ -33,6 +48,7 @@ export async function triggerConsolidation(
   signal?: AbortSignal,
   timeoutMs: number = 60000,
   toolTarget: ToolMemoryTarget = target,
+  llmConfig: Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride"> = {},
 ): Promise<ConsolidationResult> {
   const entries = entriesForTarget(store, target);
   const currentContent = entries.join(ENTRY_DELIMITER);
@@ -47,17 +63,18 @@ export async function triggerConsolidation(
   ].join("\n");
 
   try {
-    const result = await pi.exec("pi", ["-p", "--no-session", prompt], {
+    const result = await execChildPrompt(pi, prompt, llmConfig, {
       signal,
-      timeout: timeoutMs,
-    });
+      timeoutMs,
+      retryWithoutOverrides: true,
+    }) as { code: number; stdout?: string; stderr?: string; killed?: boolean };
 
     if (result.code === 0) {
       return { consolidated: true };
     }
     return {
       consolidated: false,
-      error: `Consolidation process exited with code ${result.code}: ${result.stderr?.slice(0, 200) || "unknown error"}`,
+      error: describeConsolidationFailure(result, timeoutMs),
     };
   } catch (err) {
     return {
@@ -76,10 +93,12 @@ export function registerConsolidateCommand(
   timeoutMs: number = 60000,
   projectStore: MemoryStore | null = null,
   projectName?: string | null,
+  llmConfig: Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride"> = {},
 ): void {
   pi.registerCommand("memory-consolidate", {
     description: "Manually trigger memory consolidation to free up space",
     handler: async (_args, ctx) => {
+      const manualTimeoutMs = Math.max(timeoutMs, 180000);
       const results: string[] = [];
       const targets: Array<{
         label: string;
@@ -100,6 +119,16 @@ export function registerConsolidateCommand(
         });
       }
 
+      try {
+        ctx.ui.notify(
+          `🔄 Starting memory consolidation for ${targets.length} target${targets.length === 1 ? "" : "s"}...`,
+          "info",
+        );
+      } catch {
+        // Best-effort only. If the command context is already stale, continue
+        // with the consolidation work rather than failing before it starts.
+      }
+
       for (const item of targets) {
         const entries = entriesForTarget(item.store, item.target);
 
@@ -108,7 +137,24 @@ export function registerConsolidateCommand(
           continue;
         }
 
-        const result = await triggerConsolidation(pi, item.store, item.target, ctx.signal, timeoutMs, item.toolTarget);
+        try {
+          ctx.ui.notify(
+            `⏳ Consolidating ${item.label}...`,
+            "info",
+          );
+        } catch {
+          // Best-effort progress feedback only.
+        }
+
+        const result = await triggerConsolidation(
+          pi,
+          item.store,
+          item.target,
+          ctx.signal,
+          manualTimeoutMs,
+          item.toolTarget,
+          llmConfig,
+        );
 
         if (result.consolidated) {
           await item.store.loadFromDisk();
@@ -118,10 +164,16 @@ export function registerConsolidateCommand(
         }
       }
 
-      ctx.ui.notify(
-        `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`,
-        "info",
-      );
+      const summary = `\n  🔄 Memory Consolidation\n  ${"─".repeat(30)}\n${results.map((r) => `  ${r}`).join("\n")}`;
+
+      try {
+        ctx.ui.notify(summary, "info");
+      } catch {
+        // Child consolidation can indirectly trigger a runtime reload/session
+        // replacement. If that happens, the original command ctx is stale by
+        // the time we reach the final summary, so the command should exit
+        // quietly instead of surfacing a stale-ctx error.
+      }
     },
   });
 }

package/src/handlers/background-review.ts

@@ -12,6 +12,7 @@ import { MemoryStore } from "../store/memory-store.js";
 import { COMBINED_REVIEW_PROMPT } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
 import { applyRecentMessageLimit, collectMessageParts } from "./message-parts.js";
+import { execChildPrompt } from "./pi-child-process.js";
 
 export function setupBackgroundReview(
   pi: ExtensionAPI,
@@ -116,9 +117,9 @@ export function setupBackgroundReview(
     // We intentionally omit ctx.signal — the signal is tied to the turn
     // lifetime and would abort the subprocess before it finishes now that
     // we're not awaiting. The timeout (120s) provides its own safety net.
-    const reviewPromise = pi.exec("pi", ["-p", "--no-session", reviewPrompt.join("\n")], {
+    const reviewPromise = execChildPrompt(pi, reviewPrompt.join("\n"), config, {
       signal: undefined,
-      timeout: 120000,
+      timeoutMs: 120000,
     });
 
     reviewPromise

package/src/handlers/correction-detector.ts

@@ -25,6 +25,7 @@ import {
 } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
 import { getMessageText } from "../types.js";
+import { execChildPrompt } from "./pi-child-process.js";
 
 /**
  * Extract the directive part from a correction message.
@@ -205,9 +206,9 @@ export function setupCorrectionDetector(
         recentParts.join("\n\n"),
       );
 
-      const result = await pi.exec("pi", ["-p", "--no-session", prompt.join("\n")], {
+      const result = await execChildPrompt(pi, prompt.join("\n"), config, {
         signal: ctx.signal,
-        timeout: 30000,
+        timeoutMs: 30000,
       });
 
       if (result.code === 0 && result.stdout) {

package/src/handlers/pi-child-process.ts

@@ -0,0 +1,119 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { MemoryConfig, ThinkingLevel } from "../types.js";
+
+type ChildLlmConfig = Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride">;
+
+interface PiExecResult {
+  code: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+interface ExecChildPromptOptions {
+  signal?: AbortSignal;
+  timeoutMs: number;
+  retryWithoutOverrides?: boolean;
+}
+
+const OVERRIDE_FAILURE_SUBJECT = /\b(model|provider|thinking)\b/i;
+const OVERRIDE_FAILURE_REASON = /\b(not found|unknown|invalid|unsupported|unavailable|unrecognized|no match|no matches|cannot resolve|failed to resolve)\b/i;
+
+function normalizedModelOverride(config: ChildLlmConfig): string | undefined {
+  const trimmed = config.llmModelOverride?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function effectiveThinkingOverride(config: ChildLlmConfig): ThinkingLevel | undefined {
+  return config.llmThinkingOverride ?? (normalizedModelOverride(config) ? "off" : undefined);
+}
+
+export function hasChildLlmOverrides(config: ChildLlmConfig): boolean {
+  return normalizedModelOverride(config) !== undefined || effectiveThinkingOverride(config) !== undefined;
+}
+
+export function inheritedExtensionArgs(argv: string[] = process.argv.slice(2)): string[] {
+  const args: string[] = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const current = argv[i];
+    if (current === "-e" || current === "--extension") {
+      const next = argv[i + 1];
+      if (typeof next === "string" && next.length > 0) {
+        args.push(current, next);
+        i++;
+      }
+      continue;
+    }
+
+    if (current.startsWith("--extension=")) {
+      args.push(current);
+    }
+  }
+
+  return args;
+}
+
+export function buildChildPiPromptArgs(prompt: string, config: ChildLlmConfig, argv: string[] = process.argv.slice(2)): string[] {
+  const args = ["-p", "--no-session"];
+  const model = normalizedModelOverride(config);
+  const thinking = effectiveThinkingOverride(config);
+  const inheritedExtensions = inheritedExtensionArgs(argv);
+
+  if (model) args.push("--model", model);
+  if (thinking) args.push("--thinking", thinking);
+  args.push(...inheritedExtensions);
+  args.push(prompt);
+
+  return args;
+}
+
+function basePromptArgs(prompt: string): string[] {
+  return ["-p", "--no-session", prompt];
+}
+
+function shouldRetryWithoutOverridesFromText(text: string | undefined): boolean {
+  if (!text) return false;
+  return OVERRIDE_FAILURE_SUBJECT.test(text) && OVERRIDE_FAILURE_REASON.test(text);
+}
+
+function shouldRetryWithoutOverrides(result: PiExecResult): boolean {
+  return shouldRetryWithoutOverridesFromText(result.stderr) || shouldRetryWithoutOverridesFromText(result.stdout);
+}
+
+function shouldRetryWithoutOverridesForError(error: unknown): boolean {
+  return shouldRetryWithoutOverridesFromText(String(error));
+}
+
+export async function execChildPrompt(
+  pi: Pick<ExtensionAPI, "exec">,
+  prompt: string,
+  config: ChildLlmConfig,
+  options: ExecChildPromptOptions,
+): Promise<PiExecResult> {
+  const execOptions = {
+    signal: options.signal,
+    timeout: options.timeoutMs,
+  };
+
+  try {
+    const result = await pi.exec("pi", buildChildPiPromptArgs(prompt, config), execOptions) as PiExecResult;
+    if (
+      result.code === 0 ||
+      !options.retryWithoutOverrides ||
+      !hasChildLlmOverrides(config) ||
+      !shouldRetryWithoutOverrides(result)
+    ) {
+      return result;
+    }
+  } catch (error) {
+    if (
+      !options.retryWithoutOverrides ||
+      !hasChildLlmOverrides(config) ||
+      !shouldRetryWithoutOverridesForError(error)
+    ) {
+      throw error;
+    }
+  }
+
+  return pi.exec("pi", basePromptArgs(prompt), execOptions) as Promise<PiExecResult>;
+}

package/src/handlers/session-flush.ts

@@ -9,6 +9,7 @@ import { MemoryStore } from "../store/memory-store.js";
 import { FLUSH_PROMPT } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
 import { collectMessageParts } from "./message-parts.js";
+import { execChildPrompt } from "./pi-child-process.js";
 
 export function setupSessionFlush(
   pi: ExtensionAPI,
@@ -42,9 +43,9 @@ export function setupSessionFlush(
     ].join("\n");
 
     try {
-      await pi.exec("pi", ["-p", "--no-session", flushMessage], {
+      await execChildPrompt(pi, flushMessage, config, {
         signal,
-        timeout: timeoutMs,
+        timeoutMs,
       });
     } catch {
       // Best-effort flush — never block shutdown

package/src/index.ts

@@ -179,15 +179,15 @@ export default function (pi: ExtensionAPI) {
 
   // ── 7. Setup auto-consolidation (inject consolidator into stores) ──
   store.setConsolidator(async (target, signal) => {
-    return triggerConsolidation(pi, store, target, signal, config.consolidationTimeoutMs);
+    return triggerConsolidation(pi, store, target, signal, config.consolidationTimeoutMs, target, config);
   });
   if (projectStore) {
     projectStore.setConsolidator(async (target, signal) => {
       const toolTarget = target === "memory" ? "project" : target;
-      return triggerConsolidation(pi, projectStore, target, signal, config.consolidationTimeoutMs, toolTarget);
+      return triggerConsolidation(pi, projectStore, target, signal, config.consolidationTimeoutMs, toolTarget, config);
     });
   }
-  registerConsolidateCommand(pi, store, config.consolidationTimeoutMs, projectStore, projectName);
+  registerConsolidateCommand(pi, store, config.consolidationTimeoutMs, projectStore, projectName, config);
 
   // ── 8. Setup correction detection ──
   setupCorrectionDetector(pi, store, projectStore, config, dbManager, projectName);

package/src/store/db.ts

@@ -25,50 +25,50 @@ type BunDatabaseInstance = {
   transaction?: (fn: any) => any;
 };
 
-function loadDatabaseCtor(): DatabaseCtor {
-  const require = createRequire(import.meta.url);
-  try {
-    const mod = require('better-sqlite3') as { default?: DatabaseCtor } | DatabaseCtor;
-    return (mod as { default?: DatabaseCtor }).default ?? (mod as DatabaseCtor);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message.toLowerCase() : '';
-    const isBunRuntime = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined';
-    const isBunIncompat = msg.includes('better-sqlite3 is not yet supported in bun') || msg.includes('not yet supported in bun');
-    if (!isBunIncompat) {
-      throw err;
-    }
-    if (!isBunRuntime) {
-      throw err;
+function createBunCompatDatabaseCtor(require: NodeRequire): DatabaseCtor {
+  const bunSqlite = require('bun:sqlite') as { Database: new (dbPath: string) => BunDatabaseInstance };
+
+  return class BunCompatDatabase implements DatabaseLike {
+    private readonly db: BunDatabaseInstance;
+
+    constructor(dbPath: string) {
+      this.db = new bunSqlite.Database(dbPath);
     }
 
-    const bunSqlite = require('bun:sqlite') as { Database: new (dbPath: string) => BunDatabaseInstance };
+    prepare(sql: string): StatementLike {
+      return this.db.prepare(sql);
+    }
 
-    return class BunCompatDatabase implements DatabaseLike {
-      private readonly db: BunDatabaseInstance;
+    exec(sql: string): void {
+      this.db.exec(sql);
+    }
 
-      constructor(dbPath: string) {
-        this.db = new bunSqlite.Database(dbPath);
-      }
+    close(): void {
+      this.db.close();
+    }
 
-      prepare(sql: string): StatementLike {
-        return this.db.prepare(sql);
+    transaction(fn: any): any {
+      if (!this.db.transaction) {
+        return undefined;
       }
+      return this.db.transaction(fn);
+    }
+  };
+}
 
-      exec(sql: string): void {
-        this.db.exec(sql);
-      }
+function loadDatabaseCtor(): DatabaseCtor {
+  const require = createRequire(import.meta.url);
+  const isBunRuntime = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined';
 
-      close(): void {
-        this.db.close();
-      }
+  if (isBunRuntime) {
+    return createBunCompatDatabaseCtor(require);
+  }
 
-      transaction(fn: any): any {
-        if (!this.db.transaction) {
-          return undefined;
-        }
-        return this.db.transaction(fn);
-      }
-    };
+  try {
+    const mod = require('better-sqlite3') as { default?: DatabaseCtor } | DatabaseCtor;
+    return (mod as { default?: DatabaseCtor }).default ?? (mod as DatabaseCtor);
+  } catch (err) {
+    throw err;
   }
 }
 

package/src/types.ts

@@ -8,6 +8,8 @@ export type MemoryOverflowStrategy = "auto-consolidate" | "reject" | "fifo-evict
 
 export type SessionSearchVariant = "legacy" | "anchors";
 
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+
 export interface SessionSearchConfig {
   /** Session search implementation variant. Default: legacy */
   variant: SessionSearchVariant;
@@ -46,6 +48,10 @@ export interface MemoryConfig {
   projectsMemoryDir?: string;
   /** Session search configuration. Default: { variant: "legacy" } */
   sessionSearch?: SessionSearchConfig;
+  /** Override model used for child pi -p subprocess LLM calls. Default: unset */
+  llmModelOverride?: string;
+  /** Override thinking level used for child pi -p subprocess LLM calls. Default: unset */
+  llmThinkingOverride?: ThinkingLevel;
   /** Strategy when memory is full. Default: auto-consolidate */
   memoryOverflowStrategy?: MemoryOverflowStrategy;
   /** Legacy alias for memoryOverflowStrategy. Default: true */