@@ -93,19 +93,37 @@ Per the guardrail this rebrand was scoped to: no mass rename.
   or a directory containing at least one `.cs` file anywhere under it)
   *before* running the extractor, and exits **4** with an explicit message
   if none do. This is a new, additive exit-code tier — it does not change
-  any of the existing 0/1/`>=2`/3 contract.
+  any of the existing 0/1/`>=2`/3 contract. **Correction (review, PR #246):**
+  the directory walk in this preflight check now uses the same
+  `EnumerationOptions { RecurseSubdirectories = true, IgnoreInaccessible =
+  true }` the extractor's own `Expand()` walk uses (`OwnSharp.Extractor/
+  Program.cs`) — the first version used a plain `SearchOption.AllDirectories`,
+  which throws on a locked/permission-denied subdirectory instead of
+  tolerating it and continuing, regressing a directory scan the extractor
+  itself would have handled fine.
 - **`OWEN_PYTHON`** is the preferred env var; the legacy **`OWN_PYTHON`**
   name is still accepted as a temporary compatibility fallback (so existing
   internal use — CI, scripts, muscle memory — doesn't break outright) and
   prints a one-line deprecation note to stderr every time it's the variable
   actually used to resolve Python. `OWEN_PYTHON` takes priority when both
   are set.
-- **Cache directory** moved to `~/.owen/core/<version>/`. `CoreVendor` reads
-  a plain existence check against the previous `~/.ownsharp/core/<version>/`
-  location first — if that exact version was already unpacked there by an
-  older install, it's reused in place rather than re-copied. This is a
-  fallback read, not a migration subsystem: the old location is never
-  written to, moved, or deleted by the new code.
+- **Cache directory** moved to `~/.owen/core/<version>/`. `CoreVendor` checks
+  the previous `~/.ownsharp/core/<version>/` location first — if that exact
+  version was already unpacked there by an older install, it's reused in
+  place rather than re-copied. This is a fallback read, not a migration
+  subsystem: the old location is never written to, moved, or deleted by the
+  new code. **Correction (review, PR #246):** the first version of this
+  fallback trusted a bare `.unpacked` marker file's *existence* — but the
+  CLI's own `<Version>` doesn't change every time the vendored core's
+  content does (this rebrand's own SARIF-driver-name change is the concrete
+  proof: same `0.1.0`, different core content), so an existence-only check
+  could silently reuse a stale, differently-vendored core from a machine
+  that had run a pre-rebrand `OwnSharp.Cli` install. `CoreVendor` now writes
+  a SHA-256 fingerprint of the bundled `ownlang/*.py` files as the marker's
+  content (both locations) and only trusts a cache whose marker's hash
+  matches the source this install would unpack right now — same "simple,
+  not a migration subsystem" shape, just content-aware instead of
+  version-only.
 
 ## Tests
 
 
@@ -158,6 +158,17 @@ private static string RequireValue(string[] args, ref int i, string flag)
         return args[++i];
     }
 
+    // Mirrors the extractor's own Expand() walk (Program.cs): IgnoreInaccessible
+    // tolerates a locked/permission-denied subdirectory mid-walk instead of
+    // throwing. Without this, a preflight check using plain
+    // SearchOption.AllDirectories could crash on a tree the extractor itself
+    // would have scanned around just fine (review, PR #246).
+    private static readonly EnumerationOptions DirectoryWalkOptions = new()
+    {
+        RecurseSubdirectories = true,
+        IgnoreInaccessible = true,
+    };
+
     /// <summary>True if at least one of <paramref name="paths"/> resolves to
     /// something the currently included frontend can analyze: a file whose
     /// extension is in <see cref="SupportedExtensions"/>, or a directory that
@@ -172,7 +183,7 @@ private static bool HasSupportedInput(IReadOnlyList<string> paths, out string re
         {
             if (Directory.Exists(p))
             {
-                if (Directory.EnumerateFiles(p, "*.cs", SearchOption.AllDirectories).Any())
+                if (Directory.EnumerateFiles(p, "*.cs", DirectoryWalkOptions).Any())
                 {
                     reason = "";
                     return true;
 
@@ -1,3 +1,6 @@
+using System.Security.Cryptography;
+using System.Text;
+
 namespace OwnSharp.Cli;
 
 /// <summary>
@@ -8,9 +11,10 @@ namespace OwnSharp.Cli;
 /// into the repository being analyzed. Cache root renamed to
 /// <c>~/.owen/core/&lt;version&gt;/</c> for the Owen public facade (see
 /// docs/notes/owen-public-facade.md); a version already unpacked under the
-/// previous <c>~/.ownsharp/core/&lt;version&gt;/</c> location is reused as-is
-/// (a plain existence check, not a migration — the old location is never
-/// written to or deleted).
+/// previous <c>~/.ownsharp/core/&lt;version&gt;/</c> location is reused as-is —
+/// a plain fallback read, not a migration (the old location is never written
+/// to or deleted) — but ONLY when its content fingerprint still matches the
+/// source this install actually bundles (see <see cref="EnsureUnpacked"/>).
 /// </summary>
 internal static class CoreVendor
 {
@@ -22,37 +26,46 @@ internal static class CoreVendor
     /// </summary>
     public static string EnsureUnpacked()
     {
+        var sourceOwnlang = Path.Combine(AppContext.BaseDirectory, "ownlang-core", "ownlang");
+        if (!Directory.Exists(sourceOwnlang))
+        {
+            throw new InvalidOperationException(
+                $"owen: vendored core not found at '{sourceOwnlang}' — a corrupt or " +
+                "incomplete tool install. Try `dotnet tool uninstall --global Owen.Cli` " +
+                "and reinstall.");
+        }
+        // A same-version marker alone does NOT prove the cached files match what
+        // THIS install bundles (review, PR #246): the CLI's own <Version> can
+        // stay unchanged across a content-only re-vendor (exactly what shipping
+        // the Owen SARIF-driver-name rename without a version bump would do),
+        // and the legacy ~/.ownsharp fallback below is a second location that
+        // can hold same-version-but-different-content data from a genuinely
+        // different install lineage (a pre-rebrand tool). A content fingerprint
+        // closes both holes with the same simple mechanism, no migration
+        // subsystem: trust a cache only when its marker's hash equals the hash
+        // of the source this install would unpack right now.
+        var fingerprint = Fingerprint(sourceOwnlang);
+
         var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
         var cacheRoot = Path.Combine(userProfile, ".owen", "core", ToolVersion.Current);
         var marker = Path.Combine(cacheRoot, ".unpacked");
 
-        if (File.Exists(marker))
+        if (File.Exists(marker) && File.ReadAllText(marker) == fingerprint)
         {
             return cacheRoot;
         }
 
         // Simple fallback read from the previous ~/.ownsharp location (same
-        // version already unpacked there by an older install of this same
-        // tool) — reuse it in place rather than re-copying, no migration
-        // subsystem. Only a same-version marker counts: a different version
-        // there is irrelevant (each version gets its own cache directory).
+        // version, same content, already unpacked there by an older install)
+        // — reuse it in place rather than re-copying.
         var legacyCacheRoot = Path.Combine(userProfile, ".ownsharp", "core", ToolVersion.Current);
         var legacyMarker = Path.Combine(legacyCacheRoot, ".unpacked");
-        if (File.Exists(legacyMarker))
+        if (File.Exists(legacyMarker) && File.ReadAllText(legacyMarker) == fingerprint)
         {
             return legacyCacheRoot;
         }
 
         var destOwnlang = Path.Combine(cacheRoot, "ownlang");
-        var sourceOwnlang = Path.Combine(AppContext.BaseDirectory, "ownlang-core", "ownlang");
-        if (!Directory.Exists(sourceOwnlang))
-        {
-            throw new InvalidOperationException(
-                $"owen: vendored core not found at '{sourceOwnlang}' — a corrupt or " +
-                "incomplete tool install. Try `dotnet tool uninstall --global Owen.Cli` " +
-                "and reinstall.");
-        }
-
         Directory.CreateDirectory(destOwnlang);
         foreach (var file in Directory.EnumerateFiles(sourceOwnlang, "*.py"))
         {
@@ -62,7 +75,25 @@ public static string EnsureUnpacked()
         // Write the marker LAST: an interrupted copy (killed process, full disk)
         // leaves no marker, so the next run redoes the unpack instead of running
         // against a half-written core.
-        File.WriteAllText(marker, ToolVersion.Current);
+        File.WriteAllText(marker, fingerprint);
         return cacheRoot;
     }
+
+    /// <summary>SHA-256 over every vendored <c>*.py</c> file's name and content,
+    /// sorted by filename for determinism — a cheap, self-contained way to tell
+    /// "this cache holds exactly this source" apart from "this cache exists and
+    /// the version number happens to match".</summary>
+    private static string Fingerprint(string sourceOwnlang)
+    {
+        using var sha = SHA256.Create();
+        using var buffer = new MemoryStream();
+        foreach (var file in Directory.EnumerateFiles(sourceOwnlang, "*.py").OrderBy(f => f, StringComparer.Ordinal))
+        {
+            var nameBytes = Encoding.UTF8.GetBytes(Path.GetFileName(file));
+            buffer.Write(nameBytes);
+            var contentBytes = File.ReadAllBytes(file);
+            buffer.Write(contentBytes);
+        }
+        return Convert.ToHexString(sha.ComputeHash(buffer.ToArray()));
+    }
 }