@remnic/plugin-pi 9.36.0 → 9.38.0

package/dist/index.js

@@ -1,198 +1,11 @@
 import {
-  REMNIC_PI_EXTENSION_DIR_NAME,
-  resolvePiAgentHome
-} from "./chunk-ASGQGBO2.js";
+  DEFAULT_CONFIG,
+  loadConfig
+} from "./chunk-HRZBFDYV.js";
 
 // src/index.ts
 import { Type } from "@sinclair/typebox";
-
-// src/config.ts
-import { existsSync, readFileSync } from "fs";
-import path from "path";
-import { expandTildePath } from "@remnic/core/utils/path";
-var DEFAULT_CONFIG = {
-  remnicDaemonUrl: "http://127.0.0.1:4318",
-  recallMode: "auto",
-  recallTopK: 8,
-  recallBudgetChars: 12e3,
-  recallEnabled: true,
-  observeEnabled: true,
-  observeSkipExtraction: false,
-  compactionEnabled: true,
-  mcpToolsEnabled: true,
-  statusEnabled: true,
-  requestTimeoutMs: 6e4,
-  startupRequestTimeoutMs: 1e3,
-  // Default 20 s is comfortably under the Pi/omp 30 s handler budget (#1626).
-  turnRequestTimeoutMs: 2e4,
-  // Default 100 KiB leaves headroom under the daemon's 128 KiB default (#1600).
-  observeMaxBytes: 102400,
-  observeMaxRetries: 2,
-  // Base cooldown for the circuit breaker; doubles on consecutive failures (#1626).
-  daemonCooldownMs: 5e3
-};
-function defaultConfigPath(env) {
-  return path.join(resolvePiAgentHome(env), "extensions", REMNIC_PI_EXTENSION_DIR_NAME, "remnic.config.json");
-}
-function coerceBoolean(value, fallback, fieldName) {
-  if (value === void 0 || value === null) return fallback;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "1", "yes", "on"].includes(normalized)) return true;
-    if (["false", "0", "no", "off"].includes(normalized)) return false;
-  }
-  throw new Error(`Invalid boolean value for Remnic Pi config field ${fieldName}`);
-}
-function coercePositiveInt(value, fallback, max, fieldName) {
-  if (value === void 0 || value === null || value === "") return fallback;
-  let parsed;
-  if (typeof value === "number") {
-    parsed = value;
-  } else if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return fallback;
-    if (!/^[+-]?\d+$/.test(trimmed)) {
-      throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
-    }
-    parsed = Number(trimmed);
-  } else {
-    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
-  }
-  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > max) {
-    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 1 to ${max}`);
-  }
-  return parsed;
-}
-function coerceNonNegativeInt(value, fallback, max, fieldName) {
-  if (value === void 0 || value === null || value === "") return fallback;
-  let parsed;
-  if (typeof value === "number") {
-    parsed = value;
-  } else if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) return fallback;
-    if (!/^[+-]?\d+$/.test(trimmed)) {
-      throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 0 to ${max}`);
-    }
-    parsed = Number(trimmed);
-  } else {
-    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 0 to ${max}`);
-  }
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > max) {
-    throw new Error(`Invalid numeric value for Remnic Pi config field ${fieldName}: expected an integer from 0 to ${max}`);
-  }
-  return parsed;
-}
-function coerceOptionalNonEmptyString(value, fieldName) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string" && value.trim().length > 0) return value.trim();
-  throw new Error(`Invalid string value for Remnic Pi config field ${fieldName}`);
-}
-function coerceOptionalString(value, fieldName) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : void 0;
-  }
-  throw new Error(`Invalid string value for Remnic Pi config field ${fieldName}`);
-}
-function coerceOptionalHttpUrl(value, fieldName) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string") {
-    throw new Error(`Invalid URL value for Remnic Pi config field ${fieldName}: expected an http or https URL`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return void 0;
-  try {
-    const parsed = new URL(trimmed);
-    if (parsed.protocol === "http:" || parsed.protocol === "https:") return trimTrailingSlashes(trimmed);
-  } catch {
-  }
-  throw new Error(`Invalid URL value for Remnic Pi config field ${fieldName}: expected an http or https URL`);
-}
-function coerceRecallMode(value) {
-  if (value === void 0 || value === null || value === "") return DEFAULT_CONFIG.recallMode;
-  if (value === "minimal" || value === "full" || value === "graph_mode" || value === "no_recall" || value === "auto") {
-    return value;
-  }
-  throw new Error(`Invalid recallMode value for Remnic Pi config: ${JSON.stringify(value)}`);
-}
-function readConfigFile(configPath) {
-  if (!existsSync(configPath)) return {};
-  try {
-    const raw = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    throw new Error("expected a JSON object");
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to load Remnic Pi config at ${configPath}: ${reason}`);
-  }
-}
-function trimTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
-  return value.slice(0, end);
-}
-function resolveConfigPath(options = {}) {
-  const env = options.env ?? process.env;
-  return expandTildePath(
-    options.configPath || env.REMNIC_PI_CONFIG || env.REMNIC_OMP_CONFIG || defaultConfigPath(env)
-  );
-}
-function loadConfig(options = {}) {
-  const env = options.env ?? process.env;
-  const fileConfig = readConfigFile(resolveConfigPath(options));
-  const daemonUrl = coerceOptionalHttpUrl(fileConfig.remnicDaemonUrl, "remnicDaemonUrl") ?? coerceOptionalHttpUrl(env.REMNIC_DAEMON_URL, "REMNIC_DAEMON_URL") ?? DEFAULT_CONFIG.remnicDaemonUrl;
-  const authToken = coerceOptionalString(fileConfig.authToken, "authToken") ?? coerceOptionalString(env.REMNIC_PI_AUTH_TOKEN, "REMNIC_PI_AUTH_TOKEN");
-  const namespace = coerceOptionalNonEmptyString(fileConfig.namespace, "namespace");
-  const requestTimeoutMs = coercePositiveInt(
-    fileConfig.requestTimeoutMs,
-    DEFAULT_CONFIG.requestTimeoutMs,
-    6e4,
-    "requestTimeoutMs"
-  );
-  const turnFallback = Math.min(requestTimeoutMs, DEFAULT_CONFIG.turnRequestTimeoutMs);
-  const turnRequestTimeoutMs = coercePositiveInt(
-    fileConfig.turnRequestTimeoutMs,
-    turnFallback,
-    25e3,
-    "turnRequestTimeoutMs"
-  );
-  return {
-    remnicDaemonUrl: daemonUrl,
-    authToken,
-    namespace,
-    recallMode: coerceRecallMode(fileConfig.recallMode),
-    recallTopK: coercePositiveInt(fileConfig.recallTopK, DEFAULT_CONFIG.recallTopK, 50, "recallTopK"),
-    recallBudgetChars: coercePositiveInt(fileConfig.recallBudgetChars, DEFAULT_CONFIG.recallBudgetChars, 64e3, "recallBudgetChars"),
-    recallEnabled: coerceBoolean(fileConfig.recallEnabled, DEFAULT_CONFIG.recallEnabled, "recallEnabled"),
-    observeEnabled: coerceBoolean(fileConfig.observeEnabled, DEFAULT_CONFIG.observeEnabled, "observeEnabled"),
-    observeSkipExtraction: coerceBoolean(fileConfig.observeSkipExtraction, DEFAULT_CONFIG.observeSkipExtraction, "observeSkipExtraction"),
-    compactionEnabled: coerceBoolean(fileConfig.compactionEnabled, DEFAULT_CONFIG.compactionEnabled, "compactionEnabled"),
-    mcpToolsEnabled: coerceBoolean(fileConfig.mcpToolsEnabled, DEFAULT_CONFIG.mcpToolsEnabled, "mcpToolsEnabled"),
-    statusEnabled: coerceBoolean(fileConfig.statusEnabled, DEFAULT_CONFIG.statusEnabled, "statusEnabled"),
-    requestTimeoutMs,
-    startupRequestTimeoutMs: coercePositiveInt(
-      fileConfig.startupRequestTimeoutMs,
-      DEFAULT_CONFIG.startupRequestTimeoutMs,
-      6e4,
-      "startupRequestTimeoutMs"
-    ),
-    turnRequestTimeoutMs,
-    observeMaxBytes: coercePositiveInt(
-      fileConfig.observeMaxBytes,
-      DEFAULT_CONFIG.observeMaxBytes,
-      8388608,
-      "observeMaxBytes"
-    ),
-    observeMaxRetries: coerceNonNegativeInt(fileConfig.observeMaxRetries, DEFAULT_CONFIG.observeMaxRetries, 5, "observeMaxRetries"),
-    daemonCooldownMs: coercePositiveInt(fileConfig.daemonCooldownMs, DEFAULT_CONFIG.daemonCooldownMs, 6e4, "daemonCooldownMs")
-  };
-}
+import { createHash as createHash2 } from "crypto";
 
 // src/client.ts
 var RemnicHttpError = class extends Error {
@@ -204,6 +17,20 @@ var RemnicHttpError = class extends Error {
   status;
   code;
 };
+var RemnicRequestTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Remnic request timed out after ${timeoutMs}ms`);
+    this.name = "RemnicRequestTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var RemnicRequestAbortedError = class extends Error {
+  constructor() {
+    super("Remnic request aborted");
+    this.name = "RemnicRequestAbortedError";
+  }
+};
 var encoder = new TextEncoder();
 var RETRY_BASE_DELAY_MS = 200;
 var MAX_COOLDOWN_MS = 6e4;
@@ -255,11 +82,11 @@ var RemnicClient = class {
     if (sessionKey) params.set("session", sessionKey);
     params.set("op", this.config.observeEnabled ? "observe" : "memory_store");
     const qs = params.toString();
-    const path2 = `/engram/v1/namespace/writable${qs ? `?${qs}` : ""}`;
+    const path = `/engram/v1/namespace/writable${qs ? `?${qs}` : ""}`;
     try {
       const payload = await this.request(
         "GET",
-        path2,
+        path,
         void 0,
         options
       );
@@ -310,6 +137,7 @@ var RemnicClient = class {
     const turnBudgetMs = options.timeoutMs ?? this.config.turnRequestTimeoutMs;
     const retryOptions = {
       timeoutMs: turnBudgetMs,
+      signal: options.signal,
       maxRetries: options.maxRetries ?? this.config.observeMaxRetries
     };
     const chunks = chunkObservePayload(this.config, sessionKey, cwd, messages, maxBytes);
@@ -381,11 +209,11 @@ var RemnicClient = class {
     const tools = result.tools;
     return Array.isArray(tools) ? tools.filter(isMcpTool) : [];
   }
-  async mcpTool(name, args) {
+  async mcpTool(name, args, options = {}) {
     return this.mcpRequest("tools/call", {
       name,
       arguments: args
-    });
+    }, options);
   }
   /**
    * Single HTTP attempt with the configured timeout. No retry — retry of
@@ -393,9 +221,23 @@ var RemnicClient = class {
    */
   async request(method, pathname, body, options = {}) {
     const controller = new AbortController();
+    let timedOut = false;
+    const onExternalAbort = () => controller.abort();
+    if (options.signal?.aborted) {
+      throw new RemnicRequestAbortedError();
+    }
+    options.signal?.addEventListener("abort", onExternalAbort, { once: true });
     const override = options.timeoutMs;
-    const timeoutMs = typeof override === "number" && Number.isFinite(override) && override > 0 ? override : this.config.requestTimeoutMs;
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const timeoutMs = override === void 0 ? this.config.requestTimeoutMs : (() => {
+      if (!Number.isInteger(override) || override <= 0) {
+        throw new TypeError("Request timeoutMs must be a positive integer");
+      }
+      return override;
+    })();
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
     try {
       const response = await fetch(`${this.config.remnicDaemonUrl}${pathname}`, {
         method,
@@ -432,12 +274,12 @@ var RemnicClient = class {
       }
       return payload;
     } catch (err) {
-      if (isAbortError(err)) {
-        throw new Error(`Remnic request timed out after ${timeoutMs}ms`);
-      }
+      if (timedOut) throw new RemnicRequestTimeoutError(timeoutMs);
+      if (options.signal?.aborted) throw new RemnicRequestAbortedError();
       throw err;
     } finally {
       clearTimeout(timeout);
+      options.signal?.removeEventListener("abort", onExternalAbort);
     }
   }
   /**
@@ -469,7 +311,7 @@ var RemnicClient = class {
             );
           }
         }
-        await sleep(delayMs);
+        await sleep(delayMs, options.signal);
         attempt += 1;
         if (hasDeadline) {
           const remaining = deadline - Date.now();
@@ -523,8 +365,19 @@ function isTransientNetworkError(err) {
   }
   return false;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.reject(new RemnicRequestAbortedError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new RemnicRequestAbortedError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function jsonBytes(value) {
   return encoder.encode(JSON.stringify(value)).length;
@@ -661,21 +514,6 @@ function textFromMessage(message) {
   }
   return textFromContent(obj.content).trim();
 }
-function latestUserRecallTarget(messages) {
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index];
-    if (isExcludedFromContext(message) || isRemnicInjected(message)) continue;
-    if (message?.role !== "user") continue;
-    const query = textFromMessage(message);
-    if (query.length === 0) continue;
-    const identity = stableObservedMessageIdentity(message);
-    return {
-      query,
-      dedupeKey: identity ? `message:${identity}:${query}` : `query:${query}`
-    };
-  }
-  return null;
-}
 function toObserveMessage(message) {
   if (!message || typeof message !== "object") return null;
   const obj = message;
@@ -777,6 +615,61 @@ function stableObservedMessageIdentity(rawContent) {
   return null;
 }
 
+// src/recall-timeout-breaker.ts
+function isRecallTimeoutError(err) {
+  return err instanceof RemnicRequestTimeoutError;
+}
+var RecallTimeoutBreaker = class {
+  tripped = false;
+  results = [];
+  threshold;
+  windowSize;
+  abortController = new AbortController();
+  constructor(options) {
+    const { threshold, window } = options;
+    if (typeof threshold !== "number" || !Number.isInteger(threshold) || threshold <= 0 || typeof window !== "number" || !Number.isInteger(window) || window <= 0 || threshold > window) {
+      throw new Error(
+        `Invalid RecallTimeoutBreaker options: threshold and window must be positive integers with threshold <= window (got threshold=${threshold}, window=${window})`
+      );
+    }
+    this.threshold = threshold;
+    this.windowSize = window;
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  isTripped() {
+    return this.tripped;
+  }
+  recordSuccess() {
+    this.record("success");
+  }
+  recordTimeout() {
+    return this.record("timeout");
+  }
+  recordFailure() {
+    this.record("failure");
+  }
+  record(result) {
+    if (this.tripped) return false;
+    this.results.push(result === "timeout");
+    if (this.results.length > this.windowSize) this.results.shift();
+    if (this.timeoutCount() >= this.threshold) {
+      this.tripped = true;
+      this.abortController.abort();
+      return true;
+    }
+    return false;
+  }
+  timeoutCount() {
+    let count = 0;
+    for (const timedOut of this.results) {
+      if (timedOut) count += 1;
+    }
+    return count;
+  }
+};
+
 // src/index.ts
 var STATE_CUSTOM_TYPE = "remnic_state";
 var MAX_OBSERVED_HASHES = 2e3;
@@ -784,57 +677,93 @@ var MAX_SESSION_STATES = 50;
 var MAX_CONTEXT_CHARS = 12e3;
 var TRUNCATION_NOTICE = "\n\n[Remnic context truncated]";
 var SESSION_OWNED_FIELDS = /* @__PURE__ */ new Set(["sessionKey", "namespace", "cwd"]);
+var RECALL_BREAKER_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("remnic.plugin-pi.recall-timeout-breakers");
+var recallBreakerRegistry = globalThis;
+var PROCESS_SCOPED_RECALL_BREAKERS = recallBreakerRegistry[RECALL_BREAKER_REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+var RECALL_PRODUCING_TOOL_NAMES = {
+  "remnic.recall": true,
+  "remnic.recall_xray": true
+};
+function recallTimeoutBreakerCacheKey(config) {
+  return JSON.stringify([
+    config.remnicDaemonUrl,
+    config.namespace ?? "",
+    createHash2("sha256").update(config.authToken ?? "").digest("hex"),
+    config.recallTimeoutThreshold,
+    config.recallTimeoutWindow
+  ]);
+}
+function resetProcessRecallBreakerForTest(config) {
+  PROCESS_SCOPED_RECALL_BREAKERS.delete(recallTimeoutBreakerCacheKey(config));
+}
 function createRemnicPiExtension(options = {}) {
-  const config = options.config ?? loadConfig(options);
+  const config = { ...DEFAULT_CONFIG, ...options.config ?? loadConfig(options) };
   const client = new RemnicClient(config);
   const sessionStates = /* @__PURE__ */ new Map();
+  const breakerKey = recallTimeoutBreakerCacheKey(config);
+  let recallTimeoutBreaker = PROCESS_SCOPED_RECALL_BREAKERS.get(breakerKey);
+  if (!recallTimeoutBreaker) {
+    recallTimeoutBreaker = new RecallTimeoutBreaker({
+      threshold: config.recallTimeoutThreshold,
+      window: config.recallTimeoutWindow
+    });
+    PROCESS_SCOPED_RECALL_BREAKERS.set(breakerKey, recallTimeoutBreaker);
+  }
   return async function remnicPiExtension2(pi) {
     pi.on("session_start", async (_event, ctx) => {
       const session = snapshotPiContext(ctx, { includeSessionHistory: true });
       if (!session) return;
       const { state } = getSessionState(session.sessionKey, sessionStates);
       restoreObservedState(session, state.observedHashes);
+      state.cachedContext = null;
+      state.recallCompleted = false;
       const probe = await probeDaemonHealth(client, config);
       if (config.statusEnabled) {
-        session.setStatus("remnic", remnicStatusLabel(probe, config.namespace));
+        session.setStatus(
+          "remnic",
+          recallTimeoutBreaker.isTripped() ? RECALL_DISABLED_STATUS : remnicStatusLabel(probe, config.namespace)
+        );
       }
       await runNamespacePreflight(pi, session, client, config);
     });
-    pi.on("context", async (event, ctx) => {
+    pi.on("before_agent_start", async (event, ctx) => {
       const session = snapshotPiContext(ctx);
       if (!session) return;
-      if (!config.recallEnabled || !config.authToken) return;
-      if (!client.isReachable()) return;
-      const recallTarget = latestUserRecallTarget(Array.isArray(event.messages) ? event.messages : []);
-      if (!recallTarget) return;
-      const { query } = recallTarget;
       const { state } = getSessionState(session.sessionKey, sessionStates);
-      if (recallTarget.dedupeKey === state.lastInjectedRecallKey) return;
-      try {
-        const recalled = await client.recall(query, session.sessionKey, session.cwd, {
-          timeoutMs: config.turnRequestTimeoutMs
-        });
-        client.markReachable();
-        const context = trimContext(recalled.context ?? "", config.recallBudgetChars);
-        if (!context) return;
-        state.lastInjectedRecallKey = recallTarget.dedupeKey;
-        return {
-          messages: [
-            ...event.messages,
-            {
-              role: "user",
-              content: [{ type: "text", text: `Remnic recalled context for this turn:
-
-${context}` }],
-              remnicInjected: true,
-              timestamp: Date.now()
+      if (!state.recallCompleted && config.recallEnabled && config.authToken && client.isReachable()) {
+        const promptText = typeof event.prompt === "string" && event.prompt.trim().length > 0 ? event.prompt : "";
+        if (promptText) {
+          state.recallCompleted = true;
+          try {
+            const recalled = await executeRecallWithBreaker(
+              (signal) => client.recall(promptText, session.sessionKey, session.cwd, {
+                timeoutMs: config.turnRequestTimeoutMs,
+                signal
+              }),
+              recallTimeoutBreaker,
+              pi,
+              session,
+              config
+            );
+            client.markReachable();
+            const context = trimContext(recalled.context ?? "", config.recallBudgetChars);
+            if (context) {
+              state.cachedContext = context;
             }
-          ]
-        };
-      } catch (err) {
-        if (isDaemonUnreachableError(err)) client.markUnreachable(config.daemonCooldownMs);
-        session.notify(`Remnic recall unavailable: ${errorMessage(err)}`, "warning");
+          } catch (err) {
+            if (recallTimeoutBreaker.isTripped()) return;
+            if (isDaemonUnreachableError(err)) client.markUnreachable(config.daemonCooldownMs);
+            session.notify(`Remnic recall unavailable: ${errorMessage(err)}`, "warning");
+          }
+        }
       }
+      if (!state.cachedContext) return;
+      const basePrompt = typeof event.systemPrompt === "string" ? event.systemPrompt : "";
+      return {
+        systemPrompt: `${basePrompt}
+
+${state.cachedContext}`
+      };
     });
     pi.on("message_end", async (event, ctx) => {
       const session = snapshotPiContext(ctx);
@@ -905,19 +834,20 @@ ${context}` }],
         }
       };
     });
-    registerCommands(pi, client, config);
+    registerCommands(pi, client, config, recallTimeoutBreaker);
     if (config.mcpToolsEnabled && config.authToken) {
-      await registerMcpTools(pi, client, config);
+      await registerMcpTools(pi, client, config, recallTimeoutBreaker);
     }
   };
 }
 async function remnicPiExtension(pi) {
   await createRemnicPiExtension()(pi);
 }
-function registerCommands(pi, client, config) {
+function registerCommands(pi, client, config, recallTimeoutBreaker) {
   pi.registerCommand("remnic-status", {
     description: "Check Remnic daemon status",
     handler: commandHandler(async (_args, _ctx, session) => {
+      if (recallTimeoutBreaker.isTripped()) notifyRecallDisabled(session);
       const health = await client.health();
       client.markReachable();
       session.notify(`Remnic ${health.ok ? "healthy" : "unhealthy"} at ${config.remnicDaemonUrl}`, health.ok ? "success" : "warning");
@@ -931,9 +861,20 @@ function registerCommands(pi, client, config) {
         session.notify("Usage: /remnic-recall <query>", "warning");
         return;
       }
-      const result = await client.recall(query, session.sessionKey, session.cwd, {
-        timeoutMs: config.requestTimeoutMs
-      });
+      if (recallTimeoutBreaker.isTripped()) {
+        notifyRecallDisabled(session);
+        return;
+      }
+      const result = await executeRecallWithBreaker(
+        (signal) => client.recall(query, session.sessionKey, session.cwd, {
+          timeoutMs: config.requestTimeoutMs,
+          signal
+        }),
+        recallTimeoutBreaker,
+        pi,
+        session,
+        config
+      );
       client.markReachable();
       session.notify(trimContext(result.context ?? "(no Remnic context)", MAX_CONTEXT_CHARS), "info");
     })
@@ -988,7 +929,7 @@ function commandHandler(handler) {
     }
   };
 }
-async function registerMcpTools(pi, client, config) {
+async function registerMcpTools(pi, client, config, recallTimeoutBreaker) {
   let tools = [];
   try {
     tools = await client.mcpListTools({ timeoutMs: config.startupRequestTimeoutMs });
@@ -1003,7 +944,7 @@ async function registerMcpTools(pi, client, config) {
       label: tool.name,
       description: tool.description ?? `Call ${tool.name}`,
       parameters: toPiToolParametersSchema(tool.inputSchema),
-      async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         const session = snapshotPiContext(ctx);
         if (!session) {
           return {
@@ -1011,13 +952,29 @@ async function registerMcpTools(pi, client, config) {
             details: { skipped: true, reason: "stale_context" }
           };
         }
+        if (recallTimeoutBreaker.isTripped() && RECALL_PRODUCING_TOOL_NAMES[tool.name] === true) {
+          const message = notifyRecallDisabled(session);
+          return {
+            content: [{ type: "text", text: message }],
+            details: { skipped: true, reason: "recall_timeout_breaker" }
+          };
+        }
         const safeParams = stripSessionOwnedRuntimeFields(params ?? {});
-        const result = await client.mcpTool(tool.name, {
+        const toolArguments = {
           ...safeParams,
           sessionKey: session.sessionKey,
           namespace: config.namespace,
           cwd: session.cwd
-        });
+        };
+        const result = RECALL_PRODUCING_TOOL_NAMES[tool.name] === true ? await executeRecallWithBreaker(
+          (breakerSignal) => client.mcpTool(tool.name, toolArguments, {
+            signal: signal ? AbortSignal.any([signal, breakerSignal]) : breakerSignal
+          }),
+          recallTimeoutBreaker,
+          pi,
+          session,
+          config
+        ) : await client.mcpTool(tool.name, toolArguments, { signal });
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           details: result
@@ -1094,7 +1051,8 @@ function getSessionState(sessionKey, states) {
     state = {
       observedHashes: /* @__PURE__ */ new Set(),
       liveObservedReplayKeys: /* @__PURE__ */ new Map(),
-      lastInjectedRecallKey: ""
+      cachedContext: null,
+      recallCompleted: false
     };
     states.set(sessionKey, state);
     pruneSessionStates(states);
@@ -1393,6 +1351,43 @@ function isDaemonUnreachableError(err) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+function notifyRecallDisabled(session) {
+  const message = "Remnic recall is disabled for this process because timeouts delayed operations; memory recall is unavailable until restart.";
+  session.notify(message, "warning");
+  return message;
+}
+var RECALL_DISABLED_STATUS = "Remnic recall disabled until restart (timeouts delayed operations)";
+function emitRecallTimeoutTrip(pi, session, config, err) {
+  const message = `Remnic recall has been disabled for this process because repeated timeouts delayed operations. Memory recall is unavailable until restart (${config.recallTimeoutThreshold} timeouts in the last ${config.recallTimeoutWindow} recall attempts).`;
+  session.notify(message, "warning");
+  if (config.statusEnabled) {
+    session.setStatus("remnic", RECALL_DISABLED_STATUS);
+  }
+  pi.appendEntry(STATE_CUSTOM_TYPE, {
+    level: "warning",
+    code: "RECALL_TIMEOUT_TRIP",
+    threshold: config.recallTimeoutThreshold,
+    window: config.recallTimeoutWindow,
+    reason: "Recall disabled until restart because timeouts delayed operations",
+    message,
+    error: errorMessage(err),
+    disabledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    persistent: true
+  });
+}
+async function executeRecallWithBreaker(operation, breaker, pi, session, config) {
+  try {
+    const result = await operation(breaker.signal);
+    breaker.recordSuccess();
+    return result;
+  } catch (err) {
+    if (!(breaker.isTripped() && err instanceof RemnicRequestAbortedError)) {
+      const tripped = breaker.record(isRecallTimeoutError(err) ? "timeout" : "failure");
+      if (tripped) emitRecallTimeoutTrip(pi, session, config, err);
+    }
+    throw err;
+  }
+}
 function finiteTokenCount(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 }
@@ -1405,6 +1400,7 @@ export {
   remnicPiExtension as default,
   isDaemonUnreachableError,
   observeMessages,
+  resetProcessRecallBreakerForTest,
   stripSessionOwnedRuntimeFields,
   stripSessionOwnedSchemaFields,
   textFromMessage,