@remnic/core 1.1.31 → 9.3.516

package/src/recall-state.ts

@@ -2,6 +2,7 @@ import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { log } from "./logger.js";
+import { writeFileAtomically } from "./maintenance/atomic-file.js";
 import type {
   IdentityInjectionMode,
   RecallPlanMode,
@@ -120,6 +121,7 @@ export function clampGraphRecallExpandedEntries(
 }
 
 type LastRecallState = Record<string, LastRecallSnapshot>;
+type StateFileWriter = (filePath: string, content: string) => Promise<void>;
 
 /**
  * Deep-copy a RecallTierExplain block.  Used by both the write path
@@ -193,11 +195,18 @@ const DEFAULT_TIER_MIGRATION_STATUS: TierMigrationStatusSnapshot = {
 export class LastRecallStore {
   private readonly statePath: string;
   private readonly impressionsPath: string;
+  private readonly writeStateFile: StateFileWriter;
   private state: LastRecallState = {};
+  private stateWriteChain: Promise<void> = Promise.resolve();
 
-  constructor(memoryDir: string) {
+  constructor(memoryDir: string, options: { writeStateFile?: StateFileWriter } = {}) {
     this.statePath = path.join(memoryDir, "state", "last_recall.json");
     this.impressionsPath = path.join(memoryDir, "state", "recall_impressions.jsonl");
+    this.writeStateFile =
+      options.writeStateFile ??
+      (async (filePath, content) => {
+        await writeFileAtomically(filePath, content);
+      });
   }
 
   async load(): Promise<void> {
@@ -310,8 +319,7 @@ export class LastRecallStore {
     }
 
     try {
-      await mkdir(path.dirname(this.statePath), { recursive: true });
-      await writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await this.flushState();
     } catch (err) {
       log.debug(`last recall store write failed: ${err}`);
     }
@@ -370,12 +378,23 @@ export class LastRecallStore {
       tierExplain: cloneTierExplain(tierExplain),
     };
     try {
-      await mkdir(path.dirname(this.statePath), { recursive: true });
-      await writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await this.flushState();
     } catch (err) {
       log.debug(`last recall tier-explain annotate failed: ${err}`);
     }
   }
+
+  private flushState(): Promise<void> {
+    const run = this.stateWriteChain.catch(() => undefined).then(async () => {
+      await mkdir(path.dirname(this.statePath), { recursive: true });
+      await this.writeStateFile(this.statePath, JSON.stringify(this.state, null, 2));
+    });
+    this.stateWriteChain = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
 }
 
 export class TierMigrationStatusStore {

package/src/relevance.ts

@@ -1,16 +1,25 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { log } from "./logger.js";
+import { writeFileAtomically } from "./maintenance/atomic-file.js";
 import type { RelevanceFeedback } from "./types.js";
 
 type RelevanceState = Record<string, RelevanceFeedback>;
+type StateFileWriter = (filePath: string, content: string) => Promise<void>;
 
 export class RelevanceStore {
   private readonly statePath: string;
+  private readonly writeStateFile: StateFileWriter;
   private state: RelevanceState = {};
+  private stateWriteChain: Promise<void> = Promise.resolve();
 
-  constructor(memoryDir: string) {
+  constructor(memoryDir: string, options: { writeStateFile?: StateFileWriter } = {}) {
     this.statePath = path.join(memoryDir, "state", "relevance.json");
+    this.writeStateFile =
+      options.writeStateFile ??
+      (async (filePath, content) => {
+        await writeFileAtomically(filePath, content);
+      });
   }
 
   async load(): Promise<void> {
@@ -41,8 +50,7 @@ export class RelevanceStore {
     this.state[memoryId] = next;
 
     try {
-      await mkdir(path.dirname(this.statePath), { recursive: true });
-      await writeFile(this.statePath, JSON.stringify(this.state, null, 2), "utf-8");
+      await this.flushState();
     } catch (err) {
       log.debug(`relevance store write failed: ${err}`);
     }
@@ -63,5 +71,16 @@ export class RelevanceStore {
     // Typical QMD scores are around 0-1; keep adjustments small.
     return up * 0.05 - down * 0.10; // max +0.15, min -0.30
   }
-}
 
+  private flushState(): Promise<void> {
+    const run = this.stateWriteChain.catch(() => undefined).then(async () => {
+      await mkdir(path.dirname(this.statePath), { recursive: true });
+      await this.writeStateFile(this.statePath, JSON.stringify(this.state, null, 2));
+    });
+    this.stateWriteChain = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+}

package/src/replay/normalizers/chatgpt.ts

@@ -66,16 +66,19 @@ function extractFromMapping(conversation: Record<string, unknown>): Array<Record
 export const chatgptReplayNormalizer: ReplayNormalizer = {
   source: "chatgpt",
   parse(input: unknown, options: ReplayParseOptions = {}): ReplayParseResult {
+    const warnings: ReplayParseResult["warnings"] = [];
     let parsedInput = input;
     if (typeof input === "string") {
       try {
         parsedInput = JSON.parse(input);
-      } catch {
+      } catch (error) {
+        const message = `Invalid ChatGPT replay JSON: ${error instanceof Error ? error.message : String(error)}`;
+        if (options.strict) throw new Error(message);
+        warnings.push({ code: "replay.chatgpt.json.invalid", message });
         parsedInput = [];
       }
     }
 
-    const warnings: ReplayParseResult["warnings"] = [];
     const turns: ReplayTurn[] = [];
 
     const conversations = gatherConversations(parsedInput);
@@ -88,11 +91,18 @@ export const chatgptReplayNormalizer: ReplayNormalizer = {
       const fallbackSessionKey = options.defaultSessionKey?.trim() || sessionKey;
 
       const messageRows = Array.isArray(conversation.messages)
-        ? conversation.messages.filter((item): item is Record<string, unknown> => !!item && typeof item === "object")
+        ? conversation.messages
         : extractFromMapping(conversation);
 
       for (let j = 0; j < messageRows.length; j += 1) {
-        const row = messageRows[j];
+        const rawRow = messageRows[j];
+        if (!rawRow || typeof rawRow !== "object") {
+          const message = `Skipping malformed ChatGPT replay message at conversation ${i + 1}, index ${j}.`;
+          if (options.strict) throw new Error(message);
+          warnings.push({ code: "replay.chatgpt.message.invalid", message, index: j });
+          continue;
+        }
+        const row = rawRow as Record<string, unknown>;
         const role = normalizeReplayRole(
           (row.author as Record<string, unknown> | undefined)?.role ?? row.role,
         );

package/src/replay/normalizers/claude.ts

@@ -25,16 +25,19 @@ function gatherConversations(input: unknown): Array<Record<string, unknown>> {
 export const claudeReplayNormalizer: ReplayNormalizer = {
   source: "claude",
   parse(input: unknown, options: ReplayParseOptions = {}): ReplayParseResult {
+    const warnings: ReplayParseResult["warnings"] = [];
     let parsedInput = input;
     if (typeof input === "string") {
       try {
         parsedInput = JSON.parse(input);
-      } catch {
+      } catch (error) {
+        const message = `Invalid Claude replay JSON: ${error instanceof Error ? error.message : String(error)}`;
+        if (options.strict) throw new Error(message);
+        warnings.push({ code: "replay.claude.json.invalid", message });
         parsedInput = [];
       }
     }
 
-    const warnings: ReplayParseResult["warnings"] = [];
     const turns: ReplayTurn[] = [];
     const conversations = gatherConversations(parsedInput);
 
@@ -55,9 +58,11 @@ export const claudeReplayNormalizer: ReplayNormalizer = {
       for (let j = 0; j < messagesRaw.length; j += 1) {
         const msg = messagesRaw[j];
         if (!msg || typeof msg !== "object") {
+          const message = `Skipping malformed Claude message at conversation ${i + 1}, index ${j}.`;
+          if (options.strict) throw new Error(message);
           warnings.push({
             code: "replay.claude.message.invalid",
-            message: `Skipping malformed Claude message at conversation ${i + 1}, index ${j}.`,
+            message,
             index: j,
           });
           continue;

package/src/replay/normalizers/openclaw.ts

@@ -6,7 +6,11 @@ import {
 } from "../types.js";
 import { normalizeReplayContent, normalizeReplayRole, normalizeReplayTimestamp } from "./shared.js";
 
-function parseJsonl(raw: string, warnings: Array<{ code: string; message: string; index?: number }>): unknown[] {
+function parseJsonl(
+  raw: string,
+  warnings: Array<{ code: string; message: string; index?: number }>,
+  strict: boolean | undefined,
+): unknown[] {
   const out: unknown[] = [];
   for (const [index, line] of raw.split("\n").entries()) {
     const trimmed = line.trim();
@@ -14,25 +18,33 @@ function parseJsonl(raw: string, warnings: Array<{ code: string; message: string
     try {
       out.push(JSON.parse(trimmed));
     } catch {
-      warnings.push({
+      const warning = {
         code: "replay.openclaw.jsonl.invalid_line",
         message: `Skipping invalid JSONL line ${index + 1}.`,
         index,
-      });
+      };
+      if (strict) throw new Error(warning.message);
+      warnings.push(warning);
     }
   }
   return out;
 }
 
-function gatherCandidates(input: unknown, warnings: Array<{ code: string; message: string; index?: number }>): unknown[] {
+function gatherCandidates(
+  input: unknown,
+  warnings: Array<{ code: string; message: string; index?: number }>,
+  strict: boolean | undefined,
+): unknown[] {
   if (Array.isArray(input)) return input;
 
   if (typeof input === "string") {
+    let parsed: unknown;
     try {
-      return gatherCandidates(JSON.parse(input), warnings);
+      parsed = JSON.parse(input);
     } catch {
-      return parseJsonl(input, warnings);
+      return parseJsonl(input, warnings, strict);
     }
+    return gatherCandidates(parsed, warnings, strict);
   }
 
   if (!input || typeof input !== "object") return [];
@@ -44,14 +56,23 @@ function gatherCandidates(input: unknown, warnings: Array<{ code: string; messag
 
   if (Array.isArray(obj.records)) {
     const rows: unknown[] = [];
-    for (const rec of obj.records) {
-      if (!rec || typeof rec !== "object") continue;
+    for (const [index, rec] of obj.records.entries()) {
+      if (!rec || typeof rec !== "object") {
+        const warning = {
+          code: "replay.openclaw.record.invalid",
+          message: `Skipping non-object OpenClaw replay record at index ${index}.`,
+          index,
+        };
+        if (strict) throw new Error(warning.message);
+        warnings.push(warning);
+        continue;
+      }
       const record = rec as Record<string, unknown>;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
       const path = typeof record.path === "string" ? record.path : "";
       if (!path.startsWith("transcripts/") && !path.includes("/transcripts/")) continue;
-      rows.push(...parseJsonl(content, warnings));
+      rows.push(...parseJsonl(content, warnings, strict));
     }
     return rows;
   }
@@ -63,7 +84,7 @@ export const openclawReplayNormalizer: ReplayNormalizer = {
   source: "openclaw",
   parse(input: unknown, options: ReplayParseOptions = {}): ReplayParseResult {
     const warnings: ReplayParseResult["warnings"] = [];
-    const rawTurns = gatherCandidates(input, warnings);
+    const rawTurns = gatherCandidates(input, warnings, options.strict);
     const turns: ReplayTurn[] = [];
 
     const defaultSessionKey = options.defaultSessionKey?.trim() || "replay:openclaw:import";
@@ -71,11 +92,13 @@ export const openclawReplayNormalizer: ReplayNormalizer = {
     for (let i = 0; i < rawTurns.length; i += 1) {
       const raw = rawTurns[i];
       if (!raw || typeof raw !== "object") {
-        warnings.push({
+        const warning = {
           code: "replay.openclaw.turn.invalid",
           message: "Skipping non-object replay turn.",
           index: i,
-        });
+        };
+        if (options.strict) throw new Error(warning.message);
+        warnings.push(warning);
         continue;
       }
 

package/src/replay/normalizers/replay-normalizers.test.ts

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { chatgptReplayNormalizer } from "./chatgpt.js";
+import { claudeReplayNormalizer } from "./claude.js";
+import { openclawReplayNormalizer } from "./openclaw.js";
+
+test("replay normalizers throw on malformed whole-file JSON in strict mode", () => {
+  assert.throws(
+    () => chatgptReplayNormalizer.parse("{", { strict: true }),
+    /Invalid ChatGPT replay JSON/,
+  );
+  assert.throws(
+    () => claudeReplayNormalizer.parse("{", { strict: true }),
+    /Invalid Claude replay JSON/,
+  );
+  assert.throws(
+    () => openclawReplayNormalizer.parse("{bad jsonl}", { strict: true }),
+    /invalid JSONL line/i,
+  );
+});
+
+test("replay normalizers warn on malformed whole-file JSON outside strict mode", async () => {
+  const chatgpt = await chatgptReplayNormalizer.parse("{");
+  const claude = await claudeReplayNormalizer.parse("{");
+  const openclaw = await openclawReplayNormalizer.parse("{bad jsonl}");
+
+  assert.equal(
+    chatgpt.warnings.some((warning) =>
+      warning.code === "replay.chatgpt.json.invalid",
+    ),
+    true,
+  );
+  assert.equal(
+    claude.warnings.some((warning) =>
+      warning.code === "replay.claude.json.invalid",
+    ),
+    true,
+  );
+  assert.equal(
+    openclaw.warnings.some((warning) =>
+      warning.code === "replay.openclaw.jsonl.invalid_line",
+    ),
+    true,
+  );
+});
+
+test("replay normalizers throw on malformed message rows in strict mode", () => {
+  assert.throws(
+    () => chatgptReplayNormalizer.parse({ messages: [null] }, { strict: true }),
+    /malformed ChatGPT replay message/i,
+  );
+  assert.throws(
+    () => claudeReplayNormalizer.parse({ messages: [null] }, { strict: true }),
+    /malformed Claude message/i,
+  );
+  assert.throws(
+    () => openclawReplayNormalizer.parse([null], { strict: true }),
+    /non-object replay turn/i,
+  );
+  assert.throws(
+    () => openclawReplayNormalizer.parse({ records: [null] }, { strict: true }),
+    /non-object OpenClaw replay record/i,
+  );
+});

package/src/replay/normalizers/shared.ts

@@ -27,7 +27,8 @@ export function normalizeReplayContent(value: unknown): string | null {
   }
   if (Array.isArray(value)) {
     const text = value
-      .map((part) => (typeof part === "string" ? part : ""))
+      .map((part) => normalizeReplayContent(part) ?? "")
+      .filter((part) => part.length > 0)
       .join("\n")
       .trim();
     return text.length > 0 ? text : null;
@@ -35,6 +36,8 @@ export function normalizeReplayContent(value: unknown): string | null {
   if (value && typeof value === "object") {
     const obj = value as Record<string, unknown>;
     if (Array.isArray(obj.parts)) return normalizeReplayContent(obj.parts);
+    if (Array.isArray(obj.content)) return normalizeReplayContent(obj.content);
+    if (typeof obj.content === "string") return normalizeReplayContent(obj.content);
     if (typeof obj.text === "string") return normalizeReplayContent(obj.text);
   }
   return null;

package/src/replay/runner.ts

@@ -62,7 +62,7 @@ function inDateRange(turn: ReplayTurn, fromTs: number | null, toTs: number | nul
   const turnTs = parseIsoTimestamp(turn.timestamp);
   if (turnTs === null) return false;
   if (fromTs !== null && turnTs < fromTs) return false;
-  if (toTs !== null && turnTs > toTs) return false;
+  if (toTs !== null && turnTs >= toTs) return false;
   return true;
 }
 

package/src/rerank.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { rerankLocalOrNoop } from "./rerank.js";
+import { RerankCache, rerankLocalOrNoop } from "./rerank.js";
 
 test("rerankLocalOrNoop tags rerank requests as recall-critical", async () => {
   const calls: Array<{
@@ -46,3 +46,43 @@ test("rerankLocalOrNoop tags rerank requests as recall-critical", async () => {
   assert.equal(calls[0]?.options?.operation, "rerank");
   assert.equal(calls[0]?.options?.priority, "recall-critical");
 });
+
+test("rerankLocalOrNoop cache is isolated from caller mutations", async () => {
+  let calls = 0;
+  const cache = new RerankCache();
+  const options = {
+    query: "API rate limit issue",
+    candidates: [
+      { id: "a", snippet: "API rate limit is 1000 requests per minute." },
+      { id: "b", snippet: "Deployment note." },
+    ],
+    local: {
+      async chatCompletion() {
+        calls += 1;
+        return {
+          content: JSON.stringify({
+            scores: [
+              { id: "a", score: 90 },
+              { id: "b", score: 10 },
+            ],
+          }),
+        };
+      },
+    },
+    enabled: true,
+    timeoutMs: 1_500,
+    maxCandidates: 5,
+    cache,
+    cacheEnabled: true,
+    cacheTtlMs: 60_000,
+  };
+
+  const first = await rerankLocalOrNoop(options);
+  assert.deepEqual(first, ["a", "b"]);
+  first?.reverse();
+  first?.push("unknown");
+
+  const second = await rerankLocalOrNoop(options);
+  assert.deepEqual(second, ["a", "b"]);
+  assert.equal(calls, 1);
+});

package/src/rerank.ts

@@ -23,11 +23,11 @@ export class RerankCache {
       this.entries.delete(key);
       return null;
     }
-    return e.rankedIds;
+    return e.rankedIds.slice();
   }
 
   set(key: string, rankedIds: string[], ttlMs: number): void {
-    this.entries.set(key, { rankedIds, expiresAtMs: Date.now() + ttlMs });
+    this.entries.set(key, { rankedIds: rankedIds.slice(), expiresAtMs: Date.now() + ttlMs });
   }
 }
 

package/src/resolve-auth-token.test.ts

@@ -119,6 +119,35 @@ test("resolveAgentAccessAuthToken cache key is order-independent", async () => {
   }
 });
 
+test("resolveAgentAccessAuthToken scopes SecretRef cache by resolver function", async () => {
+  clearAuthTokenSecretCache();
+  let resolverACalls = 0;
+  let resolverBCalls = 0;
+  const resolverA = async () => {
+    resolverACalls += 1;
+    return "token-a";
+  };
+  const resolverB = async () => {
+    resolverBCalls += 1;
+    return "token-b";
+  };
+
+  try {
+    const ref = { source: "exec", provider: "shared", id: "value" };
+    const first = await resolveAgentAccessAuthToken(ref, { resolveSecretRef: resolverA });
+    const second = await resolveAgentAccessAuthToken(ref, { resolveSecretRef: resolverB });
+    const third = await resolveAgentAccessAuthToken({ ...ref }, { resolveSecretRef: resolverB });
+
+    assert.equal(first, "token-a");
+    assert.equal(second, "token-b");
+    assert.equal(third, "token-b");
+    assert.equal(resolverACalls, 1);
+    assert.equal(resolverBCalls, 1);
+  } finally {
+    clearAuthTokenSecretCache();
+  }
+});
+
 test("resolveAgentAccessAuthToken throws when no SecretRef resolver is provided", async () => {
   clearAuthTokenSecretCache();
 

package/src/resolve-auth-token.ts

@@ -37,7 +37,7 @@ type ResolveAgentAccessAuthTokenOptions = {
   resolveSecretRef?: ResolveSecretRefFn | null;
 };
 
-const resolvedCache = new Map<string, string>();
+let resolvedCache = new WeakMap<ResolveSecretRefFn, Map<string, string>>();
 
 /**
  * SecretRef objects are stable per (source, provider, id, command) tuple.
@@ -92,10 +92,6 @@ export async function resolveAgentAccessAuthToken(
     );
   }
 
-  const cacheKey = cacheKeyForSecretRef(ref);
-  const cached = resolvedCache.get(cacheKey);
-  if (cached !== undefined) return cached;
-
   const resolver = options.resolveSecretRef ?? null;
   if (!resolver) {
     throw new Error(
@@ -107,6 +103,15 @@ export async function resolveAgentAccessAuthToken(
     );
   }
 
+  const cacheKey = cacheKeyForSecretRef(ref);
+  let resolverCache = resolvedCache.get(resolver);
+  if (!resolverCache) {
+    resolverCache = new Map<string, string>();
+    resolvedCache.set(resolver, resolverCache);
+  }
+  const cached = resolverCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+
   let resolved: string | undefined;
   try {
     const out = await resolver(ref);
@@ -130,7 +135,7 @@ export async function resolveAgentAccessAuthToken(
     );
   }
 
-  resolvedCache.set(cacheKey, resolved);
+  resolverCache.set(cacheKey, resolved);
   return resolved;
 }
 
@@ -147,5 +152,5 @@ export function isAgentAccessSecretRef(value: unknown): value is SecretRef {
 
 /** Test/operations hook: drop the cache and force resolver rediscovery. */
 export function clearAuthTokenSecretCache(): void {
-  resolvedCache.clear();
+  resolvedCache = new WeakMap<ResolveSecretRefFn, Map<string, string>>();
 }

package/src/resolve-provider-secret.test.ts

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  __findExecutableOnPathForTest,
   __setGatewayResolverForTest,
   clearSecretCache,
   resolveProviderApiKey,
@@ -50,6 +49,37 @@ test("resolveProviderApiKey scopes cached gateway secrets by agent directory", a
   }
 });
 
+test("resolveProviderApiKey resolves SecretRef-like inputs through an injected host resolver", async () => {
+  clearSecretCache();
+  const calls: unknown[] = [];
+
+  try {
+    const resolved = await resolveProviderApiKey(
+      "anthropic",
+      { source: "host-secret", id: "claude-prod" },
+      { profile: "standalone-host" },
+      "/tmp/host-agent",
+      {
+        resolveApiKeyForProvider: async (params) => {
+          calls.push(params);
+          return { apiKey: "sk-from-injected-host", source: "host-secret", mode: "test" };
+        },
+      },
+    );
+
+    assert.equal(resolved, "sk-from-injected-host");
+    assert.deepEqual(calls, [
+      {
+        provider: "anthropic",
+        cfg: { profile: "standalone-host" },
+        agentDir: "/tmp/host-agent",
+      },
+    ]);
+  } finally {
+    clearSecretCache();
+  }
+});
+
 test("resolveProviderApiKey does not reuse cached literal keys for different inputs", async () => {
   clearSecretCache();
 
@@ -115,6 +145,53 @@ test("resolveProviderApiKey scopes cached gateway secrets by auth input and conf
   }
 });
 
+test("resolveProviderApiKey scopes cached gateway secrets by injected resolver identity", async () => {
+  clearSecretCache();
+  const gatewayConfig = { profile: "shared" };
+  let firstCalls = 0;
+  let secondCalls = 0;
+  const firstResolver = async () => {
+    firstCalls += 1;
+    return { apiKey: "key:first" };
+  };
+  const secondResolver = async () => {
+    secondCalls += 1;
+    return { apiKey: "key:second" };
+  };
+
+  try {
+    const first = await resolveProviderApiKey(
+      "openai",
+      "secretref-managed",
+      gatewayConfig,
+      "/tmp/shared-agent",
+      { resolveApiKeyForProvider: firstResolver },
+    );
+    const second = await resolveProviderApiKey(
+      "openai",
+      "secretref-managed",
+      gatewayConfig,
+      "/tmp/shared-agent",
+      { resolveApiKeyForProvider: secondResolver },
+    );
+    const repeatFirst = await resolveProviderApiKey(
+      "openai",
+      "secretref-managed",
+      gatewayConfig,
+      "/tmp/shared-agent",
+      { resolveApiKeyForProvider: firstResolver },
+    );
+
+    assert.equal(first, "key:first");
+    assert.equal(second, "key:second");
+    assert.equal(repeatFirst, first);
+    assert.equal(firstCalls, 1);
+    assert.equal(secondCalls, 1);
+  } finally {
+    clearSecretCache();
+  }
+});
+
 test("resolveProviderApiKey treats env-var-shaped config strings as markers", async () => {
   clearSecretCache();
   const previousOpenAI = process.env.OPENAI_API_KEY;
@@ -164,24 +241,3 @@ test("resolveProviderApiKey treats env-var-shaped config strings as markers", as
     clearSecretCache();
   }
 });
-
-test("findExecutableOnPath skips directories named like the executable", () => {
-  const calls: string[] = [];
-  const access = (candidate: string): void => {
-    calls.push(candidate);
-  };
-  const stat = (candidate: string): { isFile(): boolean } => ({
-    isFile: () => candidate === "/bin/openclaw",
-  });
-  const previousPath = process.env.PATH;
-
-  try {
-    process.env.PATH = ["/tmp", "/bin"].join(":");
-    const resolved = __findExecutableOnPathForTest("openclaw", access, stat, 1);
-    assert.equal(resolved, "/bin/openclaw");
-    assert.deepEqual(calls, ["/tmp/openclaw", "/bin/openclaw"]);
-  } finally {
-    if (previousPath === undefined) delete process.env.PATH;
-    else process.env.PATH = previousPath;
-  }
-});