fix(doctor): scan raw snapshot paths

giodl73-repo · Copilot · giodl73-repo · commit 0c8c1761fc06 · 2026-05-17T10:42:39.000-07:00
Expand home-relative cached snapshot paths before stale bundled-skill classification and scan raw session-store JSON so persisted resolvedSkills are inspected before normal session-store normalization strips them.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/src/commands/doctor-session-snapshots.test.ts b/src/commands/doctor-session-snapshots.test.ts
@@ -113,6 +113,33 @@ describe("doctor session snapshot stale runtime metadata", () => {
     ]);
   });
 
+  it("expands home-relative cached bundled skill locations before classifying them", () => {
+    const homeDir = path.join(root, "home");
+    const stalePath = "~/old-runtime/node_modules/openclaw/skills/doctor/SKILL.md";
+
+    const findings = scanSessionStoreForStaleRuntimeSnapshotPaths({
+      bundledSkillsDir,
+      env: { HOME: homeDir },
+      store: {
+        "agent:home": sessionEntry({
+          skillsSnapshot: {
+            prompt: skillPrompt(stalePath),
+            skills: [{ name: "doctor" }],
+          },
+        }),
+      },
+    });
+
+    expect(findings).toEqual([
+      {
+        sessionKey: "agent:home",
+        field: "skillsSnapshot.prompt",
+        cachedPath: stalePath,
+        expectedPath: path.join(bundledSkillsDir, "doctor", "SKILL.md"),
+      },
+    ]);
+  });
+
   it("ignores current bundled locations and unrelated workspace skill locations", () => {
     const currentPath = path.join(bundledSkillsDir, "doctor", "SKILL.md");
     const workspacePath = path.join(root, "workspace", "skills", "doctor", "SKILL.md");
@@ -223,6 +250,52 @@ describe("doctor session snapshot stale runtime metadata", () => {
     expect(message).toContain(path.join(bundledSkillsDir, "doctor", "SKILL.md"));
   });
 
+  it("scans resolvedSkills before session store normalization strips them", async () => {
+    const stalePath = path.join(
+      root,
+      "old-runtime",
+      "node_modules",
+      "openclaw",
+      "skills",
+      "doctor",
+      "SKILL.md",
+    );
+    const storePath = path.join(root, "state", "agents", "main", "sessions", "sessions.json");
+    await writeSessionStore(storePath, {
+      "agent:main": sessionEntry({
+        skillsSnapshot: {
+          prompt: "",
+          skills: [{ name: "doctor" }],
+          resolvedSkills: [
+            {
+              name: "doctor",
+              description: "Doctor skill",
+              source: "bundled",
+              filePath: stalePath,
+              baseDir: path.dirname(stalePath),
+              sourceInfo: {
+                path: stalePath,
+                source: "bundled",
+                scope: "user",
+                origin: "top-level",
+                baseDir: path.dirname(stalePath),
+              },
+              disableModelInvocation: false,
+            },
+          ],
+        },
+      }),
+    });
+
+    await noteSessionSnapshotHealth({ storePaths: [storePath], bundledSkillsDir });
+
+    expect(note).toHaveBeenCalledTimes(1);
+    const [message] = note.mock.calls[0] as [string, string];
+    expect(message).toContain("agent:main");
+    expect(message).toContain("skillsSnapshot.resolvedSkills");
+    expect(message).toContain(stalePath);
+  });
+
   it("reports stale cached metadata from configured session stores", async () => {
     const stalePath = path.join(
       root,
diff --git a/src/commands/doctor-session-snapshots.ts b/src/commands/doctor-session-snapshots.ts
@@ -2,10 +2,10 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveBundledSkillsDir } from "../agents/skills/bundled-dir.js";
 import { resolveStateDir } from "../config/paths.js";
-import { loadSessionStore } from "../config/sessions/store-load.js";
 import { resolveAllAgentSessionStoreTargetsSync } from "../config/sessions/targets.js";
 import type { SessionEntry } from "../config/sessions/types.js";
 import type { OpenClawConfig } from "../config/types.openclaw.js";
+import { expandHomePrefix } from "../infra/home-dir.js";
 import { note } from "../terminal/note.js";
 import { shortenHomePath } from "../utils.js";
 
@@ -168,14 +168,20 @@ function resolveExpectedBundledSkillPath(params: {
   cachedPath: string;
   bundledSkillsDir: string;
   pathExists: (filePath: string) => boolean;
+  homeDir?: string;
+  env?: NodeJS.ProcessEnv;
 }): string | undefined {
-  if (!isAbsolutePathLike(params.cachedPath)) {
+  const expandedCachedPath = expandHomePrefix(params.cachedPath, {
+    home: params.homeDir,
+    env: params.env,
+  });
+  if (!isAbsolutePathLike(expandedCachedPath)) {
     return undefined;
   }
-  if (isInsidePath(params.bundledSkillsDir, params.cachedPath)) {
+  if (isInsidePath(params.bundledSkillsDir, expandedCachedPath)) {
     return undefined;
   }
-  const relativeSegments = extractBundledSkillRelativeSegments(params.cachedPath);
+  const relativeSegments = extractBundledSkillRelativeSegments(expandedCachedPath);
   if (!relativeSegments) {
     return undefined;
   }
@@ -187,6 +193,8 @@ export function scanSessionStoreForStaleRuntimeSnapshotPaths(params: {
   store: Record<string, SessionEntry>;
   bundledSkillsDir: string | undefined;
   pathExists?: (filePath: string) => boolean;
+  homeDir?: string;
+  env?: NodeJS.ProcessEnv;
 }): StaleSessionSnapshotPathFinding[] {
   const bundledSkillsDir = params.bundledSkillsDir?.trim();
   if (!bundledSkillsDir) {
@@ -204,6 +212,8 @@ export function scanSessionStoreForStaleRuntimeSnapshotPaths(params: {
         cachedPath: cached.path,
         bundledSkillsDir,
         pathExists,
+        homeDir: params.homeDir,
+        env: params.env,
       });
       if (!expectedPath) {
         continue;
@@ -252,6 +262,11 @@ function resolveSessionStorePaths(params: {
     .toSorted((a, b) => a.localeCompare(b));
 }
 
+function loadSessionStoreForSnapshotScan(storePath: string): Record<string, SessionEntry> {
+  const parsed = JSON.parse(fs.readFileSync(storePath, "utf-8")) as unknown;
+  return isRecord(parsed) ? (parsed as Record<string, SessionEntry>) : {};
+}
+
 export async function noteSessionSnapshotHealth(params?: {
   storePaths?: string[];
   bundledSkillsDir?: string;
@@ -270,15 +285,19 @@ export async function noteSessionSnapshotHealth(params?: {
   for (const storePath of storePaths) {
     let store: Record<string, SessionEntry>;
     try {
-      store = loadSessionStore(storePath);
+      store = loadSessionStoreForSnapshotScan(storePath);
     } catch (err) {
       note(
         `- Failed to inspect session snapshot metadata in ${shortenHomePath(storePath)}: ${String(err)}`,
         "Session snapshots",
       );
       continue;
     }
-    const findings = scanSessionStoreForStaleRuntimeSnapshotPaths({ store, bundledSkillsDir });
+    const findings = scanSessionStoreForStaleRuntimeSnapshotPaths({
+      store,
+      bundledSkillsDir,
+      env: params?.env,
+    });
     if (findings.length > 0) {
       findingsByStore.set(storePath, findings);
     }
