@t2000/engine 1.24.11 → 1.24.12

package/dist/index.d.ts

@@ -53,25 +53,6 @@ declare function extractAllProactiveMarkers(text: string): Array<{
     subjectKey: string;
 }>;
 
-type PostWritePollOutcome = 'detected_change' | 'ceiling' | 'aborted' | 'fallback_no_baseline' | 'fallback_no_address' | 'fallback_no_rpc';
-interface PostWritePollResult {
-    outcome: PostWritePollOutcome;
-    /** Number of poll attempts made (0 if fallback fired before polling). */
-    attempts: number;
-    /** Wall-clock ms from `pollForIndexerCatchup` entry to return. */
-    resolvedAtMs: number;
-}
-interface PostWritePollOptions {
-    suiRpcUrl: string | undefined;
-    address: string | undefined;
-    /** Hard ceiling on total wait time. Default 1500ms (matches old fixed sleep). */
-    ceilingMs: number;
-    /** Wait between poll attempts. Default 250ms. */
-    pollIntervalMs: number;
-    signal: AbortSignal;
-}
-declare function pollForIndexerCatchup(options: PostWritePollOptions): Promise<PostWritePollResult>;
-
 /** Rough token count for a message array. */
 declare function estimateTokens(messages: Message[]): number;
 interface CompactOptions {
@@ -1736,41 +1717,6 @@ interface EngineConfig {
      * Omit (undefined / empty map) to disable post-write refresh entirely.
      */
     postWriteRefresh?: Record<string, string[]>;
-    /**
-     * [SPEC 19 Phase B / 2026-05-09] Pre-warmed indexer-catchup poll Promise.
-     *
-     * Hosts that know the wallet address + Sui RPC URL the moment a resume
-     * request lands (e.g. `app/api/engine/resume/route.ts`, where both are
-     * available immediately after JWT validation) can fire
-     * `pollForIndexerCatchup` in parallel with `createEngine` and pass the
-     * returned Promise here. The engine awaits this Promise inside
-     * `runPostWriteRefresh` instead of starting a fresh poll, eliminating
-     * up to ~1.5s of serial wait when engine boot wall-clock ≥ poll
-     * wall-clock.
-     *
-     * Behavior:
-     *   - Promise resolves before refresh starts → instant pass-through
-     *     (poll already done during boot). This is the typical case.
-     *   - Promise still pending when refresh starts → engine awaits it.
-     *     Net effect: same as pre-Phase-B fresh-poll behavior.
-     *   - Promise undefined → engine starts a fresh poll (pre-Phase-B path).
-     *   - Promise rejects → engine logs warn + falls back to fresh poll
-     *     (correctness preserved; same as `outcome: 'fallback_*'`).
-     *
-     * Telemetry: `engine.pwr.sleep_ms` carries `source` tag = `'pre-warmed' | 'engine'`
-     * so the host can verify the parallelization is shaving wall-clock.
-     * On the pre-warmed path, the `outcome` + `attempts` tags are inherited
-     * from the host's poll result — same shape, just resolved earlier.
-     *
-     * Safe because:
-     *   - Poll baseline is captured via Sui RPC `getAllBalances` and is
-     *     independent of any BlockVision cache state. Pre-firing the poll
-     *     before engine boot does NOT race the engine's cache invalidation.
-     *   - The poll's correctness contract (never proceed until indexer
-     *     reflects the write) is preserved — it just runs on a different
-     *     timeline.
-     */
-    indexerCatchupPromise?: Promise<PostWritePollResult>;
 }
 interface LLMProvider {
     chat(params: ChatParams): AsyncGenerator<ProviderEvent>;
@@ -1921,7 +1867,6 @@ declare class QueryEngine {
     private readonly blockvisionApiKey;
     private readonly portfolioCache;
     private readonly postWriteRefresh;
-    private readonly indexerCatchupPromise;
     private matchedRecipe;
     private messages;
     private abortController;
@@ -2071,6 +2016,25 @@ declare class QueryEngine {
  */
 declare function validateHistory(messages: Message[]): Message[];
 
+type PostWritePollOutcome = 'detected_change' | 'ceiling' | 'aborted' | 'fallback_no_baseline' | 'fallback_no_address' | 'fallback_no_rpc';
+interface PostWritePollResult {
+    outcome: PostWritePollOutcome;
+    /** Number of poll attempts made (0 if fallback fired before polling). */
+    attempts: number;
+    /** Wall-clock ms from `pollForIndexerCatchup` entry to return. */
+    resolvedAtMs: number;
+}
+interface PostWritePollOptions {
+    suiRpcUrl: string | undefined;
+    address: string | undefined;
+    /** Hard ceiling on total wait time. Default 1500ms (matches old fixed sleep). */
+    ceilingMs: number;
+    /** Wait between poll attempts. Default 250ms. */
+    pollIntervalMs: number;
+    signal: AbortSignal;
+}
+declare function pollForIndexerCatchup(options: PostWritePollOptions): Promise<PostWritePollResult>;
+
 /**
  * SPEC 7 v0.3 Quote-Refresh ReviewCard — per-tool result freshness budgets.
  *

package/dist/index.js

@@ -5786,120 +5786,6 @@ Only offer to execute actions you have tools for. If you retrieved a quote, data
 - Cap: at most ONE proactive block per turn.
 - Skip proactive blocks when nothing notable changed since the last turn, when the user is mid-flow on something else, or when you'd just be restating the financial-context block. Quality over quantity \u2014 a block ignored is worse than no block.`;
 
-// src/post-write-poll.ts
-async function pollForIndexerCatchup(options) {
-  const { suiRpcUrl, address, ceilingMs, pollIntervalMs, signal } = options;
-  const start = Date.now();
-  if (!suiRpcUrl) {
-    await sleepWithFallback(ceilingMs, signal);
-    return {
-      outcome: "fallback_no_rpc",
-      attempts: 0,
-      resolvedAtMs: Date.now() - start
-    };
-  }
-  if (!address) {
-    await sleepWithFallback(ceilingMs, signal);
-    return {
-      outcome: "fallback_no_address",
-      attempts: 0,
-      resolvedAtMs: Date.now() - start
-    };
-  }
-  let baseline;
-  try {
-    const coins = await fetchWalletCoins(address, suiRpcUrl);
-    baseline = new Map(
-      coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
-    );
-  } catch (err) {
-    console.warn(
-      "[post-write-poll] baseline fetch failed; falling back to fixed sleep:",
-      err
-    );
-    await sleepWithFallback(ceilingMs, signal);
-    return {
-      outcome: "fallback_no_baseline",
-      attempts: 0,
-      resolvedAtMs: Date.now() - start
-    };
-  }
-  const maxAttempts = Math.max(1, Math.floor(ceilingMs / pollIntervalMs));
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    if (signal.aborted) {
-      return {
-        outcome: "aborted",
-        attempts: attempt - 1,
-        resolvedAtMs: Date.now() - start
-      };
-    }
-    await new Promise((resolve) => {
-      const t = setTimeout(resolve, pollIntervalMs);
-      signal.addEventListener(
-        "abort",
-        () => {
-          clearTimeout(t);
-          resolve();
-        },
-        { once: true }
-      );
-    });
-    if (signal.aborted) {
-      return {
-        outcome: "aborted",
-        attempts: attempt,
-        resolvedAtMs: Date.now() - start
-      };
-    }
-    let current;
-    try {
-      const coins = await fetchWalletCoins(address, suiRpcUrl);
-      current = new Map(
-        coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
-      );
-    } catch (err) {
-      console.warn(
-        `[post-write-poll] poll attempt ${attempt} failed; continuing:`,
-        err
-      );
-      continue;
-    }
-    if (balancesDiffer(baseline, current)) {
-      return {
-        outcome: "detected_change",
-        attempts: attempt,
-        resolvedAtMs: Date.now() - start
-      };
-    }
-  }
-  return {
-    outcome: "ceiling",
-    attempts: maxAttempts,
-    resolvedAtMs: Date.now() - start
-  };
-}
-function balancesDiffer(a, b) {
-  if (a.size !== b.size) return true;
-  for (const [coinType, balance] of a) {
-    if (b.get(coinType) !== balance) return true;
-  }
-  return false;
-}
-async function sleepWithFallback(ms, signal) {
-  if (signal.aborted) return;
-  await new Promise((resolve) => {
-    const t = setTimeout(resolve, ms);
-    signal.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(t);
-        resolve();
-      },
-      { once: true }
-    );
-  });
-}
-
 // src/proactive-marker.ts
 var VALID_TYPES = /* @__PURE__ */ new Set([
   "idle_balance",
@@ -7506,12 +7392,6 @@ var QueryEngine = class {
   // [v1.5] See `EngineConfig.postWriteRefresh` — drives the post-write
   // synthetic read injection in `resumeWithToolResult`.
   postWriteRefresh;
-  // [SPEC 19 Phase B / 2026-05-09] Pre-warmed indexer-catchup poll Promise.
-  // When provided by the host (resume route fires `pollForIndexerCatchup`
-  // in parallel with `createEngine`), `runPostWriteRefresh` awaits this
-  // instead of starting a fresh poll. See `EngineConfig.indexerCatchupPromise`
-  // for the full design rationale.
-  indexerCatchupPromise;
   matchedRecipe = null;
   messages = [];
   abortController = null;
@@ -7587,7 +7467,6 @@ var QueryEngine = class {
     this.onAutoExecuted = config.onAutoExecuted;
     this.onGuardFired = config.onGuardFired;
     this.postWriteRefresh = config.postWriteRefresh;
-    this.indexerCatchupPromise = config.indexerCatchupPromise;
     this.blockvisionApiKey = config.blockvisionApiKey;
     this.portfolioCache = config.portfolioCache;
     this.tools = config.tools ?? (config.agent ? getDefaultTools() : []);
@@ -7977,6 +7856,10 @@ var QueryEngine = class {
       blockvisionApiKey: this.blockvisionApiKey,
       portfolioCache: this.portfolioCache
     };
+    const canSafetyNet = !!(this.walletAddress && this.suiRpcUrl);
+    const safetyNetBaseline = canSafetyNet ? fetchWalletCoins(this.walletAddress, this.suiRpcUrl).then(
+      (coins) => new Map(coins.map((c) => [c.coinType, BigInt(c.totalBalance)]))
+    ).catch(() => null) : null;
     const cacheInvalidationStart = Date.now();
     if (this.walletAddress) {
       this.portfolioCache?.delete(this.walletAddress);
@@ -7987,45 +7870,10 @@ var QueryEngine = class {
       Date.now() - cacheInvalidationStart,
       { has_wallet: this.walletAddress ? "1" : "0" }
     );
-    const sleepStart = Date.now();
-    let pollResult;
-    let sleepSource = "engine";
-    if (this.indexerCatchupPromise) {
-      try {
-        pollResult = await this.indexerCatchupPromise;
-        sleepSource = "pre-warmed";
-      } catch (err) {
-        console.warn(
-          "[engine.pwr] pre-warmed indexer catchup promise rejected; falling back to fresh poll:",
-          err
-        );
-        pollResult = await pollForIndexerCatchup({
-          suiRpcUrl: this.suiRpcUrl,
-          address: this.walletAddress,
-          ceilingMs: 1500,
-          pollIntervalMs: 250,
-          signal
-        });
-      }
-    } else {
-      pollResult = await pollForIndexerCatchup({
-        suiRpcUrl: this.suiRpcUrl,
-        address: this.walletAddress,
-        ceilingMs: 1500,
-        pollIntervalMs: 250,
-        signal
-      });
-    }
-    getTelemetrySink().histogram(
-      "engine.pwr.sleep_ms",
-      Date.now() - sleepStart,
-      {
-        aborted: signal.aborted ? "1" : "0",
-        outcome: pollResult.outcome,
-        attempts: String(pollResult.attempts),
-        source: sleepSource
-      }
-    );
+    getTelemetrySink().counter("engine.pwr.skipped_sleep_count", {
+      has_wallet: this.walletAddress ? "1" : "0",
+      can_safety_net: canSafetyNet ? "1" : "0"
+    });
     if (signal.aborted) return;
     const refreshStart = Date.now();
     const idStem = `pwr_${action.toolUseId.slice(-6)}`;
@@ -8130,6 +7978,35 @@ var QueryEngine = class {
         is_bundle: isBundle ? "1" : "0"
       }
     );
+    if (safetyNetBaseline && canSafetyNet) {
+      const wallet = this.walletAddress;
+      const rpc = this.suiRpcUrl;
+      void (async () => {
+        try {
+          const [baseline, current] = await Promise.all([
+            safetyNetBaseline,
+            fetchWalletCoins(wallet, rpc).then(
+              (coins) => new Map(
+                coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
+              )
+            ).catch(() => null)
+          ]);
+          if (!baseline || !current) return;
+          const stale = !walletStateChanged(baseline, current);
+          if (stale) {
+            getTelemetrySink().counter(
+              "engine.pwr.observed_stale_balance_check",
+              {
+                stale: "1",
+                is_bundle: isBundle ? "1" : "0",
+                tool_count: String(refreshTools.length)
+              }
+            );
+          }
+        } catch {
+        }
+      })();
+    }
   }
   interrupt() {
     this.abortController?.abort();
@@ -9060,6 +8937,13 @@ ${recipeCtx}`;
     }
   }
 };
+function walletStateChanged(before, after) {
+  if (before.size !== after.size) return true;
+  for (const [coinType, balance] of before) {
+    if (after.get(coinType) !== balance) return true;
+  }
+  return false;
+}
 function isCorruptHistoryError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return msg.includes("tool_use") && msg.includes("tool_result") || msg.includes("roles must alternate") || msg.includes("400") && msg.includes("invalid_request_error");
@@ -9169,6 +9053,120 @@ function harnessShapeForEffort(effort) {
       return "max";
   }
 }
+
+// src/post-write-poll.ts
+async function pollForIndexerCatchup(options) {
+  const { suiRpcUrl, address, ceilingMs, pollIntervalMs, signal } = options;
+  const start = Date.now();
+  if (!suiRpcUrl) {
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_rpc",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  if (!address) {
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_address",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  let baseline;
+  try {
+    const coins = await fetchWalletCoins(address, suiRpcUrl);
+    baseline = new Map(
+      coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
+    );
+  } catch (err) {
+    console.warn(
+      "[post-write-poll] baseline fetch failed; falling back to fixed sleep:",
+      err
+    );
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_baseline",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  const maxAttempts = Math.max(1, Math.floor(ceilingMs / pollIntervalMs));
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (signal.aborted) {
+      return {
+        outcome: "aborted",
+        attempts: attempt - 1,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, pollIntervalMs);
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve();
+        },
+        { once: true }
+      );
+    });
+    if (signal.aborted) {
+      return {
+        outcome: "aborted",
+        attempts: attempt,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+    let current;
+    try {
+      const coins = await fetchWalletCoins(address, suiRpcUrl);
+      current = new Map(
+        coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
+      );
+    } catch (err) {
+      console.warn(
+        `[post-write-poll] poll attempt ${attempt} failed; continuing:`,
+        err
+      );
+      continue;
+    }
+    if (balancesDiffer(baseline, current)) {
+      return {
+        outcome: "detected_change",
+        attempts: attempt,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+  }
+  return {
+    outcome: "ceiling",
+    attempts: maxAttempts,
+    resolvedAtMs: Date.now() - start
+  };
+}
+function balancesDiffer(a, b) {
+  if (a.size !== b.size) return true;
+  for (const [coinType, balance] of a) {
+    if (b.get(coinType) !== balance) return true;
+  }
+  return false;
+}
+async function sleepWithFallback(ms, signal) {
+  if (signal.aborted) return;
+  await new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
 async function regenerateBundle(engine, action) {
   if (action.canRegenerate !== true) {
     return {