@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-hermes-memory/src/handlers/auto-consolidate.ts

@@ -18,11 +18,15 @@ import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type Proj
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { MemoryStore } from "../store/memory-store.js";
 import { DatabaseManager } from "../store/db.js";
+import { getMemoryUsageSignals, type MemoryUsageSignal } from "../store/sqlite-memory-store.js";
 import {
   CONSOLIDATION_PROMPT,
+  CONSOLIDATION_CHUNK_CHARS_MIN,
+  DEFAULT_CONSOLIDATION_CHUNK_CHARS,
+  MAX_CONSOLIDATION_ROUNDS,
   DEFAULT_CONSOLIDATION_TIMEOUT_MS,
   DIRECT_CONSOLIDATION_SYSTEM_PROMPT,
   ENTRY_DELIMITER,
@@ -30,12 +34,16 @@ import {
 import type { ConsolidationResult, MemoryConfig } from "../types.js";
 import { AGENT_ROOT } from "../paths.js";
 import { execChildPrompt } from "./pi-child-process.js";
-import { runDirectMemoryCompletion, usesDirectTransport } from "./review-memory-ops.js";
+import { runDirectMemoryCompletion, usesDirectTransport, type DirectReviewContext } from "./review-memory-ops.js";
 import { AtomicLockCoordinator } from "../store/atomic-lock-coordinator.js";
 
 type MemoryTarget = "memory" | "user" | "failure";
 type ToolMemoryTarget = MemoryTarget | "project";
-type ConsolidationLlmConfig = Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride" | "reviewTransport">;
+type ConsolidationLlmConfig = Pick<
+  MemoryConfig,
+  "llmModelOverride" | "llmThinkingOverride" | "reviewTransport"
+  | "consolidationChunking" | "consolidationChunkChars" | "consolidationUsageSignals"
+>;
 
 // staleMs is deliberately decoupled from the consolidation timeout. The holder
 // beats every CONSOLIDATION_LOCK_HEARTBEAT_MS while its child runs, so a
@@ -164,15 +172,150 @@ function buildConsolidationPrompt(
   target: MemoryTarget,
   toolTarget: ToolMemoryTarget,
   entries: string[],
+  scoped = false,
+  usageSignals: Map<string, MemoryUsageSignal> | null = null,
 ): string {
-  return [
+  const lines = [
     CONSOLIDATION_PROMPT,
     "",
     `--- Current ${labelForTarget(target, toolTarget)} Entries ---`,
     entries.join(ENTRY_DELIMITER) || "(empty)",
+  ];
+  const signalsSection = usageSignalsSectionText(usageSignals, entries);
+  if (signalsSection) {
+    lines.push("", signalsSection);
+  }
+  lines.push(
     "",
     `Use memory_add, memory_replace, or memory_remove to consolidate. Target: '${toolTarget}'`,
-  ].join("\n");
+  );
+  if (scoped) {
+    // Chunked rounds present a slice of the store, but the child's memory tools
+    // can see everything. Without an explicit scope the model may modify entries
+    // it was never shown — observed in real runs (a round wiped 11 out-of-scope
+    // entries). Real runs 2026-09-10.
+    lines.push(
+      "This pass covers ONLY the entries listed above — they are one slice of a larger store being consolidated in rounds.",
+      "Do NOT add, modify, or remove any entry that is not listed above.",
+    );
+  }
+  return lines.join("\n");
+}
+
+/** Longest entry excerpt shown in a usage-signals line. */
+const USAGE_SIGNAL_EXCERPT_CHARS = 80;
+/** Caps per half (tracked / never-recalled) so a chunk of many small entries —
+ *  or a mature store where everything has been recalled — cannot balloon a
+ *  round's prompt past its bounded budget. Both halves fold their remainder
+ *  into one summary line. */
+const USAGE_SIGNAL_TRACKED_MAX_LINES = 20;
+const USAGE_SIGNAL_NEVER_RECALLED_MAX_LINES = 20;
+
+function usageSignalExcerpt(entry: string): string {
+  const flat = entry.replace(/\s+/g, " ").trim();
+  return flat.length > USAGE_SIGNAL_EXCERPT_CHARS
+    ? `${flat.slice(0, USAGE_SIGNAL_EXCERPT_CHARS - 3)}...`
+    : flat;
+}
+
+/**
+ * Per-entry recall counts from the memory_search read path — the promotion-gate
+ * data telling the model which entries are load-bearing and which have never
+ * earned their place. Null (and therefore absent from prompts) until at least
+ * one presented entry has actually been recalled, so stores without tracking
+ * history keep byte-identical prompts.
+ */
+function usageSignalsSectionText(
+  usageSignals: Map<string, MemoryUsageSignal> | null,
+  entries: string[],
+): string | null {
+  if (!usageSignals || usageSignals.size === 0 || entries.length === 0) return null;
+
+  const tracked: Array<{ entry: string; signal: MemoryUsageSignal }> = [];
+  const neverRecalledLines: string[] = [];
+  for (const entry of entries) {
+    const signal = usageSignals.get(entry.trim());
+    const excerpt = usageSignalExcerpt(entry);
+    if (signal) {
+      tracked.push({ entry, signal });
+    } else {
+      neverRecalledLines.push(`- never recalled: "${excerpt}"`);
+    }
+  }
+  if (tracked.length === 0) return null;
+
+  // Both halves are capped with a summary line for the remainder: a chunk of
+  // many small entries — or a mature store where every entry has been recalled
+  // — must not balloon a chunked round's prompt past its bounded budget.
+  // Tracked entries are ranked by recall count so the most load-bearing ones
+  // survive the cut.
+  tracked.sort((a, b) => b.signal.hits - a.signal.hits);
+  const trackedLines = tracked
+    .slice(0, USAGE_SIGNAL_TRACKED_MAX_LINES)
+    .map(({ signal, entry }) => `- recalled ${signal.hits}x, last ${signal.lastHit}: "${usageSignalExcerpt(entry)}"`);
+  const lines = [
+    "--- Usage Signals (memory_search recall tracking) ---",
+    ...trackedLines,
+  ];
+  if (tracked.length > USAGE_SIGNAL_TRACKED_MAX_LINES) {
+    lines.push(`- (+${tracked.length - USAGE_SIGNAL_TRACKED_MAX_LINES} more recalled entries omitted — showing the top ${USAGE_SIGNAL_TRACKED_MAX_LINES} by recall count)`);
+  }
+  lines.push(...neverRecalledLines.slice(0, USAGE_SIGNAL_NEVER_RECALLED_MAX_LINES));
+  if (neverRecalledLines.length > USAGE_SIGNAL_NEVER_RECALLED_MAX_LINES) {
+    lines.push(`- (+${neverRecalledLines.length - USAGE_SIGNAL_NEVER_RECALLED_MAX_LINES} more listed entries have no recorded recalls)`);
+  }
+  lines.push(
+    "Treat these as tie-breakers, not removal orders: well-recalled entries are load-bearing (prefer keeping or merging them); never-recalled entries are weaker keep candidates.",
+  );
+  return lines.join("\n");
+}
+
+/**
+ * Scoped recall stats for the store being consolidated, or null when tracking
+ * is off, no database is available, or the lookup fails (fail-open).
+ */
+function loadUsageSignals(
+  dbManager: DatabaseManager | null,
+  llmConfig: ConsolidationLlmConfig,
+  target: MemoryTarget,
+  toolTarget: ToolMemoryTarget,
+  projectName: string | null | undefined,
+): Map<string, MemoryUsageSignal> | null {
+  if (!dbManager || llmConfig.consolidationUsageSignals === false) return null;
+  try {
+    return getMemoryUsageSignals(dbManager, {
+      target,
+      project: toolTarget === "project" ? (projectName ?? null) : null,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function chunkCharsFor(config: ConsolidationLlmConfig): number {
+  const value = config.consolidationChunkChars;
+  return typeof value === "number" && Number.isFinite(value) && value >= CONSOLIDATION_CHUNK_CHARS_MIN
+    ? value
+    : DEFAULT_CONSOLIDATION_CHUNK_CHARS;
+}
+
+/** A round shorter than this cannot plausibly boot a child and merge anything. */
+const MIN_ROUND_MS = 10_000;
+
+/**
+ * Head entries worth up to chunkChars of prompt text. Whole entries only; an
+ * entry larger than chunkChars travels alone so the loop always makes progress.
+ */
+export function takeChunk(entries: string[], chunkChars: number): string[] {
+  const batch: string[] = [];
+  let length = 0;
+  for (const entry of entries) {
+    const entryLength = entry.length + ENTRY_DELIMITER.length;
+    if (batch.length > 0 && length + entryLength > chunkChars) break;
+    batch.push(entry);
+    length += entryLength;
+  }
+  return batch;
 }
 
 export async function triggerConsolidation(
@@ -183,7 +326,7 @@ export async function triggerConsolidation(
   timeoutMs: number = DEFAULT_CONSOLIDATION_TIMEOUT_MS,
   toolTarget: ToolMemoryTarget = target,
   llmConfig: ConsolidationLlmConfig = {},
-  directCtx: Pick<ExtensionContext, "model" | "modelRegistry"> | null = null,
+  directCtx: DirectReviewContext | null = null,
   dbManager: DatabaseManager | null = null,
   projectName?: string | null,
   deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
@@ -191,9 +334,12 @@ export async function triggerConsolidation(
   const entries = entriesForTarget(store, target);
   const currentContent = entries.join(ENTRY_DELIMITER);
   const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
+  const usageSignals = loadUsageSignals(dbManager, llmConfig, target, toolTarget, projectName);
 
   if (directCtx && usesDirectTransport(llmConfig)) {
     try {
+      const directEntriesHeader = `--- Current ${labelForTarget(target, toolTarget)} Entries (target: '${toolTarget}') ---`;
+      const directSignalsSection = usageSignalsSectionText(usageSignals, entries);
       const directResult = await runDirect(
         directCtx,
         store,
@@ -201,8 +347,9 @@ export async function triggerConsolidation(
         {
           systemPrompt: DIRECT_CONSOLIDATION_SYSTEM_PROMPT,
           userPrompt: [
-            `--- Current ${labelForTarget(target, toolTarget)} Entries (target: '${toolTarget}') ---`,
+            directEntriesHeader,
             currentContent || "(empty)",
+            ...(directSignalsSection ? ["", directSignalsSection] : []),
             "",
             `Only emit operations with "target": "${toolTarget}".`,
           ].join("\n"),
@@ -221,60 +368,235 @@ export async function triggerConsolidation(
       if (directResult.ok && directResult.appliedCount > 0) {
         return { consolidated: true };
       }
+      // An empty completion is terminal (#235): the direct model answered
+      // with nothing in either channel, so the subprocess child would run
+      // the same model against the same server-side thinking default and
+      // fail the same way (#197). The success criterion is unchanged — it
+      // must actually shrink — but this case reports instead of acquiring
+      // the consolidation lock and spawning the child.
+      if (directResult.ok && directResult.fallbackReason === "empty_response") {
+        const modelRef = directCtx.model?.provider
+          ? `${directCtx.model.provider}/${directCtx.model.id}`
+          : "model";
+        return {
+          consolidated: false,
+          error: `${modelRef} returned an empty completion; no consolidation attempted`,
+        };
+      }
     } catch {
       // Fall through to subprocess below.
     }
   }
 
-  let lock: ConsolidationLock | null = null;
+    const chunkChars = chunkCharsFor(llmConfig);
+    const chunkingEnabled = llmConfig.consolidationChunking === true;
+    const hasUsage = typeof (store as any).capacityUsage === "function";
+    const usageOf = (list: string[]): number =>
+      hasUsage ? (store as any).capacityUsage(target) : list.join(ENTRY_DELIMITER).length;
+    const goal = typeof store.capacityGoal === "function" ? store.capacityGoal(target) : chunkChars;
 
-  try {
-    const attempt = await acquireConsolidationLock(store, target, toolTarget);
-    lock = attempt.lock;
-    if (!lock) {
-      // Not a failure: the work is already running in another session. Say so
-      // plainly so the memory-write path can ask for a retry instead of
-      // reporting a broken consolidation mid-task (#144).
-      return {
-        consolidated: false,
-        deferred: true,
-        error: `Consolidation already in progress for target '${toolTarget}' in another session`
-          + ` (waited ${attempt.waitedMs}ms). Nothing was consolidated here — retry shortly.`,
-      };
-    }
+    let lock: ConsolidationLock | null = null;
 
-    let promptEntries = entries;
-    if (attempt.contended) {
-      // We queued behind another session's consolidation and it has now
-      // finished. If it already freed space, running a second LLM pass here
-      // costs a child turn and over-compresses memory for nothing — hand the
-      // caller a reload-and-retry instead.
-      try {
-        await store.loadFromDisk();
-        const refreshed = entriesForTarget(store, target);
-        if (refreshed.join(ENTRY_DELIMITER).length < currentContent.length) {
+    try {
+      const attempt = await acquireConsolidationLock(store, target, toolTarget);
+      lock = attempt.lock;
+      if (!lock) {
+        // Not a failure: the work is already running in another session. Say so
+        // plainly so the memory-write path can ask for a retry instead of
+        // reporting a broken consolidation mid-task (#144).
+        return {
+          consolidated: false,
+          deferred: true,
+          error: `Consolidation already in progress for target '${toolTarget}' in another session — nothing was consolidated here; retry shortly.`,
+        };
+      }
+
+      let promptEntries = entries;
+      if (attempt.contended) {
+        // We queued behind another session's consolidation and it has now
+        // finished. If it already freed space, running a second LLM pass here
+        // costs a child turn and over-compresses memory for nothing — hand the
+        // caller a reload-and-retry instead.
+        try {
+          await store.loadFromDisk();
+          const refreshed = entriesForTarget(store, target);
+          if (refreshed.join(ENTRY_DELIMITER).length < currentContent.length) {
+            return { consolidated: true };
+          }
+          promptEntries = refreshed;
+        } catch {
+          // Reload failed — consolidate the entries we already read instead.
+        }
+      }
+
+      if (!chunkingEnabled) {
+        // Legacy single-shot path — the flag default. Byte-identical to
+        // pre-chunking releases for stores of any size (usage signals are the
+        // one additive prompt section, and only once tracking data exists).
+        // When an oversized store times out, the error below names the remedy
+        // keys so the failure teaches the fix.
+        const result = await execChildPrompt(pi, buildConsolidationPrompt(target, toolTarget, promptEntries, false, usageSignals), llmConfig, {
+          signal,
+          timeoutMs,
+          retryWithoutOverrides: true,
+        }) as { code: number; stdout?: string; stderr?: string; killed?: boolean };
+
+        if (result.code === 0) {
           return { consolidated: true };
         }
-        promptEntries = refreshed;
-      } catch {
-        // Reload failed — consolidate the entries we already read instead.
+        let error = describeConsolidationFailure(result, timeoutMs);
+        const terminated = result.killed || result.code === 124 || result.code === 143;
+        if (terminated && promptEntries.join(ENTRY_DELIMITER).length > chunkChars) {
+          error += ` This store exceeds consolidationChunkChars (${chunkChars}) — enabling consolidationChunking splits consolidation into bounded rounds.`;
+        }
+        return { consolidated: false, error };
       }
-    }
 
-    const result = await execChildPrompt(pi, buildConsolidationPrompt(target, toolTarget, promptEntries), llmConfig, {
-      signal,
-      timeoutMs,
-      retryWithoutOverrides: true,
-    }) as { code: number; stdout?: string; stderr?: string; killed?: boolean };
+      if (promptEntries.length === 0 || usageOf(promptEntries) <= goal) {
+        // Within the target's capacity goal (encoded units, same as the cap):
+        // nothing needs to shrink toward the goal — a clean no-op, not a
+        // failure. Covers healthy stores of any size, the failure tier, and
+        // manual triggers on stores that do not need consolidation.
+        return { consolidated: true, rounds: 0 };
+      }
 
-    if (result.code === 0) {
-      return { consolidated: true };
-    }
-    return {
-      consolidated: false,
-      error: describeConsolidationFailure(result, timeoutMs),
-    };
-} catch (err) {
+      const deadline = Date.now() + timeoutMs;
+
+      // Chunked path — the store exceeds one child run's prompt budget, and a
+      // single whole-store LLM merge is what produced the observed "subprocess
+      // terminated (likely timeout)" failures at cap scale. Rounds share the
+      // overall budget (deadline): each consolidates a slice, then reloads from
+      // disk (the child modified files) and re-evaluates. A store that fits one
+      // prompt runs a single UNSCOPED decisive round — the legacy single-shot
+      // call, same prompt, same timeout, one invocation. Resume needs no
+      // cursor: partial progress is already on disk.
+      let completedRounds = 0;
+      let progressRounds = 0;
+      const notes: string[] = [];
+      let offset = 0;
+
+      while (completedRounds < MAX_CONSOLIDATION_ROUNDS) {
+        if (promptEntries.length === 0) break; // everything merged away
+        const promptTotal = promptEntries.join(ENTRY_DELIMITER).length;
+        if (promptTotal <= chunkChars && usageOf(promptEntries) <= goal) break; // capacity goal met
+        if (signal?.aborted) {
+          notes.push("aborted between consolidation rounds");
+          break;
+        }
+        const remaining = deadline - Date.now();
+        if (remaining < MIN_ROUND_MS) {
+          notes.push(`consolidation time budget (${timeoutMs}ms) exhausted; retrigger consolidation to continue from current state`);
+          break;
+        }
+
+        // Removals in earlier rounds shift indices left; the walk offset may
+        // point past the (now shorter) store — wrap it instead of slicing an
+        // empty batch.
+        if (offset >= promptEntries.length) offset = 0;
+
+        const fitsOneChunk = promptTotal <= chunkChars;
+        const usageBefore = usageOf(promptEntries);
+        const batch = fitsOneChunk
+          ? promptEntries // decisive round: whole remaining store, full context
+          : takeChunk(promptEntries.slice(offset), chunkChars);
+        const batchSet = new Set(batch);
+        const beforeRound = promptEntries;
+        const result = await execChildPrompt(pi, buildConsolidationPrompt(target, toolTarget, batch, !fitsOneChunk, usageSignals), llmConfig, {
+          signal,
+          timeoutMs: Math.min(timeoutMs, remaining),
+          retryWithoutOverrides: true,
+        }) as { code: number; stdout?: string; stderr?: string; killed?: boolean };
+
+        // Reload FIRST — even a failed round may have shrunk the store before
+        // dying, and the recount below decides how the failure is reported.
+        try {
+          await store.loadFromDisk();
+          promptEntries = entriesForTarget(store, target);
+        } catch {
+          notes.push("could not reload memory after a consolidation round");
+          break;
+        }
+
+        const currentRound = completedRounds + 1;
+
+        // Out-of-scope changes: entries that vanished this round without being
+        // part of the presented slice. The child can see the whole store through
+        // its tools, and a concurrent session may delete entries in this window
+        // too — the parent cannot tell a rogue deletion from a legitimate
+        // cross-slice dedup or a concurrent one, so out-of-scope disappearances
+        // are REPORTED, never resurrected (resurrection would fight legitimate
+        // dedup and ping-pong across triggers; the store's recovery snapshots
+        // remain the repair path for real damage).
+        const outOfScope = beforeRound.filter(
+          (entry) => !batchSet.has(entry) && !promptEntries.includes(entry),
+        );
+        if (outOfScope.length > 0) {
+          notes.push(`round ${currentRound} coincided with ${outOfScope.length} out-of-scope entr${outOfScope.length === 1 ? "y" : "ies"} disappearing (by the child or a concurrent writer) — inspect memory if that was not intended`);
+        }
+
+        const usageAfter = usageOf(promptEntries);
+        const shrank = usageAfter < usageBefore;
+
+        if (result.code !== 0) {
+          if (shrank) {
+            // The round shrank the store and THEN died (killed mid-merge). The
+            // shrink is real and on disk — report it as partial progress instead
+            // of a total failure, and let the next trigger resume.
+            progressRounds++;
+            notes.push(describeConsolidationFailure(result, Math.min(timeoutMs, remaining))
+              + ` The failing round still shrank the store by ${usageBefore - usageAfter} chars; retrigger consolidation to continue.`);
+          } else {
+            notes.push(describeConsolidationFailure(result, Math.min(timeoutMs, remaining))
+              + (completedRounds > 0
+                ? ` ${completedRounds} earlier round${completedRounds === 1 ? "" : "s"} shrank the store; retrigger consolidation to continue.`
+                : ""));
+          }
+          break;
+        }
+
+        completedRounds++;
+
+        if (!shrank) {
+          // This round shrank nothing. Walk to the next slice rather than
+          // repeating it; when nothing in the walk yields, the round-cap exit
+          // below reports the store as still over its goal.
+          if (fitsOneChunk) {
+            notes.push(`consolidation could not shrink the remaining ${promptTotal} chars (capacity goal ${goal}); entries may be distinct facts worth keeping — consider manual pruning`);
+            break;
+          }
+          offset = (offset + batch.length) % Math.max(promptEntries.length, 1);
+          continue;
+        }
+
+        progressRounds++;
+        // Progress: keep walking forward past the slice this round consumed
+        // (removals shift indices left, so this is approximate) — resetting to
+        // the top would let a store whose head always yields a little progress
+        // starve the tail forever.
+        offset = (offset + batch.length) % Math.max(promptEntries.length, 1);
+        if (usageAfter <= goal) break; // capacity goal met
+        if (fitsOneChunk) break; // decisive round done; the next trigger starts a fresh pass
+      }
+
+      if (progressRounds > 0) {
+        const roundNotes = [...notes];
+        const usageEnd = usageOf(promptEntries);
+        if (usageEnd > goal) {
+          roundNotes.push(`store still ${usageEnd - goal} chars over its ${goal}-char capacity goal; entries may be distinct facts worth keeping — consider manual pruning or raising the limit`);
+        }
+        return {
+          consolidated: true,
+          partial: roundNotes.length > 0,
+          rounds: completedRounds,
+          ...(roundNotes.length ? { error: roundNotes.join("; ") } : {}),
+        };
+      }
+      notes.push(`consolidation could not shrink the store toward its ${goal}-char capacity goal (${usageOf(promptEntries)} chars); entries may be distinct facts worth keeping — consider manual pruning or raising the limit`);
+      return {
+        consolidated: false,
+        error: notes.join("; "),
+      };
+  } catch (err) {
     const message = String(err);
     if (message.includes("extension ctx is stale")) {
       // Session replaced/reloaded while consolidation was running. The new
@@ -391,7 +713,9 @@ export function registerConsolidateCommand(
 
           if (result.consolidated) {
             await item.store.loadFromDisk();
-            results.push(`${item.label}: ✅ consolidated`);
+            const roundsNote = result.rounds ? ` (${result.rounds} round${result.rounds === 1 ? "" : "s"})` : "";
+            const partialNote = result.partial ? ` ⚠️ partial: ${result.error ?? "incomplete"}` : "";
+            results.push(`${item.label}: ✅ consolidated${roundsNote}${partialNote}`);
           } else {
             results.push(`${item.label}: ❌ ${result.error}`);
           }

package/dist/extensions/pi-hermes-memory/src/handlers/background-review.ts

@@ -16,12 +16,14 @@ import {
 import { MemoryStore } from "../store/memory-store.js";
 import { DatabaseManager } from "../store/db.js";
 import type { MemoryConfig } from "../types.js";
+import type { EnsureMemoryReady } from "../memory-initialization.js";
 import { applyRecentMessageLimit, collectMessageParts } from "./message-parts.js";
 import { execChildPrompt, resolveChildPiModel } from "./pi-child-process.js";
-import { runDirectMemoryCompletion, usesDirectTransport, type DirectReviewResult } from "./review-memory-ops.js";
+import { REVIEW_COMPLETION_TIMEOUT_MS, runDirectMemoryCompletion, usesDirectTransport, type DirectReviewResult } from "./review-memory-ops.js";
 
 import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
 export interface BackgroundReviewOptions {
+  ensureMemoryReady?: EnsureMemoryReady;
   dbManager?: DatabaseManager | null;
   projectName?: ProjectNameRef;
   deps?: BackgroundReviewDeps;
@@ -149,7 +151,7 @@ async function runSubprocessReview(
     // Session-scoped signal only. The turn signal belongs to the interactive
     // agent run; forwarding it cancels unrelated review on a later user abort.
     signal,
-    timeoutMs: 120000,
+    timeoutMs: REVIEW_COMPLETION_TIMEOUT_MS,
   });
 }
 
@@ -253,6 +255,7 @@ export function setupBackgroundReview(
         return;
       }
       if (allParts.length < 4) return;
+      await options.ensureMemoryReady?.(ctx);
       if (sessionCancelled()) return;
 
       const parts = applyRecentMessageLimit(allParts, config.reviewRecentMessages);
@@ -272,7 +275,7 @@ export function setupBackgroundReview(
       if (usesDirectTransport(config)) {
         try {
           const directResult = await runDirectReview(
-            ctx as Pick<ExtensionContext, "model" | "modelRegistry">,
+            ctx,
             store,
             activeProjectStore,
             {
@@ -283,7 +286,7 @@ export function setupBackgroundReview(
                 buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
               ].join("\n"),
               config,
-              timeoutMs: 120000,
+              timeoutMs: REVIEW_COMPLETION_TIMEOUT_MS,
               signal: sessionAbort.signal,
             },
             dbManager,

package/dist/extensions/pi-hermes-memory/src/handlers/correction-detector.ts

@@ -22,6 +22,7 @@ import {
   ENTRY_DELIMITER,
 } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
+import type { EnsureMemoryReady } from "../memory-initialization.js";
 import { getMessageText } from "../types.js";
 import { execChildPrompt, resolveChildPiModel } from "./pi-child-process.js";
 import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
@@ -129,11 +130,11 @@ export function setupCorrectionDetector(
   config: MemoryConfig,
   dbManager: DatabaseManager | null = null,
   projectName: ProjectNameRef = null,
-  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
+  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion; ensureMemoryReady?: EnsureMemoryReady } = {},
 ): void {
   if (!config.correctionDetection) return;
 
-  let pendingCorrection = false;
+  let pendingCorrection: string | undefined;
   let turnsSinceLastCorrection = 3; // Start at threshold so first correction can fire immediately
   let correctionInProgress = false;
   const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
@@ -144,7 +145,7 @@ export function setupCorrectionDetector(
     const text = getMessageText(event.message);
     if (!text) return;
     if (isCorrection(text, config)) {
-      pendingCorrection = true;
+      pendingCorrection = text;
     }
   });
 
@@ -154,16 +155,25 @@ export function setupCorrectionDetector(
       turnsSinceLastCorrection++;
       return;
     }
-    pendingCorrection = false;
+    if (correctionInProgress) return;
+    const correctionText = pendingCorrection;
+    pendingCorrection = undefined;
 
     // Rate limit: max 1 correction save per 3 turns
     if (turnsSinceLastCorrection < 3) return;
-    if (correctionInProgress) return;
 
-    turnsSinceLastCorrection = 0;
     correctionInProgress = true;
 
     try {
+      try {
+        await deps.ensureMemoryReady?.(ctx, ctx.signal);
+      } catch {
+        // Keep the correction eligible for the next turn after a transient load
+        // failure, without consuming the successful-capture rate limit.
+        pendingCorrection ??= correctionText;
+        return;
+      }
+      turnsSinceLastCorrection = 0;
       // Build conversation snapshot
       const entries = ctx.sessionManager.getBranch();
       const parts: string[] = [];
@@ -203,6 +213,9 @@ export function setupCorrectionDetector(
       }
 
       promptBody.push(
+        "",
+        "--- User Correction to Save ---",
+        correctionText,
         "",
         "--- Recent Conversation ---",
         recentParts.join("\n\n"),
@@ -270,14 +283,6 @@ export function setupCorrectionDetector(
 
       // Also save as a failure memory for learning
       try {
-        let lastUserMsg: string | undefined;
-        for (let i = recentParts.length - 1; i >= 0; i--) {
-          if (recentParts[i].startsWith("[USER]")) {
-            lastUserMsg = recentParts[i];
-            break;
-          }
-        }
-        const correctionText = lastUserMsg ? lastUserMsg.replace(/^\[USER\]:\s*/, "") : "";
         if (correctionText) {
           const directive = extractCorrectionDirective(correctionText);
           const failureReason = "User corrected the agent";