supipowers 2.0.1 → 2.1.0

package/src/mempalace/format.ts

@@ -28,6 +28,17 @@ function asArray(value: unknown): RecordValue[] {
   return Array.isArray(value) ? value.map(asRecord) : [];
 }
 
+function asCountMap(value: unknown): Array<[string, number]> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const out: Array<[string, number]> = [];
+  for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
+    const count = typeof raw === "number" && Number.isFinite(raw) ? raw : Number(raw);
+    out.push([key, Number.isFinite(count) ? count : 0]);
+  }
+  out.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  return out;
+}
+
 function stringValue(value: unknown): string {
   if (value === null || value === undefined) return "";
   if (typeof value === "string") return value;
@@ -35,6 +46,10 @@ function stringValue(value: unknown): string {
   return JSON.stringify(value);
 }
 
+function finiteNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
 function truncateText(text: string, maxChars: number, guidance: string): string {
   if (text.length <= maxChars) return text;
   if (maxChars <= guidance.length + 1) {
@@ -49,11 +64,29 @@ function formatSimilarity(value: unknown): string {
 }
 
 function formatSearch(result: RecordValue, budgets: ResultBudgets): string {
-  const results = asArray(result.results ?? result.items);
+  const results = asArray(result.results);
   const query = stringValue(result.query) || "(unspecified query)";
   const count = typeof result.count === "number" ? result.count : results.length;
   const lines = [`MemPalace search`, `Search results for ${query} (${count})`];
 
+  if (result.index_recovered) {
+    lines.push("Index recovered: retried after transient index lookup failure.");
+  }
+
+  // Surface filter context so agents can tell "empty palace" from "over-filtered".
+  const filters = asRecord(result.filters);
+  const filterParts = (["wing", "room"] as string[]).flatMap(k => {
+    const v = stringValue(filters[k]);
+    return v ? [`${k}=${v}`] : [];
+  });
+  if (filterParts.length > 0) {
+    lines.push(`Filters applied: ${filterParts.join(", ")}`);
+  }
+  const totalBeforeFilter = finiteNumber(result.total_before_filter);
+  if (totalBeforeFilter !== undefined && totalBeforeFilter > count) {
+    lines.push(`Filtered out ${totalBeforeFilter - count} hit(s) by wing/room scope.`);
+  }
+
   for (const [index, item] of results.entries()) {
     const id = stringValue(item.id ?? item.drawer_id) || `#${index + 1}`;
     const wing = stringValue(item.wing);
@@ -64,12 +97,17 @@ function formatSearch(result: RecordValue, budgets: ResultBudgets): string {
     if (excerpt) lines.push(`   ${excerpt}`);
   }
 
+
   return truncateText(lines.join("\n"), budgets.searchResultChars, TRUNCATED_SEARCH_GUIDANCE);
 }
 
 function formatDrawerList(result: RecordValue, budgets: ResultBudgets): string {
-  const drawers = asArray(result.drawers ?? result.results ?? result.items);
-  const lines = [`Drawers (${drawers.length})`];
+  const drawers = asArray(result.drawers ?? result.results);
+  const total = finiteNumber(result.total);
+  const header = total === undefined
+    ? `Drawers (${drawers.length})`
+    : `Drawers (${drawers.length} shown, ${total} total)`;
+  const lines = [header];
 
   for (const drawer of drawers) {
     const id = stringValue(drawer.id ?? drawer.drawer_id) || "unknown";
@@ -81,6 +119,29 @@ function formatDrawerList(result: RecordValue, budgets: ResultBudgets): string {
   return truncateText(lines.join("\n"), budgets.listResultChars, TRUNCATED_LIST_GUIDANCE);
 }
 
+function formatWingList(result: RecordValue, budgets: ResultBudgets): string {
+  const wings = asCountMap(result.wings);
+  const total = wings.reduce((acc, [, n]) => acc + n, 0);
+  const lines = [`Wings (${wings.length}${total ? `, ${total} drawers`: ""})`];
+  for (const [name, count] of wings) {
+    lines.push(`- ${name} (${count})`);
+  }
+  if (result.partial) lines.push("(partial result — palace returned an error mid-scan)");
+  return truncateText(lines.join("\n"), budgets.listResultChars, TRUNCATED_LIST_GUIDANCE);
+}
+
+function formatRoomList(result: RecordValue, budgets: ResultBudgets): string {
+  const wing = stringValue(result.wing) || "all";
+  const rooms = asCountMap(result.rooms);
+  const total = rooms.reduce((acc, [, n]) => acc + n, 0);
+  const lines = [`Rooms in ${wing} (${rooms.length}${total ? `, ${total} drawers` : ""})`];
+  for (const [name, count] of rooms) {
+    lines.push(`- ${name} (${count})`);
+  }
+  if (result.partial) lines.push("(partial result — palace returned an error mid-scan)");
+  return truncateText(lines.join("\n"), budgets.listResultChars, TRUNCATED_LIST_GUIDANCE);
+}
+
 function formatDiary(result: RecordValue, budgets: ResultBudgets): string {
   const entries = asArray(result.entries ?? result.results ?? result.items);
   const lines = [`Diary entries (${entries.length})`];
@@ -96,13 +157,23 @@ function formatDiary(result: RecordValue, budgets: ResultBudgets): string {
 }
 
 function formatStatus(result: RecordValue): string {
-  const wings = Array.isArray(result.wings) ? result.wings.length : result.wingCount ?? result.wings_count ?? "unknown";
   const lines = ["MemPalace status"];
   const palacePath = stringValue(result.palacePath ?? result.palace_path ?? result.palace);
   if (palacePath) lines.push(`palace: ${palacePath}`);
   if ("ready" in result) lines.push(`ready: ${String(result.ready)}`);
   if ("version" in result) lines.push(`version: ${stringValue(result.version)}`);
-  lines.push(`wings: ${String(wings)}`);
+
+  const wingsCount = Array.isArray(result.wings)
+    ? result.wings.length
+    : result.wings && typeof result.wings === "object"
+      ? Object.keys(result.wings as Record<string, unknown>).length
+      : (typeof result.wingCount === "number" ? result.wingCount : undefined)
+        ?? (typeof result.wings_count === "number" ? result.wings_count : undefined);
+  lines.push(`wings: ${wingsCount === undefined ? "unknown" : String(wingsCount)}`);
+
+  if (typeof result.total_drawers === "number") lines.push(`drawers: ${result.total_drawers}`);
+  else if (typeof result.totalDrawers === "number") lines.push(`drawers: ${result.totalDrawers}`);
+
   return lines.join("\n");
 }
 
@@ -112,6 +183,45 @@ function formatGeneric(action: MempalaceAction, result: RecordValue, budgets: Re
   return truncateText(`MemPalace ${action} result\n${JSON.stringify(result, null, 2)}`, budgets.listResultChars, TRUNCATED_LIST_GUIDANCE);
 }
 
+function formatWake(wake: RecordValue, budgets: ResultBudgets): string {
+  const text = stringValue(wake.text);
+  if (!text) return "MemPalace wake: (no text returned)";
+  // Wake payloads are roughly the size of a search result block (L0/L1
+  // condensation), so reuse the search budget rather than introducing a new
+  // dimension. truncateText preserves trailing guidance so the agent can ask
+  // for more if it was clipped.
+  return truncateText(`MemPalace wake\n${text}`, budgets.searchResultChars, TRUNCATED_SEARCH_GUIDANCE);
+}
+
+function formatWakeUpAndSearch(result: RecordValue, budgets: ResultBudgets): string {
+  const wake = result.wake;
+  const search = result.search;
+  const parts: string[] = [];
+
+  // Wake half: null means wake failed — emit a one-line notice so the operator
+  // can see something went wrong without poisoning the turn with empty output.
+  // Wake payloads from python are `{ text: <L0+L1 markdown> }` — render that
+  // text directly. Passing through formatSearch() would drop it entirely
+  // because formatSearch only reads `query`/`results`.
+  if (wake === null || wake === undefined) {
+    const notice = typeof result.wake_error === "string" ? result.wake_error : "wake_up failed";
+    parts.push(`MemPalace wake: ${notice}`);
+  } else {
+    parts.push(formatWake(asRecord(wake), budgets));
+  }
+
+  // Search half: omit when null AND no error reported. If python attached a
+  // search_error (composite call failed mid-way), surface it as a one-liner so
+  // the caller can distinguish "no query / no hits" from "search blew up".
+  if (search !== null && search !== undefined) {
+    parts.push(formatSearch(asRecord(search), budgets));
+  } else if (typeof result.search_error === "string") {
+    parts.push(`MemPalace search: ${result.search_error}`);
+  }
+
+  return truncateText(parts.join("\n\n"), budgets.searchResultChars, TRUNCATED_SEARCH_GUIDANCE);
+}
+
 export function formatMempalaceResult(
   action: MempalaceAction,
   result: unknown,
@@ -124,8 +234,14 @@ export function formatMempalaceResult(
     text = formatStatus(record);
   } else if (action === "search" || action === "wake_up") {
     text = formatSearch(record, budgets);
-  } else if (action === "list_drawers" || action === "list_wings" || action === "list_rooms") {
+  } else if (action === "wake_up_and_search") {
+    text = formatWakeUpAndSearch(record, budgets);
+  } else if (action === "list_drawers") {
     text = formatDrawerList(record, budgets);
+  } else if (action === "list_wings") {
+    text = formatWingList(record, budgets);
+  } else if (action === "list_rooms") {
+    text = formatRoomList(record, budgets);
   } else if (action === "diary_read") {
     text = formatDiary(record, budgets);
   } else {

package/src/mempalace/hooks.ts

@@ -3,17 +3,73 @@ import { normalizeSystemPromptBlocks } from "../platform/system-prompt.js";
 import type { SupipowersConfig } from "../types.js";
 import { createMempalaceBridge, type MempalaceBridgeFacade } from "./bridge.js";
 import { resolveDefaultWing, resolveMempalaceConfig, type ResolvedMempalaceConfig } from "./config.js";
+import { resolveInstalledBridgeScriptPath } from "./runtime.js";
 import { getEventStore as getContextEventStore, getSessionId as getContextSessionId } from "../context-mode/hooks.js";
 import { buildCompactionCheckpoint, buildShutdownDiary } from "./session-summary.js";
+import { snapshotMempalaceInstall } from "./installer-helper.js";
 
 export interface MempalaceHooksDeps {
   createBridge?: (config: ResolvedMempalaceConfig, cwd: string) => MempalaceBridgeFacade;
   getEventStore?: () => Parameters<typeof buildCompactionCheckpoint>[0]["eventStore"];
   getSessionId?: () => string;
   now?: () => string;
+  snapshotInstall?: (paths: Platform["paths"], cwd: string, config: SupipowersConfig) => { ready: boolean };
 }
 
-const wakeUpCache = new Map<string, string>();
+/** Maximum number of (sessionId × wing × palace) entries to keep in memory. */
+const HOOK_CACHE_LRU_CAP = 64;
+
+/** Insertion-ordered bounded LRU. Drops the least-recently-used entry on overflow. */
+class BoundedLRU<K, V> {
+  private readonly inner = new Map<K, V>();
+
+  constructor(private readonly cap: number) {}
+
+  get(key: K): V | undefined {
+    if (!this.inner.has(key)) return undefined;
+    const value = this.inner.get(key) as V;
+    this.inner.delete(key);
+    this.inner.set(key, value);
+    return value;
+  }
+
+  set(key: K, value: V): void {
+    if (this.inner.has(key)) {
+      this.inner.delete(key);
+    } else if (this.inner.size >= this.cap) {
+      const oldest = this.inner.keys().next().value;
+      if (oldest !== undefined) this.inner.delete(oldest);
+    }
+    this.inner.set(key, value);
+  }
+
+  delete(key: K): boolean {
+    return this.inner.delete(key);
+  }
+
+  clear(): void {
+    this.inner.clear();
+  }
+
+  keys(): IterableIterator<K> {
+    return this.inner.keys();
+  }
+}
+
+function warnHookStateFallback(platform: Platform, message: string): void {
+  const logger = (platform as { logger?: { warn?: (message: string) => void } }).logger;
+  if (typeof logger?.warn === "function") {
+    logger.warn(message);
+    return;
+  }
+  console.warn(message);
+}
+
+function hookTimeoutSeconds(timeoutMs: number): number {
+  return Math.max(1, Math.floor(timeoutMs / 1000));
+}
+
+const wakeUpCache = new BoundedLRU<string, string>(HOOK_CACHE_LRU_CAP);
 
 /**
  * Per-session turn counter for wake-up cadence gating. The full wake-up block
@@ -21,7 +77,7 @@ const wakeUpCache = new Map<string, string>();
  * `mempalace.budgets.wakeUpInjectionEvery`); other turns get a one-line
  * refresher. Cleared on session_start / session_switch.
  */
-const turnCounters = new Map<string, number>();
+const turnCounters = new BoundedLRU<string, number>(HOOK_CACHE_LRU_CAP);
 
 /** Test-only: reset cadence state between cases. */
 export function _resetMempalaceHookState(): void {
@@ -91,6 +147,15 @@ function setupGuidanceBlock(resolved: ResolvedMempalaceConfig, wing: string): st
   ].join("\n");
 }
 
+function wakeFailureBlock(resolved: ResolvedMempalaceConfig, wing: string, error: string): string {
+  return [
+    "# MemPalace memory",
+    `- palace: ${resolved.palacePath}`,
+    `- default wing: ${wing}`,
+    `- Wake-up failed: ${error}`,
+  ].join("\n");
+}
+
 function wakeUpBlock(resolved: ResolvedMempalaceConfig, wing: string, text: string): string {
   const excerpt = truncateByTokenBudget(text, resolved.budgets.wakeUpTokens);
   const lines = [
@@ -139,19 +204,33 @@ function extractUserPrompt(event: unknown): string {
 /** Minimum prompt length below which we skip auto-search (saves a bridge call). */
 const AUTO_SEARCH_MIN_PROMPT_CHARS = 15;
 
-/** Cap on the search query length. Long prompts are truncated to the first N chars. */
-const AUTO_SEARCH_QUERY_MAX_CHARS = 500;
-
 /**
- * Returns `true` when `prompt` is a trivial acknowledgement that does not warrant
- * a memory search (saves the bridge round-trip for "yes", "ok", "thanks", etc.).
+ * Returns `true` when `prompt` warrants a MemPalace auto-search.
+ * Rules applied in order:
+ *   1. Too-short or trivial filler word → skip (saves the bridge round-trip).
+ *   2. Contains "?" or starts with a question word → search.
+ *   3. Contains a memory/recall signal → search.
+ *   4. Starts with a clearly imperative verb and has no search signal → skip.
+ *   5. Ambiguous → search (preserves recall on uncertain prompts).
  */
-function isTrivialPrompt(prompt: string): boolean {
+function shouldAutoSearchPrompt(prompt: string): boolean {
   const normalized = prompt.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").replace(/\s+/g, " ").trim();
-  if (normalized.length < AUTO_SEARCH_MIN_PROMPT_CHARS) return true;
-  // Conservative wordlist: only strip obvious filler.
+  // Rule 1: trivial length or obvious filler.
+  if (normalized.length < AUTO_SEARCH_MIN_PROMPT_CHARS) return false;
   const TRIVIAL = new Set(["yes", "no", "ok", "okay", "thanks", "thank you", "great", "cool", "go", "continue", "proceed"]);
-  return TRIVIAL.has(normalized);
+  if (TRIVIAL.has(normalized)) return false;
+  // Rule 2: explicit question signals → search.
+  if (prompt.includes("?")) return true;
+  const QUESTION_PREFIXES = ["what", "why", "when", "who", "where", "how", "which", "do", "does", "is", "are", "can", "should"];
+  if (QUESTION_PREFIXES.some(p => normalized.startsWith(p + " ") || normalized === p)) return true;
+  // Rule 3: memory/recall signal words → search.
+  const RECALL_SIGNALS = ["remember", "recall", "decided", "decision", "chose", "last time", "previously", "earlier", "before"];
+  if (RECALL_SIGNALS.some(s => normalized.includes(s))) return true;
+  // Rule 4: clearly imperative verb at start, no search signal above → skip.
+  const IMPERATIVE_PREFIXES = ["fix", "add", "remove", "delete", "run", "update", "refactor", "rename", "move", "write", "create", "make", "implement", "build"];
+  if (IMPERATIVE_PREFIXES.some(p => normalized.startsWith(p + " ") || normalized === p)) return false;
+  // Rule 5: ambiguous → search.
+  return true;
 }
 
 interface SearchHit {
@@ -169,13 +248,13 @@ function pickHits(result: unknown): SearchHit[] {
 }
 
 /** Score-gated relevance check so we don't inject low-quality matches as noise. */
-function isRelevantHit(hit: SearchHit): boolean {
+function isRelevantHit(hit: SearchHit, similarityFloor: number, bm25Floor: number): boolean {
   const sim = typeof hit.similarity === "number" ? hit.similarity : null;
   const bm25 = typeof hit.bm25_score === "number" ? hit.bm25_score : null;
-  // Either signal must clear a low bar. Mempalace's `similarity` is ~1.0 for
+  // Either signal must clear the configured floor. similarity is ~1.0 for
   // perfect, ~0.5 for "kinda related"; bm25 is unbounded but >0.3 is meaningful.
-  if (sim !== null && sim >= 0.55) return true;
-  if (bm25 !== null && bm25 >= 0.3) return true;
+  if (sim !== null && sim >= similarityFloor) return true;
+  if (bm25 !== null && bm25 >= bm25Floor) return true;
   return false;
 }
 
@@ -210,12 +289,38 @@ export function registerMempalaceHooks(
 ): void {
   if (!config.mempalace.enabled) return;
 
-  const clearAll = () => {
-    wakeUpCache.clear();
-    turnCounters.clear();
+  const snapshotInstall = deps.snapshotInstall ?? snapshotMempalaceInstall;
+  const isInstallReady = (cwd: string): boolean => snapshotInstall(platform.paths, cwd, config).ready;
+
+  const bridgeRuntime = {
+    resolveBridgeScriptPath: () => resolveInstalledBridgeScriptPath(platform.paths),
+  };
+
+  const clearSessionState = (sessionId: string): void => {
+    for (const key of [...wakeUpCache.keys()]) {
+      if (key.startsWith(`${sessionId}|`)) wakeUpCache.delete(key);
+    }
+    for (const key of [...turnCounters.keys()]) {
+      if (key.startsWith(`${sessionId}|`)) turnCounters.delete(key);
+    }
+  };
+
+  const clearForSession = (event: unknown): void => {
+    const source = typeof event === "object" && event !== null ? event as { sessionId?: unknown; previousSessionId?: unknown } : null;
+    const sessionId = typeof source?.sessionId === "string" && source.sessionId.length > 0 ? source.sessionId : null;
+    const previousSessionId =
+      typeof source?.previousSessionId === "string" && source.previousSessionId.length > 0 ? source.previousSessionId : null;
+    if (sessionId === null && previousSessionId === null) {
+      warnHookStateFallback(platform, "[mempalace hooks] session event missing sessionId — clearing all hook state");
+      wakeUpCache.clear();
+      turnCounters.clear();
+      return;
+    }
+    if (sessionId !== null) clearSessionState(sessionId);
+    if (previousSessionId !== null) clearSessionState(previousSessionId);
   };
-  platform.on("session_start", clearAll);
-  platform.on("session_switch", clearAll);
+  platform.on("session_start", clearForSession);
+  platform.on("session_switch", clearForSession);
 
   platform.on("before_agent_start", async (event: unknown, ctx: unknown) => {
     const wakeUpEnabled = config.mempalace.hooks.wakeUp;
@@ -234,11 +339,14 @@ export function registerMempalaceHooks(
     const sessionId = sessionIdFrom(event, ctx);
     const cacheKey = `${sessionId}|${wing}|${resolved.palacePath}`;
     const basePrompt = currentSystemPromptBlocks(event, ctx);
+    if (!isInstallReady(cwd)) {
+      return appendPrompt(basePrompt, setupGuidanceBlock(resolved, wing));
+    }
     const userPrompt = extractUserPrompt(event);
 
     const bridge = deps.createBridge
       ? deps.createBridge(resolved, cwd)
-      : createMempalaceBridge({ cwd, config: resolved });
+      : createMempalaceBridge({ cwd, config: resolved, runtime: bridgeRuntime });
 
     // Cadence gating: wake-up dump on turn 1 and every Nth turn; refresher
     // otherwise. Saves ~750 tokens/turn average for a default cadence of 10.
@@ -248,42 +356,78 @@ export function registerMempalaceHooks(
     turnCounters.set(turnKey, turnCount);
     const isFullInjectionTurn = turnCount === 1 || turnCount % cadence === 0;
 
-    // Run the cached generic wake_up and the per-prompt search in parallel.
-    // wake_up is cached for the session; auto-search is fresh every turn.
-    const wakePromise = (async (): Promise<string> => {
-      if (!isFullInjectionTurn) return wakeUpRefresher(resolved, wing);
+    // On cadence-gated turns: one bridge.execute call handles both wake and search
+    // (wake_up_and_search). On non-injection turns: refresher string + optional
+    // separate search call. Either path issues at most one bridge call per turn.
+    const timeoutSeconds = hookTimeoutSeconds(resolved.timeouts.hookMs); /* seconds; bridge multiplies by 1000 */
+    const wantsSearch = autoSearchEnabled && shouldAutoSearchPrompt(userPrompt);
+    // Let upstream MemPalace extract the salient question/tail from long prompts.
+    const query = wantsSearch ? userPrompt : undefined;
+
+    let wakeBlock: string;
+    let searchBlock: string | null = null;
+
+    if (!isFullInjectionTurn) {
+      // Non-injection turns: lightweight refresher, no wake bridge call needed.
+      wakeBlock = wakeUpRefresher(resolved, wing);
+      if (wantsSearch) {
+        try {
+          const result = await bridge.execute({ action: "search", query: query!, wing, limit: 3, timeout: timeoutSeconds });
+          if (result.ok) {
+            const { autoSearchSimilarityFloor, autoSearchBm25Floor } = resolved.budgets;
+            const hits = pickHits(result.result).filter(hit => isRelevantHit(hit, autoSearchSimilarityFloor, autoSearchBm25Floor));
+            searchBlock = autoSearchBlock(hits, resolved.budgets.autoSearchTokens);
+          }
+        } catch {
+          // Auto-search is best-effort. A failure here must never block the turn.
+        }
+      }
+    } else {
       const cached = wakeUpCache.get(cacheKey);
-      if (cached) return cached;
-      const wake = await bridge.execute({ action: "wake_up", wing, timeout: resolved.timeouts.hookMs });
-      const block = wake.ok
-        ? wakeUpBlock(resolved, wing, wakeText(wake.result))
-        : setupGuidanceBlock(resolved, wing);
-      wakeUpCache.set(cacheKey, block);
-      return block;
-    })();
-
-    const searchPromise = (async (): Promise<string | null> => {
-      if (!autoSearchEnabled) return null;
-      if (!userPrompt || isTrivialPrompt(userPrompt)) return null;
-      const query = userPrompt.slice(0, AUTO_SEARCH_QUERY_MAX_CHARS);
-      try {
-        const result = await bridge.execute({
-          action: "search",
-          query,
+      if (cached) {
+        // Wake block is already cached — only issue a search call if warranted.
+        wakeBlock = cached;
+        if (wantsSearch) {
+          try {
+            const result = await bridge.execute({ action: "search", query: query!, wing, limit: 3, timeout: timeoutSeconds });
+            if (result.ok) {
+              const { autoSearchSimilarityFloor, autoSearchBm25Floor } = resolved.budgets;
+              const hits = pickHits(result.result).filter(hit => isRelevantHit(hit, autoSearchSimilarityFloor, autoSearchBm25Floor));
+              searchBlock = autoSearchBlock(hits, resolved.budgets.autoSearchTokens);
+            }
+          } catch {
+            // Auto-search is best-effort. A failure here must never block the turn.
+          }
+        }
+      } else {
+        // Cache miss: batch wake + search into one bridge call.
+        const batchResult = await bridge.execute({
+          action: "wake_up_and_search",
           wing,
-          limit: 3,
-          timeout: resolved.timeouts.hookMs,
+          timeout: timeoutSeconds,
+          ...(query !== undefined ? { query, limit: 3 } : {}),
         });
-        if (!result.ok) return null;
-        const hits = pickHits(result.result).filter(isRelevantHit);
-        return autoSearchBlock(hits, resolved.budgets.autoSearchTokens);
-      } catch {
-        // Auto-search is best-effort. A failure here must never block the turn.
-        return null;
+        const composite = batchResult.ok ? (batchResult.result as Record<string, unknown>) : null;
+        const compositeWake = composite !== null ? (composite.wake as Record<string, unknown> | null | undefined) : undefined;
+        const wakeError = composite !== null && typeof composite.wake_error === "string" ? composite.wake_error : "wake_up failed";
+        const block = compositeWake != null
+          ? wakeUpBlock(resolved, wing, wakeText(compositeWake))
+          : batchResult.ok
+            ? wakeFailureBlock(resolved, wing, wakeError)
+            : setupGuidanceBlock(resolved, wing);
+        wakeUpCache.set(cacheKey, block);
+        wakeBlock = block;
+
+        // Extract search hits from the composite result (only if search was requested).
+        const compositeSearch = composite !== null ? composite.search : undefined;
+        if (compositeSearch != null && autoSearchEnabled) {
+          const { autoSearchSimilarityFloor, autoSearchBm25Floor } = resolved.budgets;
+          const hits = pickHits(compositeSearch).filter(hit => isRelevantHit(hit, autoSearchSimilarityFloor, autoSearchBm25Floor));
+          searchBlock = autoSearchBlock(hits, resolved.budgets.autoSearchTokens);
+        }
       }
-    })();
+    }
 
-    const [wakeBlock, searchBlock] = await Promise.all([wakePromise, searchPromise]);
     const combined = searchBlock ? `${wakeBlock}\n${searchBlock}` : wakeBlock;
     return appendPrompt(basePrompt, combined);
   });
@@ -292,6 +436,7 @@ export function registerMempalaceHooks(
     platform.on("session_before_compact", async (_event: unknown, ctx: unknown) => {
       try {
         const cwd = contextCwd(ctx);
+        if (!isInstallReady(cwd)) return undefined;
         const resolved = resolveMempalaceConfig(config, cwd, platform.paths);
         let wing: string;
         try {
@@ -311,7 +456,7 @@ export function registerMempalaceHooks(
         });
         const bridge = deps.createBridge
           ? deps.createBridge(resolved, cwd)
-          : createMempalaceBridge({ cwd, config: resolved });
+          : createMempalaceBridge({ cwd, config: resolved, runtime: bridgeRuntime });
         await bridge.execute({
           action: "add_drawer",
           wing: checkpoint.metadata.wing,
@@ -319,7 +464,7 @@ export function registerMempalaceHooks(
           content: checkpoint.content,
           added_by: checkpoint.metadata.added_by,
           source_file: checkpoint.metadata.source_file,
-          timeout: resolved.timeouts.hookMs,
+          timeout: hookTimeoutSeconds(resolved.timeouts.hookMs), /* seconds; bridge multiplies by 1000 */
         });
       } catch {
         // Compaction must never be cancelled by MemPalace checkpoint failures.
@@ -332,6 +477,7 @@ export function registerMempalaceHooks(
     platform.on("session_shutdown", async (_event: unknown, ctx: unknown) => {
       try {
         const cwd = contextCwd(ctx);
+        if (!isInstallReady(cwd)) return undefined;
         const resolved = resolveMempalaceConfig(config, cwd, platform.paths);
         let wing: string;
         try {
@@ -351,7 +497,7 @@ export function registerMempalaceHooks(
         });
         const bridge = deps.createBridge
           ? deps.createBridge(resolved, cwd)
-          : createMempalaceBridge({ cwd, config: resolved });
+          : createMempalaceBridge({ cwd, config: resolved, runtime: bridgeRuntime });
         await bridge.execute({
           action: "diary_write",
           agent_name: diary.metadata.agent_name,
@@ -359,7 +505,7 @@ export function registerMempalaceHooks(
           topic: diary.metadata.topic,
           entry: diary.entry,
           source_file: diary.metadata.source_file,
-          timeout: resolved.timeouts.hookMs,
+          timeout: hookTimeoutSeconds(resolved.timeouts.hookMs), /* seconds; bridge multiplies by 1000 */
         });
       } catch {
         // Shutdown must never be delayed or failed by MemPalace diary writes.
@@ -367,4 +513,6 @@ export function registerMempalaceHooks(
       return undefined;
     });
   }
+
+  platform.on("session_shutdown", clearForSession);
 }

package/src/mempalace/installer-helper.ts

@@ -6,7 +6,7 @@ import type { SupipowersConfig } from "../types.js";
 import { createMempalaceBridge, type MempalaceBridgeFacade } from "./bridge.js";
 import { resolveDefaultWing, resolveMempalaceConfig } from "./config.js";
 import {
-  resolveBridgeScriptPath,
+  resolveInstalledBridgeScriptPath,
   resolveManagedVenvPaths,
   setupMempalaceRuntime,
   type ProcessRunner,
@@ -44,7 +44,7 @@ export function snapshotMempalaceInstall(
   const managedBinDir = paths.global("bin");
   const uvBinary = process.platform === "win32" ? "uv.exe" : "uv";
   const uvPath = path.join(managedBinDir, uvBinary);
-  const bridge = resolveBridgeScriptPath();
+  const bridge = resolveInstalledBridgeScriptPath(paths);
 
   const uvInstalled = existsSync(uvPath);
   const venvInstalled = existsSync(venv.python);
@@ -85,7 +85,7 @@ export async function runMempalaceSetup(
 ): Promise<SetupMempalaceRuntimeResult> {
   const config = options.config ?? DEFAULT_CONFIG;
   const resolved = resolveMempalaceConfig(config, options.cwd, options.paths);
-  const bridge = resolveBridgeScriptPath();
+  const bridge = resolveInstalledBridgeScriptPath(options.paths);
   if (!bridge.ok) {
     return { ok: false, error: bridge.error };
   }
@@ -109,6 +109,16 @@ export interface MempalaceInitState {
 function isWingPresent(result: unknown, wing: string): boolean {
   if (!result || typeof result !== "object") return false;
   const record = result as Record<string, unknown>;
+
+  // tool_list_wings returns `{ wings: { <name>: <count>, ... } }`. The
+  // dict shape is the canonical one from mempalace.mcp_server. Older
+  // / partial responses may carry array shapes (items/results), so we
+  // accept both rather than coupling tightly.
+  const wings = record.wings;
+  if (wings && typeof wings === "object" && !Array.isArray(wings)) {
+    if (Object.prototype.hasOwnProperty.call(wings, wing)) return true;
+  }
+
   const candidates = [record.wings, record.items, record.results];
   for (const list of candidates) {
     if (!Array.isArray(list)) continue;
@@ -145,7 +155,11 @@ export async function checkMempalaceProjectInitialized(options: {
   } catch {
     wing = "project";
   }
-  const bridge = options.bridge ?? createMempalaceBridge({ cwd: options.cwd, config: resolved });
+  const bridge = options.bridge ?? createMempalaceBridge({
+    cwd: options.cwd,
+    config: resolved,
+    runtime: { resolveBridgeScriptPath: () => resolveInstalledBridgeScriptPath(options.paths) },
+  });
   const result = await bridge.execute({ action: "list_wings" });
   if (!result.ok) {
     return {