@selesai/code 0.13.39 → 0.14.0

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

@@ -4,9 +4,70 @@
 
 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 { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
 
-export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore, projectStore: ProjectStoreRef, projectName: ProjectNameRef): void {
+/** Entries shown in the usage section's top-recalled list. */
+const USAGE_TOP_ENTRIES = 5;
+/** Character cap for entry excerpts in the usage section. */
+const USAGE_EXCERPT_CHARS = 70;
+
+interface UsageScopeStats {
+  total: number;
+  tracked: number;
+  top: Array<{ content: string; signal: MemoryUsageSignal }>;
+}
+
+function usageExcerpt(content: string): string {
+  const flat = content.replace(/\s+/g, " ").trim();
+  return flat.length > USAGE_EXCERPT_CHARS
+    ? `${flat.slice(0, USAGE_EXCERPT_CHARS - 3)}...`
+    : flat;
+}
+
+/**
+ * Recall stats for one store scope. Fail-open: a null dbManager or any lookup
+ * error renders the insights command without the usage section.
+ */
+function usageScopeStats(dbManager: DatabaseManager | null, target: "memory" | "user" | "failure", project: string | null): UsageScopeStats | null {
+  if (!dbManager) return null;
+  try {
+    const signals = getMemoryUsageSignals(dbManager, { target, project });
+    const total = (dbManager.getDb().prepare(
+      "SELECT COUNT(*) as count FROM memories WHERE target = ? AND project IS ?",
+    ).get(target, project) as { count: number | bigint }).count;
+    const top = [...signals.entries()]
+      .sort((a, b) => b[1].hits - a[1].hits)
+      .slice(0, USAGE_TOP_ENTRIES)
+      .map(([content, signal]) => ({ content, signal }));
+    const numTotal = typeof total === "bigint" ? Number(total) : total;
+    return { total: numTotal, tracked: signals.size, top };
+  } catch {
+    return null;
+  }
+}
+
+function renderUsageScope(label: string, stats: UsageScopeStats | null): string[] {
+  if (!stats || stats.total === 0) return [];
+  const lines = [`  🔍 USAGE — ${label}: ${stats.tracked} of ${stats.total} entries recalled via memory_search`];
+  if (stats.top.length === 0) {
+    lines.push("  (no recorded recalls yet — usage accrues as memory_search runs)");
+  } else {
+    stats.top.forEach((entry, i) => {
+      lines.push(`  ${i + 1}. ${entry.signal.hits}x (last ${entry.signal.lastHit}) — ${usageExcerpt(entry.content)}`);
+    });
+  }
+  return lines;
+}
+
+export function registerInsightsCommand(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+  projectStore: ProjectStoreRef,
+  projectName: ProjectNameRef,
+  dbManager: DatabaseManager | null = null,
+): void {
   pi.registerCommand("memory-insights", {
     description: "Show what's stored in persistent memory",
     handler: async (_args, ctx) => {
@@ -72,6 +133,19 @@ export function registerInsightsCommand(pi: ExtensionAPI, store: MemoryStore, pr
         lines.push("");
       }
 
+      // Usage section (promotion-gate data: which entries actually get recalled)
+      const usageLines = [
+        ...renderUsageScope("global memory", usageScopeStats(dbManager, "memory", null)),
+        ...renderUsageScope(
+          `project:${activeProjectName ?? ""}`,
+          activeProjectStore && activeProjectName ? usageScopeStats(dbManager, "memory", activeProjectName) : null,
+        ),
+      ];
+      if (usageLines.length > 0) {
+        lines.push(...usageLines);
+        lines.push("");
+      }
+
       ctx.ui.notify(lines.join("\n"), "info");
     },
   });

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

@@ -28,7 +28,7 @@ export interface ApplyReviewOperationsResult {
 export interface DirectReviewResult {
   ok: boolean;
   appliedCount: number;
-  fallbackReason?: "no_model" | "no_auth" | "aborted" | "parse_error" | "provider_error" | "empty";
+  fallbackReason?: "no_model" | "no_auth" | "aborted" | "parse_error" | "provider_error" | "empty" | "empty_response";
   error?: string;
 }
 
@@ -49,6 +49,15 @@ export function usesDirectTransport(config: Pick<MemoryConfig, "reviewTransport"
   return (config.reviewTransport ?? "direct") === "direct";
 }
 
+/** One shared budget for a single review/flush/correction/consolidation
+ * completion, on both the direct transport and the `pi -p` subprocess
+ * fallback. Deliberately not configurable (#197): the bug was the double
+ * spend, not the number — after the empty-response short-circuit the
+ * painful case is one 120s call. Consolidation keeps its separate
+ * `consolidationTimeoutMs` because it is user-visible and must actually
+ * shrink. */
+export const REVIEW_COMPLETION_TIMEOUT_MS = 120_000;
+
 type ReviewLlmConfig = Pick<MemoryConfig, "llmModelOverride" | "llmFallbackModels" | "llmThinkingOverride">;
 
 function findExactModelReferenceMatch(modelReference: string, availableModels: Model<Api>[]): Model<Api> | undefined {
@@ -111,15 +120,83 @@ export type ResolvedRequestAuth = Awaited<ReturnType<ReviewModelRegistry["getApi
 
 type DirectReviewAuth = Omit<Extract<ResolvedRequestAuth, { ok: true }>, "ok">;
 
+type DirectRequestHeaders = DirectReviewAuth["headers"];
+
+/** Context the direct transport needs: request routing plus the session the
+ * gateway attributes the background request to (#250). */
+export type DirectReviewContext = Pick<ExtensionContext, "model" | "modelRegistry" | "sessionManager">;
+
+// Restated from pi-coding-agent's internal getSessionHeaders, read at
+// dist/core/provider-attribution.js in v0.87.1. The package exports no seam for
+// it, and pi-ai only grew its own injection in v0.86.0 while this extension
+// declares a 0.80.6 floor. Re-read that file when bumping the floor past
+// 0.86.0, and check that pi did not add a provider or change the client value.
+//
+// The header is set directly rather than through StreamOptions.sessionId
+// because pi-ai's openai-responses default of sendSessionIdHeader is true, so
+// passing sessionId would also start sending an OpenAI session_id header to
+// every OpenAI Responses user.
+const OPENCODE_SESSION_HEADER = "x-opencode-session";
+const OPENCODE_CLIENT_HEADER = "x-opencode-client";
+const OPENCODE_HOST = "opencode.ai";
+
+function matchesHost(baseUrl: string | undefined, expectedHost: string): boolean {
+  try {
+    return new URL(baseUrl ?? "").hostname === expectedHost;
+  } catch {
+    return false;
+  }
+}
+
+/** A missing session id degrades to the pre-#250 behaviour: the attempt still
+ * goes out, and the subprocess fallback owns recovery. */
+function readSessionId(sessionManager: DirectReviewContext["sessionManager"]): string | undefined {
+  try {
+    return sessionManager.getSessionId() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Returns a copy whenever a header is added: the registry hands out a shared
+ * object, and the credential-rotation comparison below must not read hermes'
+ * own header as a credential change.
+ *
+ * An operator-configured session header short-circuits both additions, so that
+ * request carries no client header. pi keeps its client header in that case.
+ * The divergence is deliberate, because honouring the operator's session id
+ * completely is the more predictable contract. */
+function directRequestHeaders(
+  model: Model<Api>,
+  headers: DirectRequestHeaders,
+  sessionId: string | undefined,
+): DirectRequestHeaders {
+  if (!sessionId) return headers;
+  const isOpenCode = model.provider === "opencode"
+    || model.provider === "opencode-go"
+    || matchesHost(model.baseUrl, OPENCODE_HOST);
+  if (!isOpenCode) return headers;
+  const alreadySet = Object.keys(headers ?? {}).some(
+    (key) => key.toLowerCase() === OPENCODE_SESSION_HEADER,
+  );
+  if (alreadySet) return headers;
+  return {
+    ...headers,
+    [OPENCODE_SESSION_HEADER]: sessionId,
+    [OPENCODE_CLIENT_HEADER]: "pi",
+  };
+}
+
 export function buildDirectReviewCompletionOptions(
   model: Model<Api>,
   auth: DirectReviewAuth,
   thinking: ThinkingLevel | undefined,
   signal: AbortSignal,
+  sessionId: string | undefined,
 ): SimpleStreamOptions {
   const options: SimpleStreamOptions = {
     apiKey: auth.apiKey,
-    headers: auth.headers,
+    headers: directRequestHeaders(model, auth.headers, sessionId),
     env: auth.env,
     signal,
   };
@@ -188,11 +265,19 @@ function isNonEmptyString(value: unknown): value is string {
   return typeof value === "string" && value.trim().length > 0;
 }
 
-function hasRequestAuth(auth: DirectReviewAuth): boolean {
+// Bedrock (AWS profile/SSO) signs inside its SDK, so empty auth is normal there.
+// Not for OAuth: empty OAuth auth means the token refresh failed.
+function hasRequestAuth(
+  modelRegistry: ReviewModelRegistry,
+  model: Model<Api>,
+  auth: DirectReviewAuth,
+): boolean {
   if (isNonEmptyString(auth.apiKey)) return true;
-  return Object.entries(auth.headers ?? {}).some(
+  const hasCredentialHeader = Object.entries(auth.headers ?? {}).some(
     ([key, value]) => CREDENTIAL_HEADER_NAMES.has(key.toLowerCase()) && isNonEmptyString(value),
   );
+  if (hasCredentialHeader) return true;
+  return modelRegistry.hasConfiguredAuth(model) && !modelRegistry.isUsingOAuth(model);
 }
 
 function sameStringRecord(
@@ -242,12 +327,84 @@ export async function resolveRequestAuth(
   return modelRegistry.getApiKeyAndHeaders(model);
 }
 
-function extractJsonPayload(text: string): unknown {
+/** A JSON object extracted from a model response, validated to carry an
+ * `operations` array. Candidate payloads without one are declined at every
+ * extraction step, so a log line, counterexample, or stray snippet cannot
+ * claim the parse and force the subprocess fallback (#235). */
+type JsonObjectPayload = { operations?: unknown };
+
+function isJsonObjectPayload(value: unknown): value is JsonObjectPayload {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Balanced {...} regions at any nesting depth, string- and escape-aware.
+ * Recording every matched pair — not just top-level ones — means an
+ * unbalanced "{" in surrounding prose cannot hide a later object: the
+ * object still forms its own balanced region nested inside the phantom
+ * one (#235). */
+function balancedObjectSpans(text: string): Array<[number, number]> {
+  const spans: Array<[number, number]> = [];
+  const open: number[] = [];
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      open.push(i);
+    } else if (ch === "}") {
+      const start = open.pop();
+      if (start !== undefined) spans.push([start, i]);
+    }
+  }
+  return spans;
+}
+
+/** CoT routinely restates the schema before answering, so the first-to-last
+ * slice above is invalid JSON across that span. Scan balanced objects from
+ * the end and return the last one that parses with an `operations` array —
+ * the answer trailing the preamble (#197). */
+function lastParseableOperationsObject(text: string): JsonObjectPayload | null {
+  const spans = balancedObjectSpans(text);
+  for (let s = spans.length - 1; s >= 0; s--) {
+    const span = spans[s];
+    if (!span) continue;
+    try {
+      const parsed: unknown = JSON.parse(text.slice(span[0], span[1] + 1));
+      if (isJsonObjectPayload(parsed) && Array.isArray(parsed.operations)) {
+        return parsed;
+      }
+    } catch {
+      // keep scanning
+    }
+  }
+  return null;
+}
+
+function extractJsonPayload(text: string): JsonObjectPayload | null {
   const trimmed = text.trim();
   if (!trimmed) return null;
 
+  const asObject = (value: unknown): JsonObjectPayload | null =>
+    isJsonObjectPayload(value) && Array.isArray(value.operations) ? value : null;
+
+  // A declined candidate (valid JSON, no `operations` array) must fall through
+  // to the later paths rather than exit — exiting here is how a stray snippet
+  // claimed the parse and forced the subprocess while a valid trailing
+  // answer was present (#235).
   try {
-    return JSON.parse(trimmed);
+    const parsed = asObject(JSON.parse(trimmed));
+    if (parsed) return parsed;
   } catch {
     // continue
   }
@@ -255,7 +412,8 @@ function extractJsonPayload(text: string): unknown {
   const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
   if (fenced?.[1]) {
     try {
-      return JSON.parse(fenced[1].trim());
+      const parsed = asObject(JSON.parse(fenced[1].trim()));
+      if (parsed) return parsed;
     } catch {
       // continue
     }
@@ -265,12 +423,44 @@ function extractJsonPayload(text: string): unknown {
   const end = trimmed.lastIndexOf("}");
   if (start >= 0 && end > start) {
     try {
-      return JSON.parse(trimmed.slice(start, end + 1));
+      const parsed = asObject(JSON.parse(trimmed.slice(start, end + 1)));
+      if (parsed) return parsed;
     } catch {
-      return null;
+      return lastParseableOperationsObject(trimmed);
     }
   }
 
+  return lastParseableOperationsObject(trimmed);
+}
+
+/** A winning thinking-channel candidate plus whether it sits at the tail of
+ * the channel — the trust boundary for thinking-sourced operations. */
+interface ThinkingOperationsCandidate {
+  payload: JsonObjectPayload;
+  trailing: boolean;
+}
+
+/** Thinking-sourced text takes its own extraction (#235): candidates are
+ * validated on their `operations` array and scanned from the end, because a
+ * chain of thought routinely restates the schema — or drafts an operation it
+ * then rejects — before the final answer. The shared cascade would let an
+ * earlier fenced draft win before this scan runs. The winner is the last
+ * ops-bearing object; `trailing` reports whether anything follows it, which
+ * decides how much to trust it. */
+function extractThinkingOperations(text: string): ThinkingOperationsCandidate | null {
+  const spans = balancedObjectSpans(text);
+  for (let s = spans.length - 1; s >= 0; s--) {
+    const span = spans[s];
+    if (!span) continue;
+    try {
+      const parsed: unknown = JSON.parse(text.slice(span[0], span[1] + 1));
+      if (isJsonObjectPayload(parsed) && Array.isArray(parsed.operations)) {
+        return { payload: parsed, trailing: text.slice(span[1] + 1).trim() === "" };
+      }
+    } catch {
+      // keep scanning
+    }
+  }
   return null;
 }
 
@@ -297,11 +487,16 @@ export function parseReviewOperations(text: string): ReviewMemoryOperation[] | n
   }
 
   const payload = extractJsonPayload(text);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+  if (!payload) {
     return null;
   }
 
-  const operations = (payload as { operations?: unknown }).operations;
+  return mapOperationsArray(payload.operations);
+}
+
+/** Map a candidate `operations` array to validated review operations; null
+ * means the payload is not an operations payload at all. */
+function mapOperationsArray(operations: unknown): ReviewMemoryOperation[] | null {
   if (!Array.isArray(operations)) return null;
 
   const parsed: ReviewMemoryOperation[] = [];
@@ -485,24 +680,77 @@ export async function applyReviewOperations(
   return { appliedCount, skippedCount };
 }
 
-function responseText(content: unknown): string {
-  if (!Array.isArray(content)) return "";
-  return content
+/** Channel-aware text extraction: text blocks when present, otherwise the
+ * thinking channel — thinking-default servers park the whole answer in the
+ * reasoning channel (e.g. vLLM with DEFAULT_THINKING=max, regardless of the
+ * client-side level), so it is recovered there rather than treated as a
+ * parse error (#197). The source decides which extraction path parses it:
+ * the text channel keeps the shared cascade, thinking takes its own
+ * end-scan (#235). */
+function responseChannelText(content: unknown): { text: string; source: "text" | "thinking" } {
+  if (!Array.isArray(content)) return { text: "", source: "text" };
+  const text = content
     .filter((block): block is { type: "text"; text: string } => (
       !!block && typeof block === "object" && (block as { type?: string }).type === "text"
     ))
     .map((block) => block.text)
     .join("\n");
+  if (text.trim()) return { text, source: "text" };
+
+  // Anthropic redacted_thinking arrives as {type:"thinking", redacted:true}
+  // after normalization — there is no recoverable payload in it, and letting
+  // it through would turn a redacted-only completion into a parse_error and
+  // burn the subprocess fallback (#197).
+  const thinking = content
+    .filter((block): block is { type: "thinking"; thinking: string } => (
+      !!block && typeof block === "object" && (block as { type?: string }).type === "thinking"
+      && (block as { redacted?: boolean }).redacted !== true
+    ))
+    .map((block) => block.thinking)
+    .join("\n");
+  return { text: thinking, source: "thinking" };
+}
+
+const defaultProviderNoticeState = { logged: false };
+
+/** Fired once per process when a provider returns the whole answer in its
+ * thinking channel with an empty answer channel. That signature means the
+ * provider's server-side thinking default is swallowing the output (the #197
+ * report), so thinking-channel recovery is a workaround for a
+ * misconfiguration, not a feature to rely on. */
+function notifyThinkingChannelProvider(
+  model: { provider?: unknown; id?: unknown },
+  deps: { onProviderNotice?: (message: string) => void; providerNoticeState?: { logged: boolean } },
+): void {
+  const state = deps.providerNoticeState ?? defaultProviderNoticeState;
+  if (state.logged) return;
+  state.logged = true;
+  const modelRef = typeof model?.provider === "string" && typeof model?.id === "string"
+    ? `${model.provider}/${model.id}`
+    : "the active model";
+  const sink = deps.onProviderNotice ?? ((message: string) => console.warn(message));
+  sink(
+    `[pi-hermes-memory] Provider misconfiguration: ${modelRef} returned the whole answer in its thinking channel and left the answer channel empty. `
+      + "This usually means server-side thinking is forced on for this provider (for example a vLLM server started with DEFAULT_THINKING=max). "
+      + "Review recovery from the thinking channel is best-effort and can miss saves. "
+      + "Ask your Pi to fix this as well.",
+  );
 }
 
 export async function runDirectMemoryCompletion(
-  ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
+  ctx: DirectReviewContext,
   store: MemoryStore,
   projectStore: MemoryStore | null,
   options: RunDirectMemoryCompletionOptions,
   dbManager: DatabaseManager | null = null,
   projectName?: string | null,
-  deps: { completeSimple?: typeof completeSimple } = {},
+  deps: {
+    completeSimple?: typeof completeSimple;
+    /** Test seam: replaces the console.warn sink for the provider notice. */
+    onProviderNotice?: (message: string) => void;
+    /** Test seam: dedupe state for the provider notice; omit for the process default. */
+    providerNoticeState?: { logged: boolean };
+  } = {},
 ): Promise<DirectReviewResult> {
   const complete = deps.completeSimple ?? completeSimple;
   const aborted = (): DirectReviewResult => ({ ok: false, appliedCount: 0, fallbackReason: "aborted" });
@@ -513,6 +761,10 @@ export async function runDirectMemoryCompletion(
     return { ok: false, appliedCount: 0, fallbackReason: "no_model" };
   }
 
+  // One id per completion, reused across the chain: the whole chain is a single
+  // job for a single conversation.
+  const sessionId = readSessionId(ctx.sessionManager);
+
   // 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.
@@ -525,7 +777,7 @@ export async function runDirectMemoryCompletion(
     if (options.signal?.aborted) return aborted();
     const auth = await resolveRequestAuth(ctx.modelRegistry, model);
     if (options.signal?.aborted) return aborted();
-    if (!auth.ok || !hasRequestAuth(auth)) {
+    if (!auth.ok || !hasRequestAuth(ctx.modelRegistry, model, auth)) {
       lastResult = {
         ok: false,
         appliedCount: 0,
@@ -538,7 +790,7 @@ export async function runDirectMemoryCompletion(
     let requestAuth: DirectReviewAuth = { apiKey: auth.apiKey, headers: auth.headers, env: auth.env };
 
     const controller = new AbortController();
-    const timeoutMs = options.timeoutMs ?? 120000;
+    const timeoutMs = options.timeoutMs ?? REVIEW_COMPLETION_TIMEOUT_MS;
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     const onExternalAbort = () => controller.abort();
     if (options.signal) {
@@ -559,7 +811,7 @@ export async function runDirectMemoryCompletion(
       const response = await complete(
         model,
         request,
-        buildDirectReviewCompletionOptions(model, requestAuth, thinking, controller.signal),
+        buildDirectReviewCompletionOptions(model, requestAuth, thinking, controller.signal, sessionId),
       );
       if (response.stopReason === "error" && isAuthRejection(response.errorMessage ?? "")) {
         throw new Error(response.errorMessage ?? "error");
@@ -581,7 +833,7 @@ export async function runDirectMemoryCompletion(
         // 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;
+        if (!rotated.ok || !hasRequestAuth(ctx.modelRegistry, model, rotated) || sameRequestAuth(rotated, requestAuth)) throw err;
 
         requestAuth = { apiKey: rotated.apiKey, headers: rotated.headers, env: rotated.env };
         response = await completeOnce();
@@ -597,8 +849,56 @@ export async function runDirectMemoryCompletion(
         return lastResult;
       }
 
-      const text = responseText(response.content);
-      const operations = parseReviewOperations(text);
+      const { text, source } = responseChannelText(response.content);
+      // The thinking-only signature means the provider's server-side thinking
+      // default is swallowing the answer channel (#197). Recovery works, but
+      // it is best-effort; surface the misconfiguration once per process so
+      // the user can fix the provider instead of relying on the recovery.
+      if (source === "thinking" && text.trim() !== "") {
+        notifyThinkingChannelProvider(model, deps);
+      }
+
+      // Thinking-sourced text takes its own extraction (#235): candidates are
+      // validated on their `operations` array and scanned from the end, and
+      // the winner's trailing-ness sets how much to trust it. The text channel
+      // keeps the shared cascade untouched so today's parse successes do not
+      // move.
+      let operations: ReviewMemoryOperation[] | null;
+      let unparsableThinking = false;
+      if (source === "thinking") {
+        const extraction = extractThinkingOperations(text);
+        if (extraction) {
+          operations = mapOperationsArray(extraction.payload.operations) ?? [];
+          // A candidate that is not trailing is draft-grade: apply only its
+          // adds. Trusting a draft's replace/remove — or reaching back to an
+          // earlier candidate when the trailing one is empty — would execute
+          // operations the model may have rejected; a missed save is
+          // recoverable, a wrong deletion is not.
+          if (!extraction.trailing) {
+            operations = operations.filter((operation) => operation.action === "add");
+          }
+        } else {
+          operations = null;
+          unparsableThinking = true;
+        }
+      } else {
+        operations = parseReviewOperations(text);
+      }
+
+      // A clean stop with no usable output — nothing in either channel, or
+      // thinking-sourced output that parses to nothing — settles
+      // empty_response: the subprocess would run the same model against the
+      // same server-side thinking default and fail the same way (#197). The
+      // chain still walks llmFallbackModels first, like parse_error does: a
+      // silent primary model should not end the review while a configured
+      // fallback may answer (#235). Never the subprocess on this path.
+      // Truncated responses (stopReason "length") still fall through to
+      // parse_error so the chain can retry them.
+      if ((!text.trim() || unparsableThinking) && response.stopReason === "stop") {
+        lastResult = { ok: true, appliedCount: 0, fallbackReason: "empty_response" };
+        if (mi < models.length - 1) { clearTimeout(timeout); continue; }
+        return lastResult;
+      }
       if (operations === null) {
         lastResult = { ok: false, appliedCount: 0, fallbackReason: "parse_error" };
         if (mi < models.length - 1) { clearTimeout(timeout); continue; }

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

@@ -123,6 +123,14 @@ export function scheduleSessionBackfill(
   return true;
 }
 
+/**
+ * First-use readiness has no shutdown deadline: the scheduled pass must settle
+ * before a search can read its index. Each extension owns its own state.
+ */
+export async function joinSessionBackfill(state: SessionBackfillState = sessionBackfillState): Promise<void> {
+  await state.promise;
+}
+
 /**
  * Wait briefly for an in-progress backfill before shutdown closes SQLite.
  *