windowsweep 1.3.2 → 1.4.1

package/lib/fs.ps1

@@ -61,14 +61,110 @@ function Get-ChildEntries {
 }
 
 function Get-NewestTimestampUtc {
-  <# .SYNOPSIS The most recent of write / access / creation time - the safe "last touched" estimate when access tracking is off. #>
-  param([System.IO.FileSystemInfo] $Info)
+  <# .SYNOPSIS The most recent of write / access / creation time - the safe "last touched" estimate when access tracking is off.
+     -IgnoreAccess drops last-access (D82: used where Test-LastAccessLive found it carries no signal). #>
+  param([System.IO.FileSystemInfo] $Info, [switch] $IgnoreAccess)
   $t = $Info.LastWriteTimeUtc
-  try { if ($Info.LastAccessTimeUtc -gt $t) { $t = $Info.LastAccessTimeUtc } } catch { $null = $_ }
+  if (-not $IgnoreAccess) { try { if ($Info.LastAccessTimeUtc -gt $t) { $t = $Info.LastAccessTimeUtc } } catch { $null = $_ } }
   try { if ($Info.CreationTimeUtc -gt $t) { $t = $Info.CreationTimeUtc } } catch { $null = $_ }
   return $t
 }
 
+# D82 (owner, 2026-11-02): last-access can be live - Windows updating it, or an indexer, backup, antivirus or disk
+# scanner reading every file - and then every file looks touched today, so an idle gate deletes nothing (the P52:
+# a 30-day developer run found 1.5 GB of ~37 GB). Each root is sampled once. When at least WS_ACCESS_SAMPLE_MIN
+# files written or created a week or more ago were nearly all "read" within the last day, last-access says
+# nothing there and idle age uses write/creation time for that root. A root too small to judge inherits a live
+# verdict already reached on its volume; otherwise it keeps the conservative newest-of-three.
+# The sample walks on until it has WS_ACCESS_SAMPLE_MAX old files or has seen WS_ACCESS_SCAN_CAP files: on the
+# P52 (2026-11-03) %TEMP% held 79,202 files, its 14,041 old ones sat deep under node-compile-cache and all were
+# read in one hour by a scanner, yet the first 5,000 entries held too few old files to judge - so %TEMP% inherited,
+# and kept its old files whenever no other root had set the volume's verdict first in that run. A cache with
+# plenty of old files still stops after 400 of them; only a root of mostly new files walks further.
+$Script:WS_ACCESS_LIVE = @{}
+$Script:WS_ACCESS_LIVE_VOLUME = @{}
+$Script:WS_ACCESS_SAMPLE_MIN = 20
+$Script:WS_ACCESS_SAMPLE_MAX = 400
+$Script:WS_ACCESS_SCAN_CAP = 50000
+$Script:WS_ACCESS_LIVE_RATIO = 0.9
+
+function Test-AccessSampleLive {
+  <# .SYNOPSIS The D82 verdict for a counted sample: enough old files, and nearly all of them read in the last day. #>
+  param([int] $Old, [int] $FreshAccess)
+  if ($Old -lt $Script:WS_ACCESS_SAMPLE_MIN) { return $false }
+  return (($FreshAccess / [double]$Old) -ge $Script:WS_ACCESS_LIVE_RATIO)
+}
+
+function Get-VolumeKey {
+  <# .SYNOPSIS Lower-case volume root of a path ("c:\"), or '' when it cannot be resolved. #>
+  param([string] $Path)
+  $full = Get-FullPath $Path
+  if (-not $full) { return '' }
+  try { return ([IO.Path]::GetPathRoot($full)).ToLowerInvariant() } catch { return '' }
+}
+
+function Get-AccessLiveVolumes {
+  <# .SYNOPSIS Volumes where a D82 sample found last-access live this run ("C:", "D:") - the --json summary names them. #>
+  return @($Script:WS_ACCESS_LIVE_VOLUME.Keys | ForEach-Object { ([string]$_).TrimEnd('\').ToUpperInvariant() } | Sort-Object)
+}
+
+function Reset-AccessVerdicts {
+  <# .SYNOPSIS Forget every D82 verdict (the self-test isolates its fixtures with this). #>
+  $Script:WS_ACCESS_LIVE = @{}
+  $Script:WS_ACCESS_LIVE_VOLUME = @{}
+}
+
+function Test-LastAccessLive {
+  <# .SYNOPSIS $true when last-access carries no signal under Root (D82). Judged once per root from a bounded,
+     breadth-first sample that never follows reparse points; the answer is cached for the run. #>
+  param([string] $Root)
+  $full = Get-FullPath $Root
+  if (-not $full) { return $false }
+  $key = $full.ToLowerInvariant()
+  if ($Script:WS_ACCESS_LIVE.ContainsKey($key)) { return [bool]$Script:WS_ACCESS_LIVE[$key] }
+  $now = [datetime]::UtcNow
+  $oldCut = $now.AddDays(-7); $freshCut = $now.AddDays(-1)
+  $old = 0; $fresh = 0; $seen = 0
+  $rootInfo = Get-ItemInfo $full
+  if ($rootInfo -is [IO.DirectoryInfo] -and -not (Test-ReparsePoint $rootInfo)) {
+    $queue = New-Object System.Collections.Generic.Queue[System.IO.DirectoryInfo]
+    $queue.Enqueue($rootInfo)
+    while ($queue.Count -gt 0 -and $old -lt $Script:WS_ACCESS_SAMPLE_MAX -and $seen -lt $Script:WS_ACCESS_SCAN_CAP) {
+      $dir = $queue.Dequeue()
+      $entries = $null
+      try { $entries = $dir.EnumerateFileSystemInfos() } catch { continue }
+      try {
+        foreach ($e in $entries) {
+          if (($e.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { continue }
+          if (($e.Attributes -band [IO.FileAttributes]::Directory) -ne 0) { $queue.Enqueue([IO.DirectoryInfo]$e); continue }
+          $seen++
+          if ((Get-NewestTimestampUtc $e -IgnoreAccess) -le $oldCut) {
+            $old++
+            if ($e.LastAccessTimeUtc -ge $freshCut) { $fresh++ }
+          }
+          if ($old -ge $Script:WS_ACCESS_SAMPLE_MAX -or $seen -ge $Script:WS_ACCESS_SCAN_CAP) { break }
+        }
+      } catch { $null = $_ }
+    }
+  }
+  if ($old -ge $Script:WS_ACCESS_SAMPLE_MIN) {
+    $live = Test-AccessSampleLive -Old $old -FreshAccess $fresh
+    $Script:WS_ACCESS_LIVE[$key] = $live
+    $vol = Get-VolumeKey $full
+    if ($live -and $vol -and -not $Script:WS_ACCESS_LIVE_VOLUME.ContainsKey($vol)) {
+      $Script:WS_ACCESS_LIVE_VOLUME[$vol] = $true
+      $msg = "last-access looks live on {0} ({1} of {2} files written a week or more ago were read in the last day) - idle age there uses write/creation time" -f $vol.TrimEnd('\').ToUpperInvariant(), $fresh, $old
+      Write-Note $msg
+      Write-LogLine "idle basis: $msg (first seen under $full)"
+    }
+    return $live
+  }
+  $vol = Get-VolumeKey $full
+  $inherit = [bool]($vol -and $Script:WS_ACCESS_LIVE_VOLUME.ContainsKey($vol))
+  $Script:WS_ACCESS_LIVE[$key] = $inherit
+  return $inherit
+}
+
 function Format-Utc8601 {
   <# .SYNOPSIS ISO 8601 UTC for a timestamp, or $null when nothing was found (the MinValue sentinel).
      Get-DirectoryStats returns MinValue for an empty or unreadable tree, and "0001-01-01" in a contract
@@ -79,17 +175,18 @@ function Format-Utc8601 {
 }
 
 function Get-DirectoryStats {
-  <# .SYNOPSIS Walk a tree without following reparse points. Returns Bytes, Files, Dirs, Links, Newest (UTC), Errors. #>
-  param([string] $Path)
+  <# .SYNOPSIS Walk a tree without following reparse points. Returns Bytes, Files, Dirs, Links, Newest (UTC), Errors.
+     -IgnoreAccess leaves last-access out of Newest (D82). #>
+  param([string] $Path, [switch] $IgnoreAccess)
   $bytes = [long]0; $files = 0; $dirs = 0; $links = 0; $errors = 0
   $newest = [datetime]::MinValue
   $root = Get-ItemInfo $Path
   if ($null -eq $root) { return [pscustomobject]@{ Bytes = 0; Files = 0; Dirs = 0; Links = 0; Newest = $newest; Errors = 0; Exists = $false } }
   if ($root -is [IO.FileInfo]) {
-    return [pscustomobject]@{ Bytes = [long]$root.Length; Files = 1; Dirs = 0; Links = 0; Newest = (Get-NewestTimestampUtc $root); Errors = 0; Exists = $true }
+    return [pscustomobject]@{ Bytes = [long]$root.Length; Files = 1; Dirs = 0; Links = 0; Newest = (Get-NewestTimestampUtc $root -IgnoreAccess:$IgnoreAccess); Errors = 0; Exists = $true }
   }
   if (Test-ReparsePoint $root) {
-    return [pscustomobject]@{ Bytes = 0; Files = 0; Dirs = 0; Links = 1; Newest = (Get-NewestTimestampUtc $root); Errors = 0; Exists = $true }
+    return [pscustomobject]@{ Bytes = 0; Files = 0; Dirs = 0; Links = 1; Newest = (Get-NewestTimestampUtc $root -IgnoreAccess:$IgnoreAccess); Errors = 0; Exists = $true }
   }
   $stack = New-Object System.Collections.Generic.Stack[System.IO.DirectoryInfo]
   $stack.Push($root)
@@ -104,13 +201,13 @@ function Get-DirectoryStats {
         $files++
         $bytes += [long]$e.Length
         $t = $e.LastWriteTimeUtc
-        if ($e.LastAccessTimeUtc -gt $t) { $t = $e.LastAccessTimeUtc }
+        if (-not $IgnoreAccess -and $e.LastAccessTimeUtc -gt $t) { $t = $e.LastAccessTimeUtc }
         if ($e.CreationTimeUtc -gt $t) { $t = $e.CreationTimeUtc }
         if ($t -gt $newest) { $newest = $t }
       }
     } catch { $errors++ }
   }
-  if ($newest -eq [datetime]::MinValue) { $newest = Get-NewestTimestampUtc $root }
+  if ($newest -eq [datetime]::MinValue) { $newest = Get-NewestTimestampUtc $root -IgnoreAccess:$IgnoreAccess }
   return [pscustomobject]@{ Bytes = $bytes; Files = $files; Dirs = $dirs; Links = $links; Newest = $newest; Errors = $errors; Exists = $true }
 }
 
@@ -134,14 +231,18 @@ function Get-DirectoryBytes {
 }
 
 function Get-IdleDays {
-  <# .SYNOPSIS Days since the path (or anything inside it) was last touched. 999999 when absent. #>
-  param([string] $Path)
+  <# .SYNOPSIS Days since the path (or anything inside it) was last touched. 999999 when absent.
+     Last-access counts unless Test-LastAccessLive found it carries no signal here (D82). #>
+  # -WriteOnly (P9): write/creation time only - for declared scratch roots, where a scanner's partial read
+  # (67-85% of a month-old test profile's files on the P52, 2026-11-03) must not count as use.
+  param([string] $Path, [switch] $WriteOnly)
   $info = Get-ItemInfo $Path
   if ($null -eq $info) { return 999999 }
+  $ignore = $WriteOnly -or (Test-LastAccessLive -Root $Path)
   if ($info -is [IO.FileInfo] -or (Test-ReparsePoint $info)) {
-    return [int][math]::Floor(([datetime]::UtcNow - (Get-NewestTimestampUtc $info)).TotalDays)
+    return [int][math]::Floor(([datetime]::UtcNow - (Get-NewestTimestampUtc $info -IgnoreAccess:$ignore)).TotalDays)
   }
-  $stats = Get-DirectoryStats $Path
+  $stats = Get-DirectoryStats $Path -IgnoreAccess:$ignore
   return [int][math]::Floor(([datetime]::UtcNow - $stats.Newest).TotalDays)
 }
 
@@ -156,6 +257,7 @@ function Get-StaleFiles {
   if ($null -eq $rootInfo -or -not ($rootInfo -is [IO.DirectoryInfo]) -or (Test-ReparsePoint $rootInfo)) {
     return [pscustomobject]@{ Files = $stale; Dirs = $visited }
   }
+  $ignore = Test-LastAccessLive -Root $Root
   $stack = New-Object System.Collections.Generic.Stack[System.IO.DirectoryInfo]
   $stack.Push($rootInfo)
   while ($stack.Count -gt 0) {
@@ -171,7 +273,7 @@ function Get-StaleFiles {
           continue
         }
         $t = $e.LastWriteTimeUtc
-        if ($e.LastAccessTimeUtc -gt $t) { $t = $e.LastAccessTimeUtc }
+        if (-not $ignore -and $e.LastAccessTimeUtc -gt $t) { $t = $e.LastAccessTimeUtc }
         if ($e.CreationTimeUtc -gt $t) { $t = $e.CreationTimeUtc }
         if ($t -le $cutoff) { $stale.Add([pscustomobject]@{ Path = $e.FullName; Bytes = [long]$e.Length }) }
       }

package/lib/safety.ps1

@@ -1,12 +1,16 @@
 # safety.ps1 - the deletion chokepoint and its guards.
 #
-# Every byte this tool removes passes through Remove-PathSafe (or Send-ToRecycleBin), which:
-#   1. resolves the path and refuses relative segments, UNC paths, drive roots and system roots;
-#   2. refuses every protected subtree / pattern / basename (Test-ProtectedPath);
-#   3. asserts the path lies strictly inside the target root the caller declared (-Within);
-#   4. short-circuits in --dry-run, printing what it would do and tallying an estimate;
-#   5. removes reparse points as links, never following them; skips locked files, never fails a run.
-# No flag bypasses steps 1-3.
+# Every path the tool deletes is first checked by Get-ProtectionReason, which:
+#   1. refuses relative segments, UNC paths, drive roots and system roots;
+#   2. refuses every protected subtree / pattern / basename - except an exception, an exact folder inside a
+#      protected subtree that a section may remove (declared below, or computed for the run: D79);
+#   3. refuses the user's own --exclude-path / excludePaths entries, exceptions included.
+# The deleting functions: Remove-PathSafe (one file, folder or link, strictly inside a declared -Within root),
+# Send-ToRecycleBin, Remove-StaleFiles (each idle file after the same check) and Clear-DirectoryContents (each
+# child through Remove-PathSafe); Remove-TreeInternal removes the children of a folder that passed the check.
+# All of them honour --dry-run, remove reparse points as links without following them, and skip locked files.
+# Tools that delete on their own (docker, cleanmgr, DISM, wevtutil, powercfg, sdkmanager, nvm) run through
+# Invoke-External -Destructive, which --dry-run turns into a printed command. No flag lifts steps 1 and 2.
 
 function Initialize-Safety {
   <# .SYNOPSIS Build the protected-path tables from the environment. Called once at startup. #>
@@ -22,7 +26,10 @@ function Initialize-Safety {
 
   $exact = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::OrdinalIgnoreCase)
   foreach ($d in [IO.DriveInfo]::GetDrives()) { $null = $exact.Add($d.Name.TrimEnd('\')); $null = $exact.Add($d.Name) }
-  foreach ($p in @($SR, "$SR\System32", "$SR\SysWOW64", $PF, $PF86, $PD, "$SD\Users", "$SD\Users\Default", "$SD\Users\Public", $env:PUBLIC, $U, "$U\AppData", $A, $L, $LL)) {
+  # P9: the Common Files and ProgramData\Microsoft roots - section 26 reads InstallLocation from the registry,
+  # and an installer that registered one of these as its own folder must never get it offered as a leftover.
+  foreach ($p in @($SR, "$SR\System32", "$SR\SysWOW64", $PF, $PF86, $PD, "$SD\Users", "$SD\Users\Default", "$SD\Users\Public", $env:PUBLIC, $U, "$U\AppData", $A, $L, $LL,
+      "$PF\Common Files", "$PF86\Common Files", "$PD\Microsoft")) {
     if (-not $p) { continue }
     $fp = Get-FullPath $p
     if ($fp) { $null = $exact.Add($fp) }
@@ -37,12 +44,19 @@ function Initialize-Safety {
     "$A\npm", "$A\nvm", "$L\nvm", "$SD\nvm4w", "$L\Volta", "$L\fnm", "$L\fnm_multishells", "$L\node\corepack",
     "$L\pnpm\global", "$U\.bun\bin", "$U\.bun\install\global", "$U\.deno\bin", "$U\.cargo\bin", "$U\.rustup", "$U\go\bin",
     "$L\Programs", "$L\Microsoft\WindowsApps", "$L\Android\Sdk",
+    # The desktop app's own install and data folders (section 23 offered the data folder on the P52, 2026-11-02).
+    "$L\windowsweep", "$L\com.aoneahsan.windowsweep",
     "$SR\Prefetch", "$SR\Installer", "$SR\WinSxS", "$SR\System32\config", "$SR\servicing", "$SR\Boot", "$SR\Fonts",
     "$PD\Package Cache", "$PD\Microsoft\Windows\Start Menu",
     "$SD\`$Recycle.Bin", "$SD\System Volume Information", "$SD\Recovery", "$SD\Boot", "$SD\EFI"
   )
   # Declared exceptions: paths inside a protected subtree that ARE regenerable caches.
   $exceptions = @("$L\Android\Sdk\.temp", "$L\Android\Sdk\.downloadIntermediates")
+  # D79 (2026-11-02): computed for this run - exactly the superseded Codex release folders section 28 may remove.
+  # The current release and the newest older one are never listed, so the chokepoint still refuses them.
+  if (Get-Command Get-CodexReleaseExceptions -ErrorAction SilentlyContinue) {
+    try { $exceptions += @(Get-CodexReleaseExceptions) } catch { $null = $_ }
+  }
 
   # Wildcards matched against the full path. Browser/editor state that must never be mistaken for cache.
   $patterns = @(
@@ -125,18 +139,23 @@ function Get-ProtectionReason {
   if ($pr.Exact.Contains($p)) { return "protected root: $p" }
   $ic = [StringComparison]::OrdinalIgnoreCase
   $pSlash = $p + '\'
-  foreach ($e in $pr.ExceptionPrefixes) { if ($pSlash.StartsWith($e, $ic)) { return $null } }
-  for ($i = 0; $i -lt $pr.SubtreePrefixes.Count; $i++) {
-    if ($pSlash.StartsWith($pr.SubtreePrefixes[$i], $ic)) { return "inside protected: $($pr.Subtrees[$i])" }
-  }
-  for ($i = 0; $i -lt $pr.PatternObjects.Count; $i++) {
-    if ($pr.PatternObjects[$i].IsMatch($p)) { return "matches protected pattern: $($pr.Patterns[$i])" }
-  }
-  $base = [IO.Path]::GetFileName($p)
-  foreach ($b in $pr.Basenames) { if ($base.Equals($b, $ic)) { return "protected file name: $b" } }
-  if ($Script:WS.Home -and -not $Script:WS.AllowOwnData) {
-    if (-not $pr.HomePrefix) { $pr.HomePrefix = (Get-FullPath $Script:WS.Home) + '\' }
-    if ($pSlash.StartsWith($pr.HomePrefix, $ic)) { return 'the tool''s own data directory' }
+  # An exception lifts the protected lists for its exact folder, never the user's own exclusions below: an
+  # early return here used to let an exception path through even when the user had excluded it.
+  $excepted = $false
+  foreach ($e in $pr.ExceptionPrefixes) { if ($pSlash.StartsWith($e, $ic)) { $excepted = $true; break } }
+  if (-not $excepted) {
+    for ($i = 0; $i -lt $pr.SubtreePrefixes.Count; $i++) {
+      if ($pSlash.StartsWith($pr.SubtreePrefixes[$i], $ic)) { return "inside protected: $($pr.Subtrees[$i])" }
+    }
+    for ($i = 0; $i -lt $pr.PatternObjects.Count; $i++) {
+      if ($pr.PatternObjects[$i].IsMatch($p)) { return "matches protected pattern: $($pr.Patterns[$i])" }
+    }
+    $base = [IO.Path]::GetFileName($p)
+    foreach ($b in $pr.Basenames) { if ($base.Equals($b, $ic)) { return "protected file name: $b" } }
+    if ($Script:WS.Home -and -not $Script:WS.AllowOwnData) {
+      if (-not $pr.HomePrefix) { $pr.HomePrefix = (Get-FullPath $Script:WS.Home) + '\' }
+      if ($pSlash.StartsWith($pr.HomePrefix, $ic)) { return 'the tool''s own data directory' }
+    }
   }
   # A user exclusion is checked LAST, so a path that is both protected and excluded still reports the
   # PROTECTED reason - the stronger statement, and the one no flag can lift. When nothing is excluded the
@@ -428,11 +447,17 @@ function Clear-DirectoryContents {
   return $out
 }
 
+function Test-UsePermanentRemoval {
+  param([bool] $Permanent, [bool] $AlwaysRecycle)
+  return ($Permanent -and -not $AlwaysRecycle)
+}
+
 function Send-ToRecycleBin {
-  <# .SYNOPSIS Move a personal file/folder to the Recycle Bin (or delete when --permanent). Same guards as Remove-PathSafe. #>
-  param([Parameter(Mandatory = $true)][string] $Path, [Parameter(Mandatory = $true)][string] $Within)
+  <# .SYNOPSIS Move a file/folder to the Recycle Bin; section 19 always keeps this undo path. #>
+  param([Parameter(Mandatory = $true)][string] $Path, [Parameter(Mandatory = $true)][string] $Within,
+    [switch] $AlwaysRecycle)
   $ws = $Script:WS
-  if ($ws.Permanent) { return (Remove-PathSafe -Path $Path -Within $Within) }
+  if (Test-UsePermanentRemoval -Permanent $ws.Permanent -AlwaysRecycle $AlwaysRecycle) { return (Remove-PathSafe -Path $Path -Within $Within) }
   $r = New-RemoveResult
   $p = Get-FullPath $Path
   $why = Get-ProtectionReason $p

package/lib/ui.ps1

@@ -96,14 +96,32 @@ function Write-Separator {
   Write-UiLine ([string]::new([char]($Script:WS.Glyph.hline), 78)) 'DarkGray'
 }
 
+function Split-WrappedText {
+  <# .SYNOPSIS Word-wrap text into lines of at most -Width characters; a single longer word stands alone. #>
+  param([string] $Text, [int] $Width)
+  $lines = New-Object System.Collections.Generic.List[string]
+  $current = ''
+  foreach ($word in ($Text -split '\s+')) {
+    if (-not $word) { continue }
+    if (-not $current) { $current = $word; continue }
+    if (($current.Length + 1 + $word.Length) -le $Width) { $current = "$current $word" }
+    else { $lines.Add($current); $current = $word }
+  }
+  if ($current) { $lines.Add($current) }
+  return , $lines.ToArray()
+}
+
 function Write-Box {
-  <# .SYNOPSIS Double-lined title box with an optional dim subtitle. #>
+  <# .SYNOPSIS Double-lined title box with an optional dim subtitle, wrapped inside the 78-glyph rule. #>
   param([string] $Title, [string] $Subtitle = '')
   $line = [string]::new([char]($Script:WS.Glyph.dline), 78)
   Write-UiLine '' 'Gray'
   Write-UiLine $line 'Blue'
   Write-UiLine ("   $Title") 'Blue'
-  if ($Subtitle) { Write-UiLine ("   $Subtitle") 'DarkGray' }
+  if ($Subtitle) {
+    # The rule is 78 glyphs and the subtitle is indented by three, so each line holds 75.
+    foreach ($part in (Split-WrappedText -Text $Subtitle -Width 75)) { Write-UiLine ("   $part") 'DarkGray' }
+  }
   Write-UiLine $line 'Blue'
 }
 

package/modules/android_avd.ps1

@@ -1,36 +1,187 @@
-# android_avd.ps1 - section 4: Android emulators (AVDs). Slow to recreate, so per-AVD idle gate and never in --all.
-
-function Get-Targets04 {
-  return @((New-Target 4 'Android AVDs (each .avd + .ini pair)' "$($Script:P.U)\.android\avd" -Mode units -Dev $true -Note "an AVD goes only when nothing inside it changed for $($Script:WS.Days)+ days"))
-}
-
-function Invoke-Section04 {
-  $ws = $Script:WS
-  $root = Join-Path $Script:P.U '.android\avd'
-  Write-SectionIntro @(
-    'An emulator image is 5-15 GB and takes minutes to recreate. Each AVD is one unit: it is removed only when',
-    "every file inside it has been idle for $($ws.Days)+ days (booting an emulator updates its files)."
-  ) -Dev $true
-  if (-not (Test-DirPresent $root)) { Write-Info 'no AVDs found'; return }
-  if (Test-ProcessRunning @('qemu-system-x86_64', 'emulator', 'emulator64-crash-service')) { Write-Warn 'an Android emulator is running - section skipped'; return }
-  $avds = @()
-  foreach ($e in (Get-ChildEntries $root)) {
-    if (-not ($e -is [IO.DirectoryInfo]) -or $e.Name -notlike '*.avd') { continue }
-    $full = Remove-LongPrefix $e.FullName
-    $avds += [pscustomobject]@{ Name = $e.Name; Path = $full; Ini = (Join-Path $root ($e.Name -replace '\.avd$', '.ini')); Idle = (Get-IdleDays $full); Bytes = (Get-DirectoryBytes $full) }
-  }
-  if ($avds.Count -eq 0) { Write-Info 'no AVDs found'; return }
-  Write-UiLine ("  {0,-36} {1,10} {2,8}" -f 'AVD', 'SIZE', 'IDLE') 'White'
-  foreach ($a in $avds) { Write-UiLine ("  {0,-36} {1,10} {2,7}d" -f $a.Name, (Format-Bytes $a.Bytes), $a.Idle) 'Gray' }
-  $avds = @($avds)
-  $stale = @($avds | Where-Object { $_.Idle -ge $ws.Days -or $ws.PurgeAll })
-  if ($stale.Count -eq 0) { Write-Info "every AVD was used within the last $($ws.Days) days - nothing to prune"; return }
-  if (-not (Confirm-Section "Remove $($stale.Count) idle AVD(s)?" 'n')) { Write-Info 'skipped'; return }
-  foreach ($a in $stale) {
-    $r = Remove-PathSafe -Path $a.Path -Within $root -Label $a.Name
-    if ($r.Removed) {
-      if (Test-PathPresent $a.Ini) { $null = Remove-PathSafe -Path $a.Ini -Within $root -Label "$($a.Name) ini" }
-      if (-not $ws.DryRun) { Write-Ok ("removed AVD $($a.Name) ($($a.Idle)d idle, " + (Format-Bytes $r.Bytes) + ')') }
-    }
-  }
-}
+# android_avd.ps1 - section 4: Android emulators (AVDs) and what they leave. Slow to recreate, so a per-AVD idle
+# gate and never in --all. P9: every AVD root (also ANDROID_AVD_HOME), pointer .ini files whose AVD is gone
+# (the P52's pointed into a drive that no longer existed, 2026-11-02) and system images no remaining AVD uses -
+# removed with the SDK's own sdkmanager, the emulator too once no AVD is left. ASCII only.
+
+function Get-AvdRoots {
+  <# .SYNOPSIS Every folder the emulator may keep AVDs in: the default, ANDROID_AVD_HOME, and the avd folder under
+     ANDROID_EMULATOR_HOME / ANDROID_SDK_HOME / ANDROID_PREFS_ROOT (process, user, machine) - existing ones, once
+     each. A missed root would make its AVDs' images look unused. #>
+  $default = Join-Path $Script:P.U '.android\avd'
+  $seen = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::OrdinalIgnoreCase)
+  $cands = @($default)
+  foreach ($scope in 'Process', 'User', 'Machine') {
+    $cands += [Environment]::GetEnvironmentVariable('ANDROID_AVD_HOME', $scope)
+    $em = [Environment]::GetEnvironmentVariable('ANDROID_EMULATOR_HOME', $scope)
+    if ($em) { $cands += (Join-Path $em 'avd') }
+    foreach ($v in 'ANDROID_SDK_HOME', 'ANDROID_PREFS_ROOT') { $h = [Environment]::GetEnvironmentVariable($v, $scope); if ($h) { $cands += (Join-Path $h '.android\avd') } }
+  }
+  $out = @()
+  foreach ($c in $cands) {
+    if (-not $c) { continue }
+    $f = Get-FullPath $c
+    if (-not $f -or -not $seen.Add($f)) { continue }
+    if (Test-DirPresent $f) { $out += $f } elseif ($f -ne (Get-FullPath $default)) { Write-Note "an Android variable names the AVD folder $f, which does not exist" }
+  }
+  return $out
+}
+
+function Read-KeyValueFile {
+  <# .SYNOPSIS The key=value lines of an AVD .ini or config.ini; empty when unreadable. #>
+  param([string] $Path)
+  $h = @{}
+  try { foreach ($line in [IO.File]::ReadAllLines($Path)) { $i = $line.IndexOf('='); if ($i -gt 0) { $h[$line.Substring(0, $i).Trim()] = $line.Substring($i + 1).Trim() } } } catch { $null = $_ }
+  return $h
+}
+
+function Get-AvdInventory {
+  <# .SYNOPSIS AVD folders in the roots, AVDs stored elsewhere that a pointer .ini names (External: used for image
+     references, never pruned here), and pointer .ini files whose AVD folder is gone. #>
+  param([string[]] $Roots)
+  $avds = @(); $dangling = @()
+  $seen = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::OrdinalIgnoreCase)
+  foreach ($root in $Roots) {
+    foreach ($e in (Get-ChildEntries $root)) {
+      if ($e -is [IO.DirectoryInfo] -and $e.Name -like '*.avd') {
+        $full = Remove-LongPrefix $e.FullName
+        if ($seen.Add($full)) { $avds += [pscustomobject]@{ Name = $e.Name; Path = $full; Root = $root; Ini = (Join-Path $root ($e.Name -replace '\.avd$', '.ini')); External = $false } }
+      }
+    }
+  }
+  foreach ($root in $Roots) {
+    foreach ($e in (Get-ChildEntries $root)) {
+      if (-not ($e -is [IO.FileInfo]) -or $e.Name -notlike '*.ini') { continue }
+      $full = Remove-LongPrefix $e.FullName
+      $target = [string](Read-KeyValueFile $full)['path']
+      if (-not $target) { $target = Join-Path $root ($e.Name -replace '\.ini$', '.avd') }
+      if (-not (Test-DirPresent $target)) { $dangling += [pscustomobject]@{ Path = $full; Root = $root; Target = $target }; continue }
+      $t = Get-FullPath $target
+      if ($seen.Add($t)) { $avds += [pscustomobject]@{ Name = (Split-Path -Leaf $t); Path = $t; Root = (Split-Path -Parent $t); Ini = $full; External = $true } }
+    }
+  }
+  return [pscustomobject]@{ Avds = $avds; Dangling = $dangling }
+}
+
+function Get-AndroidSdkRoot {
+  foreach ($c in @($env:ANDROID_HOME, $env:ANDROID_SDK_ROOT, [Environment]::GetEnvironmentVariable('ANDROID_HOME', 'User'),
+      [Environment]::GetEnvironmentVariable('ANDROID_SDK_ROOT', 'User'), (Join-Path $Script:P.L 'Android\Sdk'))) {
+    if ($c -and (Test-DirPresent $c)) { return (Get-FullPath $c) }
+  }
+  return ''
+}
+
+function Get-SystemImages {
+  <# .SYNOPSIS <sdk>\system-images\<api>\<tag>\<abi> folders. Broken = holds no image (an interrupted install left
+     only its .installer folder on the P52): sdkmanager does not know it, so it is only reported. #>
+  param([string] $Sdk)
+  $out = @()
+  foreach ($api in (Get-ChildEntries (Join-Path $Sdk 'system-images'))) {
+    if (-not ($api -is [IO.DirectoryInfo])) { continue }
+    foreach ($tag in (Get-ChildEntries (Remove-LongPrefix $api.FullName))) {
+      if (-not ($tag -is [IO.DirectoryInfo])) { continue }
+      foreach ($abi in (Get-ChildEntries (Remove-LongPrefix $tag.FullName))) {
+        if (-not ($abi -is [IO.DirectoryInfo])) { continue }
+        $p = Remove-LongPrefix $abi.FullName
+        $broken = -not ((Test-PathPresent (Join-Path $p 'source.properties')) -or (Test-PathPresent (Join-Path $p 'system.img')) -or (Test-PathPresent (Join-Path $p 'package.xml')))
+        $out += [pscustomobject]@{ Package = "system-images;$($api.Name);$($tag.Name);$($abi.Name)"; Path = $p; Rel = ("system-images\$($api.Name)\$($tag.Name)\$($abi.Name)").ToLowerInvariant(); Broken = $broken }
+      }
+    }
+  }
+  return $out
+}
+
+function Get-UnusedSdkPackages {
+  <# .SYNOPSIS Pure: the system images no remaining AVD's config.ini names, and the emulator once no AVD is left.
+     An AVD whose config names no image (unreadable, or made by hand) keeps every image. #>
+  param([object[]] $Images, [object[]] $Avds, [bool] $EmulatorPresent)
+  $used = New-Object System.Collections.Generic.HashSet[string]([StringComparer]::OrdinalIgnoreCase)
+  foreach ($a in @($Avds)) {
+    $kv = Read-KeyValueFile (Join-Path $a.Path 'config.ini')
+    $refs = @($kv.Keys | Where-Object { $_ -like 'image.sysdir.*' } | ForEach-Object { ([string]$kv[$_]).Replace('/', '\').Trim('\').ToLowerInvariant() })
+    if ($refs.Count -eq 0) { return [pscustomobject]@{ Packages = @(); Reason = "the AVD $($a.Name) names no system image - every image is kept" } }
+    foreach ($r in $refs) { $null = $used.Add($r) }
+  }
+  $drop = @($Images | Where-Object { -not $used.Contains($_.Rel) })
+  if ($EmulatorPresent -and @($Avds).Count -eq 0) { $drop += [pscustomobject]@{ Package = 'emulator'; Path = ''; Rel = 'emulator' } }
+  return [pscustomobject]@{ Packages = $drop; Reason = '' }
+}
+
+function Get-SdkManagerPath {
+  param([string] $Sdk)
+  $c = @((Join-Path $Sdk 'cmdline-tools\latest\bin\sdkmanager.bat'))
+  $c += @(Get-ChildEntries (Join-Path $Sdk 'cmdline-tools') | Sort-Object Name -Descending | ForEach-Object { Join-Path (Remove-LongPrefix $_.FullName) 'bin\sdkmanager.bat' })
+  $c += (Join-Path $Sdk 'tools\bin\sdkmanager.bat')
+  foreach ($p in $c) { if (Test-PathPresent $p) { return $p } }
+  return ''
+}
+
+function Remove-SdkPackages {
+  <# .SYNOPSIS Uninstall SDK packages with the SDK's own sdkmanager (no file is deleted by this tool). #>
+  param([string] $Sdk, [object[]] $Packages)
+  $tool = Get-SdkManagerPath $Sdk
+  if (-not $tool) { Write-Warn ('sdkmanager was not found; remove them in Android Studio > SDK Manager: ' + (($Packages | ForEach-Object { $_.Package }) -join ', ')); return }
+  $savedJava = $env:JAVA_HOME
+  $jbr = Join-Path $Script:P.PF 'Android\Android Studio\jbr'
+  if (-not $env:JAVA_HOME -and -not (Test-CommandPresent 'java') -and (Test-DirPresent $jbr)) { $env:JAVA_HOME = $jbr }
+  try {
+    foreach ($pkg in $Packages) {
+      $bytes = [long]0
+      if ($pkg.Path) { $bytes = [long](Get-DirectoryBytes $pkg.Path) } else { $bytes = [long](Get-DirectoryBytes (Join-Path $Sdk 'emulator')) }
+      $r = Invoke-External -FilePath $tool -ArgumentList @('--uninstall', $pkg.Package) -Destructive -Quiet -Label 'sdkmanager'
+      if ($Script:WS.DryRun) { Add-Freed $bytes; continue }
+      $left = $pkg.Path
+      if (-not $left) { $left = Join-Path $Sdk 'emulator' }
+      if (-not (Test-DirPresent $left)) { Add-Freed $bytes; Write-Ok ("{0} removed with sdkmanager ({1})" -f $pkg.Package, (Format-Bytes $bytes)) } else { Write-Warn "$($pkg.Package) is still installed (sdkmanager exit $($r.ExitCode))" }
+    }
+  } finally { $env:JAVA_HOME = $savedJava }
+}
+
+function Get-Targets04 {
+  $t = @((New-Target 4 'Android AVDs (each .avd + .ini pair)' "$($Script:P.U)\.android\avd" -Mode units -Dev $true -Note "an AVD goes only when nothing inside it changed for $($Script:WS.Days)+ days"))
+  $sdk = Get-AndroidSdkRoot
+  if ($sdk) { $t += (New-Target 4 'Android system images no AVD uses' (Join-Path $sdk 'system-images') -Kind cmd -Dev $true -Note 'removed with sdkmanager; the emulator too once no AVD is left') }
+  return $t
+}
+
+function Invoke-Section04 {
+  $ws = $Script:WS
+  Write-SectionIntro @(
+    'An emulator image is 5-15 GB and takes minutes to recreate. Each AVD is one unit: it is removed only when',
+    "every file inside it has been idle for $($ws.Days)+ days (booting an emulator updates its files). Pointer .ini",
+    'files whose AVD is gone, and system images no remaining AVD uses, go too - the images with the SDK''s sdkmanager.'
+  ) -Dev $true
+  if (Test-ProcessRunning @('qemu-system-x86_64', 'emulator', 'emulator64-crash-service')) { Write-Warn 'an Android emulator is running - section skipped'; return }
+  $inv = Get-AvdInventory -Roots @(Get-AvdRoots)
+  $own = @($inv.Avds | Where-Object { -not $_.External })
+  foreach ($a in $own) { $a | Add-Member -NotePropertyName Idle -NotePropertyValue (Get-IdleDays $a.Path) -Force; $a | Add-Member -NotePropertyName Bytes -NotePropertyValue (Get-DirectoryBytes $a.Path) -Force }
+  if ($own.Count -gt 0) {
+    Write-UiLine ("  {0,-36} {1,10} {2,8}" -f 'AVD', 'SIZE', 'IDLE') 'White'
+    foreach ($a in $own) { Write-UiLine ("  {0,-36} {1,10} {2,7}d" -f $a.Name, (Format-Bytes $a.Bytes), $a.Idle) 'Gray' }
+  }
+  $stale = @($own | Where-Object { $_.Idle -ge $ws.Days -or $ws.PurgeAll })
+  foreach ($d in $inv.Dangling) { Write-UiLine ("  pointer to a missing AVD: {0}  (-> {1})" -f $d.Path, $d.Target) 'Gray' }
+  $sdk = Get-AndroidSdkRoot
+  $unused = [pscustomobject]@{ Packages = @(); Reason = '' }
+  if ($sdk) {
+    $remaining = @($inv.Avds | Where-Object { $stale -notcontains $_ })
+    $all = @(Get-SystemImages $sdk)
+    foreach ($b in @($all | Where-Object { $_.Broken })) { Write-UiLine ("  an interrupted SDK install left {0} - remove it in Android Studio > SDK Manager, or delete the folder" -f $b.Path) 'Gray' }
+    $unused = Get-UnusedSdkPackages -Images @($all | Where-Object { -not $_.Broken }) -Avds $remaining -EmulatorPresent (Test-DirPresent (Join-Path $sdk 'emulator'))
+    if ($unused.Reason) { Write-Note $unused.Reason }
+    foreach ($p in $unused.Packages) { Write-UiLine ("  SDK package no AVD uses: {0}" -f $p.Package) 'Gray' }
+  }
+  $n = $stale.Count + @($inv.Dangling).Count + @($unused.Packages).Count
+  if ($n -eq 0) { Write-Info "nothing to remove: every AVD was used within $($ws.Days) days, no pointer is dangling and every image is in use"; return }
+  if (-not (Confirm-Section ("Remove {0} idle AVD(s), {1} dangling pointer(s) and {2} unused SDK package(s)?" -f $stale.Count, @($inv.Dangling).Count, @($unused.Packages).Count) 'n')) { Write-Info 'skipped'; return }
+  foreach ($a in $stale) {
+    $r = Remove-PathSafe -Path $a.Path -Within $a.Root -Label $a.Name
+    if ($r.Removed) {
+      if (Test-PathPresent $a.Ini) { $null = Remove-PathSafe -Path $a.Ini -Within $a.Root -Label "$($a.Name) ini" }
+      if (-not $ws.DryRun) { Write-Ok ("removed AVD $($a.Name) ($($a.Idle)d idle, " + (Format-Bytes $r.Bytes) + ')') }
+    }
+  }
+  foreach ($d in $inv.Dangling) { $null = Send-ToRecycleBin -Path $d.Path -Within $d.Root }
+  if (@($unused.Packages).Count -eq 0) { return }
+  if (-not $ws.DryRun -and @($stale | Where-Object { Test-DirPresent $_.Path }).Count -gt 0) { Write-Warn 'an AVD could not be removed - its system image is kept; run section 4 again'; return }
+  Remove-SdkPackages -Sdk $sdk -Packages @($unused.Packages)
+}