fix(doctor): probe memory embeddings on --deep and skip false warning for local provider

lzyyzznl · lzyyzznl · commit f190d5c69c85 · 2026-06-24T14:59:44.000+08:00
- Add skipped guard in noteMemorySearchHealth for local provider
- Add optional probe parameter to probeGatewayMemoryStatus
- Forward probe:true when doctor --deep is used
- Add regression tests for skipped guard and probe forwarding
- Add L2 module verification and L3 real CLI evidence
diff --git a/src/commands/doctor-gateway-health.test.ts b/src/commands/doctor-gateway-health.test.ts
@@ -233,6 +233,24 @@ describe("probeGatewayMemoryStatus", () => {
     });
   });
 
+  it("forwards probe: true when deep probing is requested", async () => {
+    callGateway.mockResolvedValue({ embedding: { ok: true } });
+
+    await expect(probeGatewayMemoryStatus({ cfg, probe: true })).resolves.toEqual({
+      checked: true,
+      ready: true,
+      error: undefined,
+      skipped: false,
+    });
+
+    expect(callGateway).toHaveBeenCalledWith({
+      method: "doctor.memory.status",
+      params: { probe: true },
+      timeoutMs: 8000,
+      config: cfg,
+    });
+  });
+
   it("treats outer gateway timeouts as inconclusive (skipped: false)", async () => {
     // A transport timeout must NOT be treated as a skipped probe. It is a real
     // diagnostic signal and the renderer should warn for key-optional providers.
diff --git a/src/commands/doctor-gateway-health.ts b/src/commands/doctor-gateway-health.ts
@@ -144,17 +144,18 @@ export async function checkGatewayHealth(params: {
   return { healthOk, authenticated: false, status };
 }
 
-/** Probes gateway memory readiness without forcing deep embedding checks. */
+/** Probes gateway memory readiness. Pass `probe: true` to force deep embedding checks. */
 export async function probeGatewayMemoryStatus(params: {
   cfg: OpenClawConfig;
   timeoutMs?: number;
+  probe?: boolean;
 }): Promise<GatewayMemoryProbe> {
   const timeoutMs =
     typeof params.timeoutMs === "number" && params.timeoutMs > 0 ? params.timeoutMs : 8_000;
   try {
     const payload = await callGateway<DoctorMemoryStatusPayload>({
       method: "doctor.memory.status",
-      params: { probe: false },
+      params: { probe: params.probe === true },
       timeoutMs,
       config: params.cfg,
     });
diff --git a/src/commands/doctor-memory-search.test.ts b/src/commands/doctor-memory-search.test.ts
@@ -257,7 +257,29 @@ describe("noteMemorySearchHealth", () => {
     expect(note).not.toHaveBeenCalled();
   });
 
-  it("warns when local provider skipped readiness but configured local model is missing", async () => {
+  it("does not warn when local provider probe was skipped without any model path configured", async () => {
+    // The PR adds an unconditional early return when gatewayMemoryProbe.skipped
+    // is true for local provider. Even without any model path, a skipped probe
+    // must not produce a false warning — it means readiness was never checked,
+    // not that embeddings are unavailable.
+    resolveMemorySearchConfig.mockReturnValue({
+      provider: "local",
+      local: {},
+      remote: {},
+    });
+
+    await noteMemorySearchHealth(cfg, {
+      gatewayMemoryProbe: { checked: false, ready: false, skipped: true },
+    });
+
+    expect(note).not.toHaveBeenCalled();
+  });
+
+  it("does not warn when local provider probe was skipped even with missing model path", async () => {
+    // The skipped-probe guard (PR #95091) returns early when gatewayMemoryProbe.skipped
+    // is true, regardless of model path. A skipped probe means readiness was never
+    // checked, so no warning is emitted — the user should run `openclaw doctor --deep`
+    // to force probing.
     resolveMemorySearchConfig.mockReturnValue({
       provider: "local",
       local: { modelPath: "/definitely/missing/openclaw-memory-model.gguf" },
@@ -274,8 +296,7 @@ describe("noteMemorySearchHealth", () => {
       },
     });
 
-    expect(note).toHaveBeenCalledTimes(1);
-    expect(firstNoteMessage()).toContain('Memory search provider is set to "local"');
+    expect(note).not.toHaveBeenCalled();
   });
 
   it("warns when local provider readiness probe is inconclusive", async () => {
diff --git a/src/commands/doctor-memory-search.ts b/src/commands/doctor-memory-search.ts
@@ -472,6 +472,13 @@ export async function noteMemorySearchHealth(
     if (opts?.gatewayMemoryProbe?.checked && opts.gatewayMemoryProbe.ready) {
       return;
     }
+    // When the probe was intentionally skipped (checked: false / skipped: true
+    // from the probe:false path), do not warn — the user has not requested a
+    // deep probe. They can run `openclaw doctor --deep` to force actual probing
+    // or `openclaw memory status --deep` for the authoritative check.
+    if (opts?.gatewayMemoryProbe?.skipped) {
+      return;
+    }
     const hasExplicitLocalModel = hasLocalEmbeddings(resolved.local);
     const hasUnavailableConfiguredLocalModel =
       Boolean(normalizeOptionalString(resolved.local.modelPath)) && !hasExplicitLocalModel;
diff --git a/src/flows/doctor-health-contributions.ts b/src/flows/doctor-health-contributions.ts
@@ -999,6 +999,7 @@ async function runGatewayHealthChecks(ctx: DoctorHealthFlowContext): Promise<voi
     ? await probeGatewayMemoryStatus({
         cfg: ctx.cfg,
         timeoutMs: ctx.options.nonInteractive === true ? 3000 : 10_000,
+        probe: ctx.options.deep === true,
       })
     : { checked: false, ready: false, skipped: healthOk };
 }

Original file line number	Diff line number	Diff line change
`@@ -999,6 +999,7 @@ async function runGatewayHealthChecks(ctx: DoctorHealthFlowContext): Promise<voi`
`999`	`999`	`? await probeGatewayMemoryStatus({`
`1000`	`1000`	`cfg: ctx.cfg,`
`1001`	`1001`	`timeoutMs: ctx.options.nonInteractive === true ? 3000 : 10_000,`
	`1002`	`+ probe: ctx.options.deep === true,`
`1002`	`1003`	`})`
`1003`	`1004`	`: { checked: false, ready: false, skipped: healthOk };`
`1004`	`1005`	`}`