@@ -205,6 +205,11 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("external history
             enabled: false,
             config: { homePath: claude },
           },
+          [ProviderInstanceId.make("invalid-claude")]: {
+            driver: ProviderDriverKind.make("claudeAgent"),
+            enabled: false,
+            config: { homePath: 17 },
+          },
           [ProviderInstanceId.make("opencode-downloads")]: {
             driver: ProviderDriverKind.make("opencode"),
             environment: [
 
@@ -4,6 +4,7 @@ import { expect, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as PlatformError from "effect/PlatformError";
 import { makeClaudeHistoryStore, makePiHistoryStore } from "./JsonlHistoryStore.ts";
 import { makeLocalHistory } from "./LocalHistory.ts";
 
@@ -89,8 +90,10 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("local JSONL hist
             .read(store, { operation: "read", ref: first.matches[0]!.ref })
             .pipe(Effect.flip)).reason,
         ).toBe("changed");
-        const restarted = yield* history.search(store, { ...paged, cursor: second.nextCursor! });
-        expect(restarted.matches[0]?.itemId).toBe("new-0");
+        expect(
+          (yield* history.search(store, { ...paged, cursor: second.nextCursor! }).pipe(Effect.flip))
+            .reason,
+        ).toBe("changed");
         expect(
           (yield* store
             .loadThread({ key: "../../outside.jsonl", version: "", updatedAt: 0 })
@@ -135,6 +138,80 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("local JSONL hist
     }).pipe(Effect.scoped),
   );
 
+  it.effect("isolates unreadable entries and retries incomplete listings after recovery", () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const root = yield* fs.makeTempDirectoryScoped();
+      const directory = `${root}/projects`;
+      for (const project of ["good", "blocked"]) {
+        yield* fs.makeDirectory(`${directory}/${project}`, { recursive: true });
+        yield* fs.writeFileString(
+          `${directory}/${project}/session.jsonl`,
+          JSON.stringify({ type: "user", uuid: project, message: { content: "needle" } }) + "\n",
+        );
+      }
+      const history = yield* makeLocalHistory;
+      const allKeys = ["blocked/session.jsonl", "good/session.jsonl"];
+      for (const failure of [
+        { method: "stat", path: `${directory}/blocked`, reason: "NotFound" },
+        { method: "readDirectory", path: `${directory}/blocked`, reason: "PermissionDenied" },
+        { method: "stat", path: `${directory}/blocked/session.jsonl`, reason: "NotFound" },
+        { method: "stat", path: `${directory}/blocked/session.jsonl`, reason: "PermissionDenied" },
+      ] as const) {
+        let unavailable = true;
+        const error = PlatformError.systemError({
+          _tag: failure.reason,
+          module: "FileSystem",
+          method: failure.method,
+          pathOrDescriptor: failure.path,
+        });
+        const partialFs = FileSystem.make({
+          ...fs,
+          stat: (path) =>
+            unavailable && failure.method === "stat" && path === failure.path
+              ? Effect.fail(error)
+              : fs.stat(path),
+          readDirectory: (path) =>
+            unavailable && failure.method === "readDirectory" && path === failure.path
+              ? Effect.fail(error)
+              : fs.readDirectory(path),
+        });
+        const store = yield* makeClaudeHistoryStore(root, history.cache).pipe(
+          Effect.provideService(FileSystem.FileSystem, partialFs),
+        );
+        expect((yield* store.listThreads).map((ref) => ref.key)).toEqual(["good/session.jsonl"]);
+        unavailable = false;
+        expect((yield* store.listThreads).map((ref) => ref.key).toSorted()).toEqual(allKeys);
+        if (failure.method === "stat") {
+          unavailable = true;
+          expect((yield* store.listThreads).map((ref) => ref.key)).toEqual(["good/session.jsonl"]);
+          unavailable = false;
+          expect((yield* store.listThreads).map((ref) => ref.key).toSorted()).toEqual(allKeys);
+        }
+      }
+      const inaccessibleRoot = yield* makeClaudeHistoryStore(root, history.cache).pipe(
+        Effect.provideService(
+          FileSystem.FileSystem,
+          FileSystem.make({
+            ...fs,
+            readDirectory: (path) =>
+              path === directory
+                ? Effect.fail(
+                    PlatformError.systemError({
+                      _tag: "PermissionDenied",
+                      module: "FileSystem",
+                      method: "readDirectory",
+                      pathOrDescriptor: path,
+                    }),
+                  )
+                : fs.readDirectory(path),
+          }),
+        ),
+      );
+      expect((yield* inaccessibleRoot.listThreads.pipe(Effect.flip)).reason).toBe("unavailable");
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("searches sessions larger than the old allocation cap and verifies their source", () =>
     Effect.gen(function* () {
       const fs = yield* FileSystem.FileSystem;
 
@@ -89,9 +89,18 @@ const makeJsonlHistoryStore = Effect.fn("ExternalHistory.openJsonlStore")(functi
     | { directories: ReadonlyMap<string, string>; refs: ReadonlyArray<LocalThreadRef> }
     | undefined;
   const listThreads = Effect.gen(function* () {
-    if (listing) {
+    let complete = true;
+    const skipEntryError = (error: PlatformError.PlatformError) => {
+      if (error.reason._tag === "NotFound" || error.reason._tag === "PermissionDenied") {
+        complete = false;
+        return Effect.undefined;
+      }
+      return Effect.fail(error);
+    };
+    const cachedListing = listing;
+    if (cachedListing) {
       let unchanged = true;
-      for (const [dir, version] of listing.directories) {
+      for (const [dir, version] of cachedListing.directories) {
         const stat = yield* fs.stat(dir).pipe(Effect.option);
         if (Option.isNone(stat) || fileVersion(stat.value) !== version) {
           unchanged = false;
@@ -101,7 +110,7 @@ const makeJsonlHistoryStore = Effect.fn("ExternalHistory.openJsonlStore")(functi
       if (unchanged) {
         // Appending a transcript does not change its directory's mtime.
         const refreshed = yield* Effect.forEach(
-          listing.refs,
+          cachedListing.refs,
           (ref) =>
             fs.stat(path.join(directory, ...ref.key.split("/"))).pipe(
               Effect.map((info) =>
@@ -115,16 +124,13 @@ const makeJsonlHistoryStore = Effect.fn("ExternalHistory.openJsonlStore")(functi
                     }
                   : undefined,
               ),
-              Effect.catchTags({
-                PlatformError: (error) =>
-                  error.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(error),
-              }),
+              Effect.catchTags({ PlatformError: skipEntryError }),
             ),
           { concurrency: 16 },
         );
         const refs = refreshed.filter((ref) => ref !== undefined);
         refs.sort((a, b) => b.updatedAt - a.updatedAt || a.key.localeCompare(b.key));
-        listing = { directories: listing.directories, refs };
+        listing = complete ? { directories: cachedListing.directories, refs } : undefined;
         return refs;
       }
     }
@@ -138,22 +144,30 @@ const makeJsonlHistoryStore = Effect.fn("ExternalHistory.openJsonlStore")(functi
     for (const child of children) {
       const childPath = path.join(directory, child);
       if (yield* Effect.isSuccess(fs.readLink(childPath))) continue;
-      const info = yield* fs.stat(childPath);
+      const info = yield* fs
+        .stat(childPath)
+        .pipe(Effect.catchTags({ PlatformError: skipEntryError }));
+      if (!info) continue;
       const files =
         info.type === "Directory"
-          ? yield* fs.readDirectory(childPath)
+          ? yield* fs
+              .readDirectory(childPath)
+              .pipe(Effect.catchTags({ PlatformError: skipEntryError }))
           : source === "pi" && child.endsWith(".jsonl")
             ? [child]
             : [];
+      if (!files) continue;
       if (info.type === "Directory") directories.set(childPath, fileVersion(info));
       if (directories.size > 50_000 || files.length + refs.length > 50_000)
         return yield* new ExternalHistoryError({ reason: "limit_exceeded" });
       for (const name of files) {
         if (!name.endsWith(".jsonl")) continue;
         const filePath = info.type === "Directory" ? path.join(childPath, name) : childPath;
         if (yield* Effect.isSuccess(fs.readLink(filePath))) continue;
-        const stat = yield* fs.stat(filePath);
-        if (stat.type !== "File") continue;
+        const stat = yield* fs
+          .stat(filePath)
+          .pipe(Effect.catchTags({ PlatformError: skipEntryError }));
+        if (stat?.type !== "File") continue;
         const key = path.relative(directory, filePath).split(path.sep).join("/");
         if (key.length > 512) return yield* new ExternalHistoryError({ reason: "limit_exceeded" });
         refs.push({
@@ -164,7 +178,8 @@ const makeJsonlHistoryStore = Effect.fn("ExternalHistory.openJsonlStore")(functi
       }
     }
     refs.sort((a, b) => b.updatedAt - a.updatedAt || a.key.localeCompare(b.key));
-    listing = { directories, refs };
+    // An omitted entry may recover without changing its parent's mtime.
+    listing = complete ? { directories, refs } : undefined;
     return refs;
   }).pipe(Effect.mapError(mapError));
 
 
@@ -103,6 +103,18 @@ it.layer(NodeCrypto.layer)("local history search paging", (it) => {
         "last:hit",
       ]);
       expect(requests).toBeGreaterThan(3);
+
+      let refs = yield* store.listThreads;
+      const changingStore = { ...store, listThreads: Effect.sync(() => refs) };
+      const history = yield* makeLocalHistory;
+      const request = { operation: "search", sourceId: "local", query: "needle" } as const;
+      const first = yield* history.search(changingStore, request);
+      refs = [refs.at(-1)!, ...refs.slice(0, -1)];
+      expect(
+        (yield* history
+          .search(changingStore, { ...request, cursor: first.nextCursor! })
+          .pipe(Effect.flip)).reason,
+      ).toBe("changed");
     }),
   );
 
 
@@ -20,10 +20,11 @@ import {
 } from "./LocalHistoryStore.ts";
 
 const SearchCursor = Schema.Struct({
-  v: Schema.Literal(2),
+  v: Schema.Literal(3),
   sourceId: Schema.String,
   query: Schema.String,
   filterCwd: Schema.NullOr(Schema.String),
+  listingDigest: Schema.String,
   afterKey: Schema.NullOr(Schema.String),
   itemOffset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
   version: Schema.NullOr(Schema.String),
@@ -86,17 +87,22 @@ export const makeLocalHistory = Effect.gen(function* () {
     )
       return yield* invalidCursor();
     const refs = yield* store.listThreads;
+    // Appends can reorder sessions between pages; never silently skip or repeat them.
+    const listingDigest = yield* digest(JSON.stringify(refs.map((ref) => ref.key)));
+    if (cursor && cursor.listingDigest !== listingDigest)
+      return yield* new ExternalHistoryError({ reason: "changed" });
     const first =
       cursor?.afterKey == null ? 0 : refs.findIndex((ref) => ref.key === cursor.afterKey);
     if (first < 0) return yield* new ExternalHistoryError({ reason: "changed" });
     const cursorAt = (index: number, itemOffset: number, version: string | null) => {
       const ref = refs[index];
       return ref
         ? encodeSearchCursor({
-            v: 2,
+            v: 3,
             sourceId: input.sourceId,
             query: input.query,
             filterCwd: input.filterCwd ?? null,
+            listingDigest,
             afterKey: ref.key,
             itemOffset,
             version,
@@ -137,6 +143,8 @@ export const makeLocalHistory = Effect.gen(function* () {
           () => Effect.undefined,
         ),
       );
+      if (resumed?.version != null && resumed.version !== thread?.version)
+        return yield* new ExternalHistoryError({ reason: "changed" });
       if (!thread) {
         examinedChars += FAILED_LOAD_CHARS;
         continue;
@@ -150,7 +158,7 @@ export const makeLocalHistory = Effect.gen(function* () {
               normalizeProjectPathForComparison(input.filterCwd)))
       )
         continue;
-      const offset = resumed?.version === thread.version ? resumed.itemOffset : 0;
+      const offset = resumed?.itemOffset ?? 0;
       if (offset > thread.items.length) return yield* invalidCursor();
       for (let position = offset; position < thread.items.length; position++) {
         const item = thread.items[position]!;
 
@@ -4,6 +4,7 @@ import { piHome, resolvePiSessionsDir } from "@t3tools/provider-pi/server/usage"
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import { resolveClaudeRuntime } from "../../provider/Drivers/ClaudeHome.ts";
@@ -32,7 +33,7 @@ type HistorySupport = { readonly label: string } & (
   | { readonly kind: "unsupported"; readonly reason: string }
 );
 
-const decodeClaudeSettings = Schema.decodeUnknownSync(ClaudeSettings);
+const decodeClaudeSettings = Schema.decodeUnknownOption(ClaudeSettings);
 const unsupported = (label: string): HistorySupport => ({
   kind: "unsupported",
   label,
@@ -54,9 +55,11 @@ export function makeHistorySupport(stores: {
       label: "Claude Code",
       open: stores.claudeAgent,
       roots: Effect.fn("ExternalHistory.claudeRoots")(function* (profile) {
+        const config = decodeClaudeSettings(profile.config ?? {});
+        if (Option.isNone(config)) return [];
         const runtime = yield* resolveClaudeRuntime({
           ...profile,
-          config: decodeClaudeSettings(profile.config ?? {}),
+          config: config.value,
         });
         return [runtime.configDir];
       }),