@selesai/code 0.13.15 → 0.13.18

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

@@ -22,6 +22,7 @@ export interface ApplyReviewOperationsResult {
   appliedCount: number;
   skippedCount: number;
   error?: string;
+  aborted?: boolean;
 }
 
 export interface DirectReviewResult {
@@ -34,7 +35,7 @@ export interface DirectReviewResult {
 export interface RunDirectMemoryCompletionOptions {
   userPrompt: string;
   systemPrompt: string;
-  config: Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride">;
+  config: Pick<MemoryConfig, "llmModelOverride" | "llmFallbackModels" | "llmThinkingOverride">;
   timeoutMs?: number;
   signal?: AbortSignal;
   requireAtomicShrink?: boolean;
@@ -48,7 +49,7 @@ export function usesDirectTransport(config: Pick<MemoryConfig, "reviewTransport"
   return (config.reviewTransport ?? "direct") === "direct";
 }
 
-type ReviewLlmConfig = Pick<MemoryConfig, "llmModelOverride" | "llmThinkingOverride">;
+type ReviewLlmConfig = Pick<MemoryConfig, "llmModelOverride" | "llmFallbackModels" | "llmThinkingOverride">;
 
 function findExactModelReferenceMatch(modelReference: string, availableModels: Model<Api>[]): Model<Api> | undefined {
   const trimmedReference = modelReference.trim();
@@ -83,6 +84,22 @@ function normalizedModelOverride(config: ReviewLlmConfig): string | undefined {
   return trimmed ? trimmed : undefined;
 }
 
+function collectFallbackOverrides(config: ReviewLlmConfig): string[] {
+  const out: string[] = [];
+  for (const raw of config.llmFallbackModels ?? []) {
+    const t = raw.trim();
+    if (t) out.push(t);
+  }
+  return out;
+}
+
+function allModelOverrides(config: ReviewLlmConfig): string[] {
+  const primary = normalizedModelOverride(config);
+  const fallbacks = collectFallbackOverrides(config);
+  const chain = primary ? [primary, ...fallbacks] : fallbacks;
+  return [...new Set(chain)];
+}
+
 function effectiveThinkingOverride(config: ReviewLlmConfig): ThinkingLevel | undefined {
   return config.llmThinkingOverride ?? (normalizedModelOverride(config) ? "off" : undefined);
 }
@@ -92,7 +109,7 @@ type ReviewModelRegistry = ExtensionContext["modelRegistry"];
 /** Derived from the installed SDK so headers/baseUrl track ProviderHeaders instead of a local mirror. */
 export type ResolvedRequestAuth = Awaited<ReturnType<ReviewModelRegistry["getApiKeyAndHeaders"]>>;
 
-type DirectReviewAuth = Omit<Extract<ResolvedRequestAuth, { ok: true }>, "ok"> & { apiKey: string };
+type DirectReviewAuth = Omit<Extract<ResolvedRequestAuth, { ok: true }>, "ok">;
 
 export function buildDirectReviewCompletionOptions(
   model: Model<Api>,
@@ -125,6 +142,28 @@ export function resolveReviewModel(
   return ctxModel;
 }
 
+export function resolveReviewModels(
+  ctxModel: Model<Api> | undefined,
+  modelRegistry: ReviewModelRegistry,
+  config: ReviewLlmConfig,
+): Model<Api>[] {
+  const chain = allModelOverrides(config);
+  if (chain.length === 0) return ctxModel ? [ctxModel] : [];
+  const all = modelRegistry.getAll();
+  const resolved: Model<Api>[] = [];
+  for (const ref of chain) {
+    const m = findExactModelReferenceMatch(ref, all);
+    if (m) resolved.push(m);
+  }
+  // If none of the chain resolved, fall back to active model so we still try something
+  if (resolved.length === 0 && ctxModel) resolved.push(ctxModel);
+  return resolved;
+}
+
+export function getReviewModelChain(config: ReviewLlmConfig): string[] {
+  return allModelOverrides(config);
+}
+
 /**
  * Provider responses that mean "this key is no longer good", as opposed to a
  * transport hiccup or a model error worth falling back to a subprocess for.
@@ -143,6 +182,54 @@ export function isAuthRejection(message: string): boolean {
   return AUTH_REJECTION_PATTERN.test(message);
 }
 
+const CREDENTIAL_HEADER_NAMES = new Set(["authorization", "x-api-key", "cf-aig-authorization"]);
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function hasRequestAuth(auth: DirectReviewAuth): boolean {
+  if (isNonEmptyString(auth.apiKey)) return true;
+  return Object.entries(auth.headers ?? {}).some(
+    ([key, value]) => CREDENTIAL_HEADER_NAMES.has(key.toLowerCase()) && isNonEmptyString(value),
+  );
+}
+
+function sameStringRecord(
+  left: Record<string, string> | undefined,
+  right: Record<string, string> | undefined,
+): boolean {
+  const leftEntries = Object.entries(left ?? {});
+  const rightKeys = Object.keys(right ?? {});
+  return leftEntries.length === rightKeys.length
+    && leftEntries.every(([key, value]) => right?.[key] === value);
+}
+
+function headerPairs(headers: DirectReviewAuth["headers"]): Array<[string, string | null]> {
+  return Object.entries(headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]);
+}
+
+function sameHeaders(
+  left: DirectReviewAuth["headers"],
+  right: DirectReviewAuth["headers"],
+): boolean {
+  const remaining = headerPairs(right);
+  const leftPairs = headerPairs(left);
+  if (leftPairs.length !== remaining.length) return false;
+  for (const [key, value] of leftPairs) {
+    const index = remaining.findIndex((pair) => pair[0] === key && pair[1] === value);
+    if (index === -1) return false;
+    remaining.splice(index, 1);
+  }
+  return true;
+}
+
+function sameRequestAuth(left: DirectReviewAuth, right: DirectReviewAuth): boolean {
+  return left.apiKey === right.apiKey
+    && sameHeaders(left.headers, right.headers)
+    && sameStringRecord(left.env, right.env);
+}
+
 /**
  * Resolve request auth through the public ModelRegistry API. Resolve it again
  * after an auth rejection so Pi can supply refreshed credentials when its
@@ -246,6 +333,7 @@ export async function applyReviewOperations(
   options: {
     requireAtomicShrink?: boolean;
     expectedTarget?: ReviewMemoryOperation["target"];
+    signal?: AbortSignal;
   } = {},
 ): Promise<ApplyReviewOperationsResult> {
   if (options.requireAtomicShrink) {
@@ -280,6 +368,9 @@ export async function applyReviewOperations(
       };
     }
 
+    if (options.signal?.aborted) {
+      return { appliedCount: 0, skippedCount: operations.length, aborted: true };
+    }
     const activeStore = target === "project" ? projectStore! : store;
     const memoryTarget = target === "project" ? "memory" : target;
     const mutationOperations = operations.map((operation) => ({
@@ -290,7 +381,13 @@ export async function applyReviewOperations(
       failureReason: operation.failure_reason,
       project: target === "failure" ? projectName ?? undefined : undefined,
     }));
-    const result = await activeStore.applyMutationPlan(memoryTarget, mutationOperations, { requireShrink: true });
+    const result = await activeStore.applyMutationPlan(memoryTarget, mutationOperations, {
+      requireShrink: true,
+      signal: options.signal,
+    });
+    if (options.signal?.aborted && !result.success) {
+      return { appliedCount: 0, skippedCount: operations.length, aborted: true };
+    }
     return result.success
       ? { appliedCount: operations.length, skippedCount: 0 }
       : {
@@ -303,7 +400,12 @@ export async function applyReviewOperations(
   let appliedCount = 0;
   let skippedCount = 0;
 
-  for (const op of operations) {
+  for (let i = 0; i < operations.length; i++) {
+    if (options.signal?.aborted) {
+      skippedCount += operations.length - i;
+      return { appliedCount, skippedCount, aborted: appliedCount === 0 };
+    }
+    const op = operations[i];
     if (op.target === "project" && !projectStore) {
       skippedCount++;
       continue;
@@ -326,6 +428,7 @@ export async function applyReviewOperations(
             category,
             failureReason: op.failure_reason,
             project: projectName ?? undefined,
+            signal: options.signal,
           });
           if (result.success) {
             appliedCount++;
@@ -333,7 +436,7 @@ export async function applyReviewOperations(
             skippedCount++;
           }
         } else {
-          result = await activeStore.add(memoryTarget, op.content);
+          result = await activeStore.add(memoryTarget, op.content, options.signal);
           if (result.success) {
             appliedCount++;
           } else {
@@ -347,7 +450,7 @@ export async function applyReviewOperations(
           skippedCount++;
           continue;
         }
-        result = await activeStore.replace(memoryTarget, op.old_text, op.content);
+        result = await activeStore.replace(memoryTarget, op.old_text, op.content, options.signal);
         if (result.success) {
           appliedCount++;
         } else {
@@ -360,7 +463,7 @@ export async function applyReviewOperations(
           skippedCount++;
           continue;
         }
-        result = await activeStore.remove(memoryTarget, op.old_text);
+        result = await activeStore.remove(memoryTarget, op.old_text, options.signal);
         if (result.success) {
           appliedCount++;
         } else {
@@ -373,6 +476,10 @@ export async function applyReviewOperations(
         continue;
     }
 
+    if (options.signal?.aborted) {
+      skippedCount += operations.length - i - 1;
+      return { appliedCount, skippedCount, aborted: appliedCount === 0 };
+    }
   }
 
   return { appliedCount, skippedCount };
@@ -398,109 +505,161 @@ export async function runDirectMemoryCompletion(
   deps: { completeSimple?: typeof completeSimple } = {},
 ): Promise<DirectReviewResult> {
   const complete = deps.completeSimple ?? completeSimple;
-  const model = resolveReviewModel(ctx.model, ctx.modelRegistry, options.config);
-  if (!model) {
-    return { ok: false, appliedCount: 0, fallbackReason: "no_model" };
-  }
+  const aborted = (): DirectReviewResult => ({ ok: false, appliedCount: 0, fallbackReason: "aborted" });
+  if (options.signal?.aborted) return aborted();
 
-  const auth = await resolveRequestAuth(ctx.modelRegistry, model);
-  if (!auth.ok || !auth.apiKey) {
-    return {
-      ok: false,
-      appliedCount: 0,
-      fallbackReason: "no_auth",
-      error: auth.ok ? `No API key for ${model.provider}` : auth.error,
-    };
+  const models = resolveReviewModels(ctx.model, ctx.modelRegistry, options.config);
+  if (models.length === 0) {
+    return { ok: false, appliedCount: 0, fallbackReason: "no_model" };
   }
-  let requestAuth: DirectReviewAuth = { apiKey: auth.apiKey, headers: auth.headers, env: auth.env };
 
-  const controller = new AbortController();
-  const timeoutMs = options.timeoutMs ?? 120000;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  if (options.signal) {
-    options.signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
+  // Try each model in chain: primary + llmFallbackModels. Only retry on
+  // provider/auth/transport failures; parse errors are prompt-specific so we
+  // still try the next model as it may have better instruction following.
+  let lastResult: DirectReviewResult | undefined;
+  for (let mi = 0; mi < models.length; mi++) {
+    const model = models[mi]!;
+    // A caller abort (user cancel, shutdown bound) ends the whole chain: the
+    // next iteration's listener would never fire for an already-aborted
+    // signal, so continuing would burn a full timeout per remaining model.
+    if (options.signal?.aborted) return aborted();
+    const auth = await resolveRequestAuth(ctx.modelRegistry, model);
+    if (options.signal?.aborted) return aborted();
+    if (!auth.ok || !hasRequestAuth(auth)) {
+      lastResult = {
+        ok: false,
+        appliedCount: 0,
+        fallbackReason: "no_auth",
+        error: auth.ok ? `No request authentication for ${model.provider}` : auth.error,
+      };
+      if (mi < models.length - 1) continue;
+      return lastResult;
+    }
+    let requestAuth: DirectReviewAuth = { apiKey: auth.apiKey, headers: auth.headers, env: auth.env };
+
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? 120000;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const onExternalAbort = () => controller.abort();
+    if (options.signal) {
+      options.signal.addEventListener("abort", onExternalAbort, { once: true });
+      if (options.signal.aborted) controller.abort();
+    }
 
-  const thinking = effectiveThinkingOverride(options.config);
-  const userMessage: Message = {
-    role: "user",
-    content: [{ type: "text", text: options.userPrompt }],
-    timestamp: Date.now(),
-  };
+    const thinking = effectiveThinkingOverride(options.config);
+    const userMessage: Message = {
+      role: "user",
+      content: [{ type: "text", text: options.userPrompt }],
+      timestamp: Date.now(),
+    };
 
-  const request = { systemPrompt: options.systemPrompt, messages: [userMessage] };
+    const request = { systemPrompt: options.systemPrompt, messages: [userMessage] };
 
-  try {
-    let response;
-    try {
-      response = await complete(
+    const completeOnce = async () => {
+      const response = await complete(
         model,
         request,
         buildDirectReviewCompletionOptions(model, requestAuth, thinking, controller.signal),
       );
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (controller.signal.aborted || !isAuthRejection(message)) throw err;
-
-      // The provider rejected the key mid-flight. A rotation tool may have
-      // re-resolve through Pi and retry once only if it returns a different
-      // key; otherwise this is a real auth problem and the subprocess
-      // fallback should handle it (#139).
-      const rotated = await resolveRequestAuth(ctx.modelRegistry, model);
-      if (!rotated.ok || !rotated.apiKey || rotated.apiKey === requestAuth.apiKey) throw err;
-
-      requestAuth = { apiKey: rotated.apiKey, headers: rotated.headers, env: rotated.env };
-      response = await complete(
-        model,
-        request,
-        buildDirectReviewCompletionOptions(model, requestAuth, thinking, controller.signal),
-      );
-    }
+      if (response.stopReason === "error" && isAuthRejection(response.errorMessage ?? "")) {
+        throw new Error(response.errorMessage ?? "error");
+      }
+      return response;
+    };
 
-    if (response.stopReason === "aborted") {
-      return { ok: false, appliedCount: 0, fallbackReason: "aborted" };
-    }
+    try {
+      let response;
+      try {
+        response = await completeOnce();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (controller.signal.aborted || !isAuthRejection(message)) throw err;
+
+        // Thrown failures and error assistant responses share this path. API keys
+        // and OAuth headers can both rotate, so re-resolve through Pi and retry
+        // once only when the effective request auth actually changed; otherwise
+        // this is a real auth problem and the subprocess fallback should handle
+        // it (#139).
+        const rotated = await resolveRequestAuth(ctx.modelRegistry, model);
+        if (!rotated.ok || !hasRequestAuth(rotated) || sameRequestAuth(rotated, requestAuth)) throw err;
+
+        requestAuth = { apiKey: rotated.apiKey, headers: rotated.headers, env: rotated.env };
+        response = await completeOnce();
+      }
 
-    const text = responseText(response.content);
-    const operations = parseReviewOperations(text);
-    if (operations === null) {
-      return { ok: false, appliedCount: 0, fallbackReason: "parse_error" };
-    }
-    if (operations.length === 0) {
-      return { ok: true, appliedCount: 0, fallbackReason: "empty" };
-    }
+      if (options.signal?.aborted) {
+        clearTimeout(timeout);
+        return aborted();
+      }
+      if (response.stopReason === "aborted" || controller.signal.aborted) {
+        lastResult = { ok: false, appliedCount: 0, fallbackReason: "aborted" };
+        if (mi < models.length - 1) { clearTimeout(timeout); continue; }
+        return lastResult;
+      }
 
-    const applied = await applyReviewOperations(
-      store,
-      projectStore,
-      operations,
-      dbManager,
-      projectName,
-      {
-        requireAtomicShrink: options.requireAtomicShrink,
-        expectedTarget: options.expectedTarget,
-      },
-    );
-    if (applied.error) {
-      return {
-        ok: false,
-        appliedCount: 0,
-        fallbackReason: "provider_error",
-        error: applied.error,
-      };
-    }
-    return { ok: true, appliedCount: applied.appliedCount };
-  } catch (err) {
-    if (controller.signal.aborted) {
-      return { ok: false, appliedCount: 0, fallbackReason: "aborted" };
+      const text = responseText(response.content);
+      const operations = parseReviewOperations(text);
+      if (operations === null) {
+        lastResult = { ok: false, appliedCount: 0, fallbackReason: "parse_error" };
+        if (mi < models.length - 1) { clearTimeout(timeout); continue; }
+        return lastResult;
+      }
+      if (operations.length === 0) {
+        clearTimeout(timeout);
+        return { ok: true, appliedCount: 0, fallbackReason: "empty" };
+      }
+      if (controller.signal.aborted || options.signal?.aborted) {
+        return aborted();
+      }
+
+      const applied = await applyReviewOperations(
+        store,
+        projectStore,
+        operations,
+        dbManager,
+        projectName,
+        {
+          requireAtomicShrink: options.requireAtomicShrink,
+          expectedTarget: options.expectedTarget,
+          signal: options.signal,
+        },
+      );
+      if (applied.aborted && applied.appliedCount === 0) {
+        return aborted();
+      }
+      if (applied.error) {
+        lastResult = {
+          ok: false,
+          appliedCount: 0,
+          fallbackReason: "provider_error",
+          error: applied.error,
+        };
+        if (mi < models.length - 1) { clearTimeout(timeout); continue; }
+        return lastResult;
+      }
+      clearTimeout(timeout);
+      return { ok: true, appliedCount: applied.appliedCount };
+    } catch (err) {
+      if (options.signal?.aborted) {
+        clearTimeout(timeout);
+        return aborted();
+      }
+      if (controller.signal.aborted) {
+        lastResult = { ok: false, appliedCount: 0, fallbackReason: "aborted" };
+      } else {
+        lastResult = {
+          ok: false,
+          appliedCount: 0,
+          fallbackReason: "provider_error",
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+      if (mi < models.length - 1) { clearTimeout(timeout); continue; }
+      return lastResult!;
+    } finally {
+      clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onExternalAbort);
     }
-    return {
-      ok: false,
-      appliedCount: 0,
-      fallbackReason: "provider_error",
-      error: err instanceof Error ? err.message : String(err),
-    };
-  } finally {
-    clearTimeout(timeout);
   }
+  return lastResult ?? { ok: false, appliedCount: 0, fallbackReason: "provider_error", error: "All fallback models failed" };
 }

package/dist/extensions/pi-hermes-memory/src/handlers/session-backfill.ts

@@ -33,6 +33,12 @@ export interface ScheduleSessionBackfillOptions {
   indexSessionsFn?: typeof indexChangedSessions;
   maxFilesToIndex?: number;
   touchBackfillTimestampFn?: typeof touchBackfillTimestamp;
+  /**
+   * Optional retention cutoff (ms epoch). Files older than this are excluded
+   * from the backfill file set so that sessions pruned by retention are not
+   * re-indexed and do not repeatedly schedule a startup backfill.
+   */
+  retentionCutoffMs?: number;
 }
 
 function formatBackfillResult(result: BulkIndexResult): string {
@@ -69,6 +75,7 @@ export function scheduleSessionBackfill(
   const indexSessionsFn = options.indexSessionsFn ?? indexChangedSessions;
   const maxFilesToIndex = options.maxFilesToIndex ?? SESSION_BACKFILL_MAX_FILES;
   const touchBackfillTimestampFn = options.touchBackfillTimestampFn ?? touchBackfillTimestamp;
+  const retentionCutoffMs = options.retentionCutoffMs ?? 0;
 
   if (state.inProgress) {
     return false;
@@ -77,7 +84,7 @@ export function scheduleSessionBackfill(
   try {
     if (!measureLifecycleSync(
       'session-backfill.check',
-      () => needsBackfillFn(dbManager, sessionsDir),
+      () => needsBackfillFn(dbManager, sessionsDir, undefined, retentionCutoffMs),
     )) {
       return false;
     }
@@ -95,7 +102,7 @@ export function scheduleSessionBackfill(
     setTimeoutFn(() => {
       measureLifecycleSync('session-backfill.callback', () => {
         try {
-          const result = indexSessionsFn(dbManager, sessionsDir, { maxFilesToIndex });
+          const result = indexSessionsFn(dbManager, sessionsDir, { maxFilesToIndex, retentionCutoffMs });
           if (!result.reachedLimit) touchBackfillTimestampFn(dbManager);
           notifyBestEffort(options.notify, formatBackfillResult(result), result.errors.length > 0 || result.reachedLimit ? 'warning' : 'info');
         } catch (err) {

package/dist/extensions/pi-hermes-memory/src/handlers/sync-markdown-memories.ts

@@ -165,6 +165,11 @@ export async function syncMarkdownMemoriesToSqlite(
         counters.imported += result.inserted;
         counters.skipped += result.existing;
         counters.removed += result.removed;
+        if (result.degraded) {
+          counters.warnings.push(
+            `${path.basename(project ?? 'global')}/${target}: FTS5 search index error (${result.degradedReason}); run /memory-sync-markdown to rebuild`,
+          );
+        }
       } catch (err) {
         counters.warnings.push(
           `${path.basename(project ?? 'global')}/${target}: ${err instanceof Error ? err.message : String(err)}`,

package/dist/extensions/pi-hermes-memory/src/index.ts

@@ -28,7 +28,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { MemoryStore } from "./store/memory-store.js";
 import { SkillStore } from "./store/skill-store.js";
 import { DatabaseManager } from "./store/db.js";
-import { indexSession, upsertSessionFileMetadata, pruneEphemeralReviewSessions } from "./store/session-indexer.js";
+import { indexSession, upsertSessionFileMetadata, pruneEphemeralReviewSessions, pruneOldSessions, retentionCutoffMs } from "./store/session-indexer.js";
 import { runRecoveryMaintenance } from "./store/recovery-maintenance.js";
 import { scheduleSessionBackfill, waitForSessionBackfill, SESSION_BACKFILL_SHUTDOWN_TIMEOUT_MS } from "./handlers/session-backfill.js";
 import { scheduleLiveSessionIndex, waitForLiveSessionIndex, SESSION_LIVE_INDEX_SHUTDOWN_TIMEOUT_MS } from "./handlers/session-live-index.js";
@@ -125,6 +125,7 @@ export default function (pi: ExtensionAPI) {
     migrationSentinelPath: path.join(globalDir, ".skills-migrated-to-extension-storage"),
   });
   const dbManager = new DatabaseManager(globalDir);
+  dbManager.setQuickCheckOnOpen(config.quickCheckOnOpen ?? true);
   let databaseMigrationPending = shouldMigrateExtensionRoot
     && isDatabaseMigrationPending(legacyGlobalDir, globalDir);
   if (databaseMigrationPending) {
@@ -226,6 +227,22 @@ export default function (pi: ExtensionAPI) {
       } catch (err) {
         console.warn(`⚠️ Ephemeral session cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
       }
+      // Prune sessions older than the configured retention window to bound the
+      // size of the session index database (see #183). Runs before
+      // scheduleSessionBackfill so pruned sessions are never re-indexed by a
+      // backfill started in the same startup.
+      if (config.sessionRetentionDays && config.sessionRetentionDays > 0) {
+        try {
+          const pruneResult = pruneOldSessions(dbManager, config.sessionRetentionDays);
+          if (pruneResult.sessionsRemoved > 0) {
+            console.info(
+              `🧠 Pruned ${pruneResult.sessionsRemoved} old session(s) (> ${config.sessionRetentionDays} days old)`,
+            );
+          }
+        } catch (err) {
+          console.warn(`⚠️ Session pruning failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
       try {
         await runRecoveryMaintenance({ config, globalDir });
       } catch (err) {
@@ -242,6 +259,9 @@ export default function (pi: ExtensionAPI) {
             console.info(message);
           }
         },
+        // Exclude files older than the retention cutoff so sessions pruned by
+        // retention are never re-indexed and never schedule another backfill.
+        retentionCutoffMs: retentionCutoffMs(config.sessionRetentionDays),
       });
     }
   });
@@ -334,7 +354,7 @@ export default function (pi: ExtensionAPI) {
   // ── 11. SQLite session search + extended memory ──
   registerSessionSearchTool(pi, dbManager, config.sessionSearch ?? { variant: "legacy" });
   registerMemorySearchTool(pi, dbManager);
-  registerIndexSessionsCommand(pi);
+  registerIndexSessionsCommand(pi, config);
 
   // ── 12. Auto-index session on shutdown ──
   // Registered last, so this runs after the session-flush shutdown handler and

package/dist/extensions/pi-hermes-memory/src/paths.ts

@@ -5,7 +5,7 @@ import { DEFAULT_PROJECTS_MEMORY_DIR } from "./constants.js";
 
 // Route through the host resolver only. The upstream `PI_CODING_AGENT_DIR`
 // env var is deliberately NOT honored here: on the Selesai fork it would
-// silently point memory at ~/.pi/agent while the host reads ~/.selesai/agent.
+// silently point memory at the upstream agent dir while the host reads ~/.selesai/agent.
 export const AGENT_ROOT = getAgentDir();
 
 export function expandHome(input: string): string {

package/dist/extensions/pi-hermes-memory/src/store/db.ts

@@ -164,6 +164,7 @@ export class DatabaseManager {
   private lastRecovery: DatabaseRecoveryResult | null = null;
   private openGuard: (() => void) | null = null;
   private pendingOpenIntegrityScan: Promise<void> | null = null;
+  private quickCheckOnOpen = true;
   private activeRecoveryLease: { coordinator: AtomicLockCoordinator; key: string; token: string } | null = null;
 
   constructor(memoryDir: string, recoveryOptions: DatabaseRecoveryOptions = {}) {
@@ -182,6 +183,10 @@ export class DatabaseManager {
     this.openGuard = guard;
   }
 
+  setQuickCheckOnOpen(enabled: boolean): void {
+    this.quickCheckOnOpen = enabled;
+  }
+
   /**
    * True when an error indicates SQLite file/page corruption rather than a
    * normal constraint, migration, or query failure.
@@ -304,6 +309,7 @@ export class DatabaseManager {
    * at operation time.
    */
   private scheduleOpenIntegrityScan(db: DatabaseLike): void {
+    if (!this.quickCheckOnOpen) return;
     if (this.pendingOpenIntegrityScan) return;
     const scan = new Promise<void>((resolve) => {
       setTimeout(() => {