pi-hermes-memory 0.7.22 → 0.8.0

package/src/handlers/background-review.ts

@@ -3,23 +3,129 @@
  * Ported from hermes-agent/run_agent.py (_spawn_background_review, _memory_nudge_interval).
  * See PLAN.md → "Hermes Source File Reference Map" for source lines.
  *
- * Uses pi.exec("pi", ["-p", ...]) for isolated one-shot review,
- * keeping us within Pi's intended extension API.
+ * Default transport: in-process complete() side-channel (preserves parent LLM cache).
+ * Fallback: pi.exec("pi", ["-p", ...]) subprocess when direct path is unavailable.
  */
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { COMBINED_REVIEW_PROMPT, DIRECT_REVIEW_SYSTEM_PROMPT } from "../constants.js";
 import { MemoryStore } from "../store/memory-store.js";
-import { COMBINED_REVIEW_PROMPT } from "../constants.js";
+import { DatabaseManager } from "../store/db.js";
 import type { MemoryConfig } from "../types.js";
 import { applyRecentMessageLimit, collectMessageParts } from "./message-parts.js";
 import { execChildPrompt } from "./pi-child-process.js";
+import { runDirectMemoryCompletion, usesDirectTransport, type DirectReviewResult } from "./review-memory-ops.js";
+
+export interface BackgroundReviewOptions {
+  dbManager?: DatabaseManager | null;
+  projectName?: string | null;
+  deps?: BackgroundReviewDeps;
+}
+
+export interface BackgroundReviewDeps {
+  runDirectReview?: typeof runDirectMemoryCompletion;
+  execChildPrompt?: typeof execChildPrompt;
+  /** Test-only hook: called once runReview() has fully settled (after the
+   * fire-and-forget review work completes and reviewInProgress resets),
+   * since production callers never await runReview() directly. */
+  onReviewSettled?: () => void;
+}
+
+export interface ReviewPromptInput {
+  parts: string[];
+  currentMemory: string;
+  currentUser: string;
+  currentProject: string | null;
+}
+
+export function buildSubprocessReviewPrompt(input: ReviewPromptInput): string {
+  const reviewPrompt = [
+    COMBINED_REVIEW_PROMPT,
+    "",
+    "--- Current Memory ---",
+    input.currentMemory || "(empty)",
+    "",
+    "--- Current User Profile ---",
+    input.currentUser || "(empty)",
+  ];
+
+  if (input.currentProject !== null) {
+    reviewPrompt.push(
+      "",
+      "--- Current Project Memory ---",
+      input.currentProject || "(empty)",
+    );
+  }
+
+  reviewPrompt.push(
+    "",
+    "--- Conversation to Review ---",
+    input.parts.join("\n\n"),
+  );
+
+  return reviewPrompt.join("\n");
+}
+
+export function buildDirectReviewUserPrompt(input: ReviewPromptInput): string {
+  const sections = [
+    "--- Current Memory ---",
+    input.currentMemory || "(empty)",
+    "",
+    "--- Current User Profile ---",
+    input.currentUser || "(empty)",
+  ];
+
+  if (input.currentProject !== null) {
+    sections.push(
+      "",
+      "--- Current Project Memory ---",
+      input.currentProject || "(empty)",
+    );
+  }
+
+  sections.push(
+    "",
+    "--- Conversation to Review ---",
+    input.parts.join("\n\n"),
+  );
+
+  return sections.join("\n");
+}
+
+function shouldNotifyDirect(result: DirectReviewResult): boolean {
+  return result.ok && result.appliedCount > 0;
+}
+
+function shouldNotifySubprocess(stdout: string | undefined): boolean {
+  const output = stdout?.trim();
+  return !!output && !output.toLowerCase().includes("nothing to save");
+}
+
+async function runSubprocessReview(
+  pi: ExtensionAPI,
+  prompt: string,
+  config: MemoryConfig,
+  execChild: typeof execChildPrompt,
+): Promise<{ code: number; stdout?: string }> {
+  return execChild(pi, prompt, config, {
+    signal: undefined,
+    timeoutMs: 120000,
+  });
+}
 
 export function setupBackgroundReview(
   pi: ExtensionAPI,
   store: MemoryStore,
   projectStore: MemoryStore | null,
   config: MemoryConfig,
+  options: BackgroundReviewOptions = {},
 ): void {
+  const dbManager = options.dbManager ?? null;
+  const projectName = options.projectName ?? null;
+  const runDirectReview = options.deps?.runDirectReview ?? runDirectMemoryCompletion;
+  const execChild = options.deps?.execChildPrompt ?? execChildPrompt;
+  const onReviewSettled = options.deps?.onReviewSettled;
+
   let turnsSinceReview = 0;
   let toolCallsSinceReview = 0;
   let userTurnCount = 0;
@@ -37,9 +143,6 @@ export function setupBackgroundReview(
     if (!config.reviewEnabled) return;
     if (reviewInProgress) return;
 
-    // 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 msg = event.message;
       if (msg?.role === "assistant") {
@@ -56,7 +159,6 @@ export function setupBackgroundReview(
       // If we can't count tool calls, fall back to turn-based only
     }
 
-    // Trigger on EITHER turn count OR tool call count
     const turnThresholdMet = turnsSinceReview >= config.nudgeInterval;
     const toolCallThresholdMet = toolCallsSinceReview >= config.nudgeToolCalls;
 
@@ -67,78 +169,76 @@ export function setupBackgroundReview(
     toolCallsSinceReview = 0;
     reviewInProgress = true;
 
-    // Build conversation snapshot from session entries (crash-safe)
     let allParts: string[] = [];
     try {
       const entries = ctx.sessionManager.getBranch();
       allParts = collectMessageParts(entries);
     } catch {
       reviewInProgress = false;
-      return; // Session expired or empty — nothing to review
+      return;
     }
     if (allParts.length < 4) {
       reviewInProgress = false;
-      return; // Not enough conversation to review
+      return;
     }
+
     const parts = applyRecentMessageLimit(allParts, config.reviewRecentMessages);
+    const promptInput: ReviewPromptInput = {
+      parts,
+      currentMemory: store.getMemoryEntries().join("\n§\n"),
+      currentUser: store.getUserEntries().join("\n§\n"),
+      currentProject: projectStore ? projectStore.getMemoryEntries().join("\n§\n") : null,
+    };
 
-    const currentMemory = store.getMemoryEntries().join("\n§\n");
-    const currentUser = store.getUserEntries().join("\n§\n");
-    const currentProject = projectStore ? projectStore.getMemoryEntries().join("\n§\n") : null;
+    const subprocessPrompt = buildSubprocessReviewPrompt(promptInput);
+    const directPrompt = buildDirectReviewUserPrompt(promptInput);
 
-    const reviewPrompt = [
-      COMBINED_REVIEW_PROMPT,
-      "",
-      "--- Current Memory ---",
-      currentMemory || "(empty)",
-      "",
-      "--- Current User Profile ---",
-      currentUser || "(empty)",
-    ];
-
-    if (currentProject !== null) {
-      reviewPrompt.push(
-        "",
-        "--- Current Project Memory ---",
-        currentProject || "(empty)",
-      );
-    }
+    const finishReview = () => {
+      reviewInProgress = false;
+      onReviewSettled?.();
+    };
 
-    reviewPrompt.push(
-      "",
-      "--- Conversation to Review ---",
-      parts.join("\n\n"),
-    );
+    const notifyIfSaved = (saved: boolean) => {
+      if (saved) {
+        ctx.ui.notify("💾 Memory auto-reviewed and updated", "info");
+      }
+    };
+
+    const runReview = async (): Promise<void> => {
+      if (usesDirectTransport(config)) {
+        try {
+          const directResult = await runDirectReview(
+            ctx as Pick<ExtensionContext, "model" | "modelRegistry">,
+            store,
+            projectStore,
+            { userPrompt: directPrompt, systemPrompt: DIRECT_REVIEW_SYSTEM_PROMPT, config, timeoutMs: 120000 },
+            dbManager,
+            projectName,
+          );
+
+          if (directResult.ok) {
+            notifyIfSaved(shouldNotifyDirect(directResult));
+            return;
+          }
 
-    // Fire-and-forget: do NOT await. The review runs in a subprocess;
-    // blocking turn_end would freeze the interactive chat.
-    // Notifications are delivered via .then() once the subprocess completes.
-    //
-    // 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 = execChildPrompt(pi, reviewPrompt.join("\n"), config, {
-      signal: undefined,
-      timeoutMs: 120000,
-    });
-
-    reviewPromise
-      .then((result) => {
-        reviewInProgress = false;
-        if (result.code === 0 && result.stdout) {
-          const output = result.stdout.trim();
-          if (output && !output.toLowerCase().includes("nothing to save")) {
-            ctx.ui.notify("💾 Memory auto-reviewed and updated", "info");
+          if (directResult.fallbackReason === "empty") {
+            return;
           }
+        } catch {
+          // Fall through to subprocess below.
         }
-        // Auto-review is best-effort. Non-zero exits are silently skipped —
-        // common on Windows where pi CLI may resolve differently. The next
-        // review cycle will retry.
-      })
+      }
+
+      const subprocessResult = await runSubprocessReview(pi, subprocessPrompt, config, execChild);
+      if (subprocessResult.code === 0) {
+        notifyIfSaved(shouldNotifySubprocess(subprocessResult.stdout));
+      }
+    };
+
+    runReview()
       .catch(() => {
-        // Best-effort: subprocess failures (timeout, signal, spawn errors)
-        // are silently ignored. The next review cycle will retry.
-        reviewInProgress = false;
-      });
+        // Best-effort only
+      })
+      .finally(finishReview);
   });
-}
+}

package/src/handlers/child-process-watchdog.mjs

@@ -0,0 +1,90 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const [timeoutValue, cancellationPath, command, ...args] = process.argv.slice(2);
+const timeoutMs = Number(timeoutValue);
+
+if (!cancellationPath || !command || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+  process.stderr.write("pi-hermes-memory watchdog: invalid invocation\n");
+  process.exit(2);
+}
+
+const child = spawn(command, args, {
+  detached: process.platform !== "win32",
+  stdio: ["ignore", "pipe", "pipe"],
+});
+
+child.stdout?.pipe(process.stdout);
+child.stderr?.pipe(process.stderr);
+
+let timedOut = false;
+let cancelled = false;
+let terminating = false;
+let forceTimer;
+
+function signalTree(signal) {
+  if (!child.pid) return;
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    killer.unref();
+    return;
+  }
+  try {
+    process.kill(-child.pid, signal);
+  } catch {
+    try { child.kill(signal); } catch {}
+  }
+}
+
+function terminateTree() {
+  if (terminating) return;
+  terminating = true;
+  signalTree("SIGTERM");
+  forceTimer = setTimeout(() => signalTree("SIGKILL"), 500);
+  forceTimer.unref();
+}
+
+const timeout = setTimeout(() => {
+  timedOut = true;
+  process.stderr.write(`[pi-hermes-memory] child timed out after ${timeoutMs}ms; terminating process tree\n`);
+  terminateTree();
+}, timeoutMs);
+timeout.unref();
+
+const cancellationPoll = cancellationPath === "-" ? undefined : setInterval(() => {
+  if (!existsSync(cancellationPath)) return;
+  cancelled = true;
+  process.stderr.write("[pi-hermes-memory] child cancellation requested; terminating process tree\n");
+  terminateTree();
+}, 25);
+cancellationPoll?.unref();
+
+for (const signal of ["SIGTERM", "SIGINT"]) {
+  process.on(signal, terminateTree);
+}
+
+child.once("error", (error) => {
+  clearTimeout(timeout);
+  if (cancellationPoll) clearInterval(cancellationPoll);
+  if (forceTimer) clearTimeout(forceTimer);
+  process.stderr.write(`pi-hermes-memory watchdog: ${error.message}\n`);
+  process.exitCode = timedOut ? 124 : cancelled ? 143 : 127;
+});
+
+child.once("close", (code, signal) => {
+  clearTimeout(timeout);
+  if (cancellationPoll) clearInterval(cancellationPoll);
+  if (forceTimer) clearTimeout(forceTimer);
+  if (timedOut) {
+    process.exitCode = 124;
+  } else if (cancelled) {
+    process.exitCode = 143;
+  } else if (typeof code === "number") {
+    process.exitCode = code;
+  } else {
+    process.exitCode = signal === "SIGTERM" ? 143 : 1;
+  }
+});

package/src/handlers/correction-detector.ts

@@ -11,21 +11,19 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { MemoryStore } from "../store/memory-store.js";
 import { DatabaseManager } from "../store/db.js";
-import {
-  formatFailureMemoryContent,
-  syncMemoryEntry,
-} from "../store/sqlite-memory-store.js";
 import {
   CORRECTION_SAVE_PROMPT,
   CORRECTION_STRONG_PATTERNS,
   CORRECTION_WEAK_PATTERNS,
   CORRECTION_NEGATIVE_PATTERNS,
   CORRECTION_DIRECTIVE_WORDS,
+  DIRECT_CORRECTION_SYSTEM_PROMPT,
   ENTRY_DELIMITER,
 } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
 import { getMessageText } from "../types.js";
 import { execChildPrompt } from "./pi-child-process.js";
+import { runDirectMemoryCompletion, usesDirectTransport } from "./review-memory-ops.js";
 
 /**
  * Extract the directive part from a correction message.
@@ -129,12 +127,14 @@ export function setupCorrectionDetector(
   config: MemoryConfig,
   dbManager: DatabaseManager | null = null,
   projectName?: string | null,
+  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
 ): void {
   if (!config.correctionDetection) return;
 
   let pendingCorrection = false;
   let turnsSinceLastCorrection = 3; // Start at threshold so first correction can fire immediately
   let correctionInProgress = false;
+  const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
 
   // Flag on message_end (user role)
   pi.on("message_end", async (event, _ctx) => {
@@ -182,9 +182,7 @@ export function setupCorrectionDetector(
       const currentUser = store.getUserEntries().join(ENTRY_DELIMITER);
       const currentProject = projectStore ? projectStore.getMemoryEntries().join(ENTRY_DELIMITER) : null;
 
-      const prompt = [
-        CORRECTION_SAVE_PROMPT,
-        "",
+      const promptBody = [
         "--- Current Memory ---",
         currentMemory || "(empty)",
         "",
@@ -193,31 +191,67 @@ export function setupCorrectionDetector(
       ];
 
       if (currentProject !== null) {
-        prompt.push(
+        promptBody.push(
           "",
           "--- Current Project Memory ---",
           currentProject || "(empty)",
         );
       }
 
-      prompt.push(
+      promptBody.push(
         "",
         "--- Recent Conversation ---",
         recentParts.join("\n\n"),
       );
 
-      const result = await execChildPrompt(pi, prompt.join("\n"), config, {
-        signal: ctx.signal,
-        timeoutMs: 30000,
-      });
+      let savedViaLlm = false;
+
+      const runSubprocessCorrection = async (): Promise<void> => {
+        const subprocessPrompt = [CORRECTION_SAVE_PROMPT, "", ...promptBody].join("\n");
+        const result = await execChildPrompt(pi, subprocessPrompt, config, {
+          signal: ctx.signal,
+          timeoutMs: 30000,
+        });
+        if (result.code === 0 && result.stdout) {
+          const output = result.stdout.trim();
+          savedViaLlm = !!output && !output.toLowerCase().includes("nothing to save");
+        }
+      };
 
-      if (result.code === 0 && result.stdout) {
-        const output = result.stdout.trim();
-        if (output && !output.toLowerCase().includes("nothing to save")) {
-          ctx.ui.notify("🔧 Correction detected — memory updated", "info");
+      let handledDirect = false;
+      if (usesDirectTransport(config)) {
+        try {
+          const directResult = await runDirect(
+            ctx,
+            store,
+            projectStore,
+            {
+              systemPrompt: DIRECT_CORRECTION_SYSTEM_PROMPT,
+              userPrompt: promptBody.join("\n"),
+              config,
+              timeoutMs: 30000,
+              signal: ctx.signal,
+            },
+            dbManager,
+            projectName,
+          );
+          if (directResult.ok) {
+            savedViaLlm = directResult.appliedCount > 0;
+            handledDirect = true;
+          }
+        } catch {
+          // Fall through to subprocess below.
         }
       }
 
+      if (!handledDirect) {
+        await runSubprocessCorrection();
+      }
+
+      if (savedViaLlm) {
+        ctx.ui.notify("🔧 Correction detected — memory updated", "info");
+      }
+
       // Also save as a failure memory for learning
       try {
         const lastUserMsg = recentParts.find(p => p.startsWith("[USER]"));
@@ -226,29 +260,11 @@ export function setupCorrectionDetector(
           const directive = extractCorrectionDirective(correctionText);
           const failureReason = "User corrected the agent";
           const scopedProjectName = projectStore ? projectName?.trim() || null : null;
-          const addResult = await store.addFailure(directive, {
+          await store.addFailure(directive, {
             category: "correction",
             failureReason,
             project: scopedProjectName ?? undefined,
           });
-
-          if (addResult.success && dbManager) {
-            try {
-              syncMemoryEntry(dbManager, {
-                content: formatFailureMemoryContent(directive, {
-                  category: "correction",
-                  failureReason,
-                  project: scopedProjectName,
-                }),
-                target: "failure",
-                project: scopedProjectName,
-                category: "correction",
-                failureReason,
-              });
-            } catch {
-              // Best-effort — searchable sync should not block correction capture
-            }
-          }
         }
       } catch {
         // Best-effort — don't block the session