@git.zone/tsdisk 1.1.0 → 1.3.0

package/dist_ts/tsdisk.usage.js

@@ -0,0 +1,194 @@
+import * as plugins from './tsdisk.plugins.js';
+export function containsPath(parent, child) {
+    const relative = plugins.path.relative(parent, child);
+    return relative === '' || (!relative.startsWith(`..${plugins.path.sep}`) && relative !== '..' && !plugins.path.isAbsolute(relative));
+}
+/** Preserve explicitly selected nested mounts; subsume overlapping roots on the same device. */
+export async function normalizeScanRoots(roots) {
+    const unique = [...new Set(roots.map((root) => plugins.path.resolve(root)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
+    const accepted = [];
+    for (const path of unique) {
+        const stat = await plugins.fs.lstat(path).catch(() => undefined);
+        const real = await plugins.fs.realpath(path).catch(() => undefined);
+        const dev = stat?.isDirectory() && real === path ? stat.dev : undefined;
+        if (dev !== undefined && accepted.some((parent) => parent.dev === dev && containsPath(parent.path, path)))
+            continue;
+        accepted.push({ path, dev });
+    }
+    return accepted.map((root) => root.path);
+}
+/** GNU du emits files immediately and inclusive directory totals on completion.
+ * Reconcile each completed directory with its observed children, rather than
+ * adding inclusive totals twice. The active ancestor chain survives a timeout.
+ */
+export class UsageAccumulator {
+    roots;
+    trackedPaths;
+    priorityPaths;
+    pending = '';
+    active = new Map();
+    largest = new Map();
+    tracked = new Map();
+    minimumLargestBytes = 0;
+    operandBytes = new Map();
+    accountingRoots;
+    currentRoot;
+    measuredBytes = 0;
+    records = 0;
+    currentPath = '';
+    constructor(roots, trackedPaths = new Set(), priorityPaths = []) {
+        this.roots = roots;
+        this.trackedPaths = trackedPaths;
+        this.priorityPaths = priorityPaths;
+        this.roots = [...roots].sort((a, b) => b.length - a.length);
+        if (roots.some((root) => plugins.path.resolve(root) !== root) || priorityPaths.some((path) => !roots.some((root) => root !== path && containsPath(root, path)))) {
+            throw new Error('Usage accounting requires normalized roots and strict descendant priority paths.');
+        }
+        this.accountingRoots = [...priorityPaths, ...roots].sort((a, b) => b.length - a.length);
+        this.trackedPaths = new Set([...trackedPaths, ...roots, ...priorityPaths]);
+    }
+    consume(chunk) {
+        this.pending += chunk;
+        let start = 0;
+        for (;;) {
+            const end = this.pending.indexOf('\0', start);
+            if (end < 0)
+                break;
+            this.record(this.pending.slice(start, end));
+            start = end + 1;
+        }
+        this.pending = this.pending.slice(start);
+        if (this.pending.length > 1024 * 1024)
+            throw new Error('Invalid du record exceeds 1 MiB.');
+    }
+    record(record) {
+        const separator = record.indexOf('\t');
+        const bytes = Number(record.slice(0, separator));
+        const path = record.slice(separator + 1);
+        const matches = (candidate) => path === candidate || path.startsWith(candidate === '/' ? '/' : `${candidate}/`);
+        const root = this.currentRoot && matches(this.currentRoot) ? this.currentRoot : this.accountingRoots.find(matches);
+        if (separator < 1 || !Number.isSafeInteger(bytes) || bytes < 0 || !plugins.path.isAbsolute(path) || !root)
+            throw new Error('Invalid du output.');
+        this.records++;
+        this.currentPath = path;
+        this.currentRoot = path === root ? undefined : root;
+        const delta = bytes - (this.active.get(path) ?? 0);
+        this.active.delete(path);
+        this.measuredBytes += delta;
+        this.operandBytes.set(root, (this.operandBytes.get(root) ?? 0) + delta);
+        if (path !== root) {
+            for (let parent = plugins.path.dirname(path);; parent = plugins.path.dirname(parent)) {
+                this.active.set(parent, (this.active.get(parent) ?? 0) + delta);
+                if (parent === root)
+                    break;
+            }
+        }
+        const entry = { path, bytes, complete: true };
+        if (this.trackedPaths.has(path))
+            this.tracked.set(path, entry);
+        // Retain only the largest completed paths, not millions of file records.
+        if (this.largest.size < 100 || bytes > this.minimumLargestBytes) {
+            this.largest.set(path, entry);
+            if (this.largest.size > 100) {
+                const sorted = [...this.largest.values()].sort((a, b) => b.bytes - a.bytes);
+                this.largest = new Map(sorted.slice(0, 100).map((item) => [item.path, item]));
+            }
+            this.minimumLargestBytes = Math.min(...[...this.largest.values()].map((item) => item.bytes));
+        }
+    }
+    snapshot() {
+        const entries = new Map([...this.largest, ...this.tracked].map(([path, entry]) => [path, { ...entry }]));
+        for (const [path, bytes] of this.active)
+            entries.set(path, { path, bytes, complete: false });
+        // du charges an overlapping subtree to its first operand and omits it from
+        // later ancestor totals. Restore those inclusive totals for display only;
+        // measuredBytes remains the native, deduplicated sum of operand contributions.
+        for (const priority of this.priorityPaths) {
+            const bytes = this.operandBytes.get(priority);
+            const root = this.roots.find((candidate) => containsPath(candidate, priority));
+            if (bytes === undefined || !root)
+                continue;
+            for (let parent = plugins.path.dirname(priority);; parent = plugins.path.dirname(parent)) {
+                const entry = entries.get(parent) ?? { path: parent, bytes: 0, complete: false };
+                entry.bytes += bytes;
+                entries.set(parent, entry);
+                if (parent === root)
+                    break;
+            }
+        }
+        return [...entries.values()].sort((a, b) => b.bytes - a.bytes);
+    }
+    get endedOnRecordBoundary() { return this.pending.length === 0; }
+}
+/** One streaming native pass; no output export, no symlink traversal, no raw file content reads. */
+export async function measureDiskUsage(roots, options) {
+    if (!Number.isFinite(options.timeoutSeconds) || options.timeoutSeconds <= 0)
+        throw new Error('Invalid usage timeout.');
+    const valid = [];
+    const devices = new Map();
+    const errors = [];
+    for (const root of await normalizeScanRoots(roots)) {
+        try {
+            const stat = await plugins.fs.lstat(root);
+            if (!stat.isDirectory() || await plugins.fs.realpath(root) !== root)
+                throw new Error('Usage roots must be real directories without symlink ancestors.');
+            valid.push(root);
+            devices.set(root, stat.dev);
+        }
+        catch (error) {
+            errors.push(`${root}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const priorities = [];
+    for (const path of await normalizeScanRoots(options.priorityPaths ?? [])) {
+        const root = [...valid].reverse().find((root) => root !== path && containsPath(root, path));
+        if (!root)
+            continue;
+        const real = await plugins.fs.realpath(path).catch(() => undefined);
+        const stat = await plugins.fs.lstat(path).catch(() => undefined);
+        if (real === path && stat?.isDirectory() && stat.dev === devices.get(root))
+            priorities.push(path);
+    }
+    // Measure retained project artifacts before broad dependency/source trees.
+    // This changes order only: remaining paths are visited by the final roots.
+    priorities.sort((a, b) => b.split(plugins.path.sep).length - a.split(plugins.path.sep).length || a.localeCompare(b));
+    let argumentBytes = valid.reduce((sum, path) => sum + Buffer.byteLength(path) + 1, 0);
+    const argumentLimit = priorities.findIndex((path) => (argumentBytes += Buffer.byteLength(path) + 1) > 128 * 1024);
+    if (argumentLimit >= 0)
+        priorities.splice(argumentLimit);
+    const usage = new UsageAccumulator(valid, new Set(options.trackedPaths), priorities);
+    let stderr = errors.join('\n');
+    let malformed = false;
+    const code = valid.length ? await new Promise((resolve) => {
+        const child = plugins.spawn('timeout', ['--kill-after=5s', `${options.timeoutSeconds}s`, 'du', '-a', '-0', '-x', '-B1', '--', ...priorities, ...valid], { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, LC_ALL: 'C' } });
+        child.stdout.setEncoding('utf8');
+        let lastNotification = 0;
+        child.stdout.on('data', (chunk) => {
+            if (malformed)
+                return;
+            try {
+                usage.consume(chunk);
+                if (Date.now() - lastNotification >= 250) {
+                    options.onProgress?.(usage);
+                    lastNotification = Date.now();
+                }
+            }
+            catch (error) {
+                malformed = true;
+                stderr += `\n${error instanceof Error ? error.message : String(error)}`;
+                // Signal timeout, which forwards termination to its managed process group.
+                child.kill('SIGTERM');
+            }
+        });
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => { if (stderr.length < 65536)
+            stderr += chunk.slice(0, 65536 - stderr.length); });
+        child.on('error', (error) => { stderr += `\n${error.message}`; });
+        child.on('close', (exitCode) => resolve(exitCode ?? 1));
+    }) : 1;
+    options.onProgress?.(usage);
+    const complete = code === 0 && !stderr.trim() && !malformed && usage.endedOnRecordBoundary;
+    const entries = usage.snapshot().map((entry) => ({ ...entry, complete: entry.complete && complete }));
+    return { roots: valid, measuredBytes: usage.measuredBytes, entries, records: usage.records, complete, code, stderr };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tsdisk.usage.js","sourceRoot":"","sources":["../ts/tsdisk.usage.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsdisk",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "private": false,
   "description": "A disk usage diagnostic CLI for finding large files, caches, logs, and Docker storage.",
   "main": "dist_ts/index.js",
@@ -20,9 +20,9 @@
     "license.md"
   ],
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tstest": "^3.6.6",
-    "@types/node": "^25.9.3"
+    "@git.zone/tsbuild": "^4.5.0",
+    "@git.zone/tstest": "^6.1.1",
+    "@types/node": "^26.5.1"
   },
   "scripts": {
     "test": "(pnpm run build && tstest test/ --verbose)",

package/readme.md

@@ -24,9 +24,11 @@ pnpm dlx @git.zone/tsdisk
 tsdisk
 ```
 
-The tool prints a structured report covering filesystem usage, top-level `du` breakdowns, known user and system cache paths, project-local tool caches on mounted workspaces such as `/mnt/data`, systemd journal usage, deleted open files, and Docker context storage.
+The tool prints a structured report covering filesystem usage, large files and directories on mounted workspaces such as `/mnt/data`, known user and system cache paths, project-local tool caches, systemd journal usage, deleted open files, and Docker context storage. Both the default human report and `scan` print live progress every five seconds, including the current stage, discovered cache count, measured workspace bytes, potential cleanup bytes, and the largest paths found so far.
 
-It asks for `sudo` because root-owned filesystem paths and deleted open files require elevated permissions. Cleanup commands are printed as suggestions only; `tsdisk` does not delete caches or prune Docker data.
+Potential cleanup is an estimate of measured cache candidates requiring owner review, not guaranteed free space. Explicitly protected caches and overlapping parent/child candidates are excluded from that estimate. Unknown sizes are counted separately. Hardlinks or shared filesystem extents can reduce actual savings. Backups, checkpoints, and worktrees appear as large disk consumers but are never automatically classified as removable. Confirmed reclaimable bytes remain unknown until the owning tool verifies cleanup eligibility.
+
+It asks for `sudo` because root-owned filesystem paths and deleted open files require elevated permissions. The default diagnostic command does not delete caches or prune Docker data. The explicit `cleanup` command previews owning-tool cleanup and requires `--apply` to execute it.
 
 ### Project Tool Cache Diagnostics
 
@@ -34,13 +36,14 @@ It asks for `sudo` because root-owned filesystem paths and deleted open files re
 
 - Deno self-extracting staging such as `dist/binaries/.*/.deno_compile_node_modules`
 - Release binary staging under `.nogit/release-binaries/.*/.deno_compile_node_modules`
-- tsbundle temp workspaces under `.nogit/tsbundle-temp`
+- tsbundle temp workspaces under `.nogit/tsbundle-temp` and `.nogit/tsbundle-temp-*`
+- Retained Rust matrix directories and renamed legacy Docker registries (report-only)
 - tsdocker local registry caches under `.nogit/docker-registry`
 - Rust target caches under `rust/target`, `ts_rust/target`, and marked `.nogit/tsrust-target`
 - Stopped `tsdocker-registry-*` containers and their bind mounts
 - Docker buildx state volumes with zero container links, as report-only findings
 
-Marked caches using `.gitzone-tool-cache.json` are classified as tool-owned. Unmarked legacy paths are report-only and do not receive destructive cleanup commands.
+Markers identify ownership, never prove inactivity. Marked caches require review; `safeToPrune: false` remains explicitly protected. No cache finding receives a raw `rm -rf` command. Unmarked legacy paths, bundle intermediates, and retained matrix runs remain report-only. Bundle cleanup belongs to tsbundle’s own stale-workspace lifecycle.
 
 ## Environment
 
@@ -53,31 +56,53 @@ Marked caches using `.gitzone-tool-cache.json` are classified as tool-owned. Unm
 | `TSDISK_KEEP_NCDU_EXPORT` | Keep the `ncdu` export for later browsing | unset |
 | `TSDISK_INSTALL_NCDU` | Install `ncdu` with `apt-get` if missing | prompt |
 
-## Commands
+## Structured Diagnostics
 
 ```bash
+tsdisk scan --root /mnt/data/foss.global --json
+tsdisk scan --root /mnt/data/project-a --root /mnt/data/project-b
 tsdisk --json
 tsdisk --help
 tsdisk --version
 ```
 
-`tsdisk --json` prints the project tool-cache diagnostics as structured JSON:
-
-```json
-{
-  "toolCaches": [
-    {
-      "path": "/mnt/data/project/.nogit/tsbundle-temp",
-      "ownerGuess": "@git.zone/tsbundle",
-      "kind": "bundle-temp-workspace",
-      "risk": "report-only",
-      "suggestedCleanupCommand": "report-only: verify ownership before removing \"/mnt/data/project/.nogit/tsbundle-temp\"",
-      "bytes": 123456
-    }
-  ]
-}
+`scan` and `--json` run bounded, noninteractive diagnostics without requesting sudo or installing tools. `--root` selects project-cache discovery and workspace size roots; host filesystem, home/cache, journal, deleted-open-file, and Docker diagnostics are still included. Without roots, discovery uses `/mnt/data` when present and the current directory. The original `tsdisk` human report remains available.
+
+The JSON object includes `schemaVersion`, `generatedAt`, `roots`, `toolCaches`, `issues`, `issueCounts`, `usage`, `reclaim`, `sections`, and `complete`. Sections with `kind: "command"` record the executed command, arguments, exit code, stdout, stderr, and completeness. Workspace sections have `kind: "derived"`, `derivedFrom: "usage.entries"`, and `command: "usage-summary"`; their text is a compatibility summary of at most 100 retained paths, not native command output. Capped summaries set `result.truncated: true` and `complete: false`. Use `usage.entries` for structured paths and partial-size flags. Missing tools, command warnings, and insufficient permissions remain visible. JSON stdout contains exactly one document; five-second progress updates go to stderr.
+
+`usage` records measured bytes, processed record count, the largest paths, cache paths, and completeness. It streams one native `du -a -0 -x -B1` pass over the selected roots, retaining partial ancestor totals even when a large directory exceeds the time budget. Discovered `.nogit` directories are measured first, so retained checkpoints and worktrees become visible before broad dependency trees. GNU du counts overlapping operands and hardlinks once; the report reconstructs inclusive ancestor totals without adding those bytes twice. `complete: false` sizes are lower bounds; human output marks them with `+`. Inclusive parent/child sizes must not be added together. File records are consumed as they arrive rather than retained in memory or exported to disk. The native pass includes dependencies, backups, and arbitrary large files. Overlapping roots on the same device are scanned once; explicitly selected nested mounts are retained.
+
+`reclaim.candidateBytes` counts measured cache candidates without parent/child overlap; `unknownSizeCount` counts unsized candidates. `confirmedReclaimableBytes` is `null` and `status` is `owner-review-required`: discovery does not run project-installed cleanup tools or establish inactivity.
+
+Cache discovery records read failures, invalid markers, symlinks, filesystem boundaries, and exhausted depth, entry, or time budgets. Unknown sizes stay absent rather than becoming zero. Symlink roots and roots with symlink ancestors are rejected. Standard dependency and generated-code directories are intentionally excluded. Cache byte sizes are allocated disk usage, not a promise of reclaimable space: parent/child findings and hardlinks may overlap.
+
+Cache discovery visits directories breadth first, so nearby projects precede deep worktrees. It is bounded to depth 8, 50,000 directory/symlink inspections, and 45 seconds per root. Ordinary source files do not consume the directory budget; each directory listing is capped at 4,096 entries so a huge flat directory cannot starve its siblings. `issueCounts` retains totals by reason; `issues` contains at most 200 discovery examples per root, plus sizing issues. Sizing has a 45-second budget and a 500-cache limit. Workspace usage has one `DU_TIMEOUT` budget (default 300 seconds, plus five seconds for termination). Additional command diagnostics have a 120-second total budget, with at most 15 seconds per command. Discovery limits are cooperative between filesystem operations. `scan` exits `0` for a complete report, `2` for an incomplete report, or `1` for invalid input/failure. Consumers of the earlier `--json` shape can still read `toolCaches` and workspace command sections.
+
+## Cleanup
+
+```bash
+# Project paths are explicit; cleanup never recurses across a workspace.
+tsdisk cleanup --root /mnt/data/project --only=docker
+# pnpm has no prune dry-run: preview identifies its configured store.
+tsdisk cleanup --root /mnt/data/project --only=pnpm --json
+# Execute only after reviewing the command and its scope.
+tsdisk cleanup --root /mnt/data/project --only=pnpm --apply --yes
 ```
 
+Cleanup defaults to a preview of `rust,docker` for the current project. `--dry-run` explicitly selects preview mode. Repeat `--root` to select multiple projects, and use `--only=rust,docker,pnpm` to choose categories. `pnpm` is opt-in because the configured store may be shared. Tsdisk never deletes a pnpm store directory.
+
+Rust requires `@git.zone/tsrust` 1.13.2 or later; Docker requires `@git.zone/tsdocker` 3.6.0 or later. Rust and Docker use their project-installed `node_modules/.bin/tsrust` and `tsdocker`; missing tools block the batch without downloading anything. Rust previews pass `--days 14` by default; `--days N` changes only Rust retention. Docker cleanup uses the owning tool’s identity, mount, and build checks; its abandoned-container scope can span projects in the current Docker context. Registry directories are project-local. Bundle, matrix, and legacy registry findings do not become execution targets.
+
+Rust rechecks retention, markers, cache identity, and active use at execution time. Active Rust tools or inaccessible process state (including protected same-user processes) block removal. Linux tsrust builds and pruning share a cache guard.
+
+All owner previews must succeed without truncated output before any execution. `--apply` prints the plan and asks for confirmation; noninteractive or JSON execution additionally requires `--yes`. Each apply invokes the owning tool again so its safety checks run at execution time. A failed command stops subsequent actions and returns a nonzero exit code; completed actions are not rolled back. Commands time out after 120 seconds for preview or 240 seconds for apply, with a five-second termination grace period. Review owning-tool state before retrying an interrupted operation.
+
+Cleanup runs as the project owner, without sudo, and refuses filesystem roots and symlink project paths. No plans or application state are persisted. This is a Linux CLI and uses `du`, `df`, `findmnt`, and GNU `timeout` from the host.
+
+## Library API
+
+`scanWorkspace(root, { maxDepth, maxEntries, timeoutMs, onProgress? })` returns findings, issues, issue counts, usage-priority paths, completion status, and the directory/symlink inspection count. `collectProjectToolCacheReport(context, roots?)` adds sizing. `collectDiskReport(context, roots?)` adds streaming workspace usage and host command diagnostics; `context.onProgress` receives live state updates. `measureDiskUsage(roots, { timeoutSeconds, trackedPaths?, priorityPaths?, onProgress? })` performs the standalone native usage pass. Priority paths only reorder descendants on the selected filesystem; they cannot expand scan scope. `estimateReclaimableSpace(findings)` returns the conservative candidate summary. The existing classification and byte-formatting exports remain available. `parseCliOptions(args)` and `createCleanupPlan(options)` expose validated CLI options and cleanup command plans; creating a plan does not execute cleanup.
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the repository license file.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsdisk',
-  version: '1.1.0',
+  version: '1.3.0',
   description: 'A disk usage diagnostic CLI for finding large files, caches, logs, and Docker storage.'
 }

package/ts/index.ts

@@ -1,8 +1,17 @@
 export { commitinfo } from './00_commitinfo_data.js';
 export {
   formatBytes,
+  collectDiskReport,
+  collectProjectToolCacheReport,
+  diagnosticCommandComplete,
   main,
   parseDuOutput,
   runCli,
 } from './tsdisk.cli.js';
 export * from './tsdisk.toolcaches.js';
+export * from './tsdisk.scan.js';
+export * from './tsdisk.cleanup.js';
+export * from './tsdisk.usage.js';
+export { DiskProgressReporter, estimateReclaimableSpace } from './tsdisk.progress.js';
+export type { IDiskProgress, IReclaimEstimate } from './tsdisk.progress.js';
+export type { IRuntimeContext, IDiagnosticSection } from './tsdisk.cli.js';

package/ts/tsdisk.cleanup.ts

@@ -0,0 +1,120 @@
+import * as plugins from './tsdisk.plugins.js';
+
+export type TCleanupCategory = 'rust' | 'docker' | 'pnpm';
+
+export interface ICleanupAction {
+  category: TCleanupCategory;
+  cwd: string;
+  command: string;
+  previewArgs?: string[];
+  applyArgs: string[];
+  scope: string;
+  blocked?: string;
+}
+
+export interface ICleanupPlan {
+  dryRun: boolean;
+  actions: ICleanupAction[];
+}
+
+export interface ICliOptions {
+  command: 'diagnose' | 'scan' | 'cleanup' | 'help' | 'version';
+  roots: string[];
+  categories: TCleanupCategory[];
+  json: boolean;
+  apply: boolean;
+  yes: boolean;
+  days: number;
+}
+
+export function parseCliOptions(args: string[]): ICliOptions {
+  const options: ICliOptions = { command: 'diagnose', roots: [], categories: ['rust', 'docker'], json: false, apply: false, yes: false, days: 14 };
+  let commandSeen = false;
+  let dryRun = false;
+  let cleanupOption = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === '--help' || arg === '-h') { options.command = 'help'; return options; }
+    if (arg === '--version' || arg === '-v') { options.command = 'version'; return options; }
+    if (arg === 'scan' || arg === 'cleanup') {
+      if (commandSeen) throw new Error('Specify one command: scan or cleanup.');
+      options.command = arg;
+      commandSeen = true;
+    } else if (arg === '--json') options.json = true;
+    else if (arg === '--apply') { options.apply = true; cleanupOption = true; }
+    else if (arg === '--yes' || arg === '-y') { options.yes = true; cleanupOption = true; }
+    else if (arg === '--dry-run' || arg === '-n') { dryRun = true; cleanupOption = true; }
+    else if (['--root', '--only', '--days'].some((flag) => arg === flag || arg.startsWith(`${flag}=`))) {
+      const separator = arg.indexOf('=');
+      const name = separator < 0 ? arg : arg.slice(0, separator);
+      const value = separator < 0 ? args[++index] : arg.slice(separator + 1);
+      if (!value || value.startsWith('--')) throw new Error(`Missing value for ${name}.`);
+      if (name === '--root') options.roots.push(plugins.path.resolve(value));
+      else if (name === '--only') {
+        cleanupOption = true;
+        const values = value.split(',');
+        if (values.some((category) => !['rust', 'docker', 'pnpm'].includes(category))) throw new Error('Cleanup categories: rust,docker,pnpm.');
+        options.categories = [...new Set(values)] as TCleanupCategory[];
+      } else {
+        cleanupOption = true;
+        options.days = Number(value);
+        if (!Number.isSafeInteger(options.days) || options.days < 1) throw new Error('--days must be a positive integer.');
+      }
+    } else throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (cleanupOption && options.command !== 'cleanup') throw new Error('Cleanup options require the cleanup command.');
+  if (dryRun && options.apply) throw new Error('--dry-run and --apply cannot be combined.');
+  if (options.yes && !options.apply) throw new Error('--yes requires --apply.');
+  if (options.command === 'diagnose' && (options.roots.length || options.json)) options.command = 'scan';
+  options.roots = [...new Set(options.roots)];
+  return options;
+}
+
+/** Build project-scoped owner commands. No discovered marker authorizes deletion. */
+export async function createCleanupPlan(options: ICliOptions): Promise<ICleanupPlan> {
+  if (options.command !== 'cleanup') throw new Error('Cleanup command required.');
+  if (!Number.isSafeInteger(options.days) || options.days < 1) throw new Error('Invalid retention period.');
+  if (!options.categories.length || options.categories.some((category) => !['rust', 'docker', 'pnpm'].includes(category))) throw new Error('Invalid cleanup category.');
+  const plan: ICleanupPlan = { dryRun: !options.apply, actions: [] };
+  for (const root of new Set(options.roots.length ? options.roots : [process.cwd()])) {
+    const cwd = plugins.path.resolve(root);
+    const stat = await plugins.fs.lstat(cwd);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || await plugins.fs.realpath(cwd) !== cwd || cwd === plugins.path.parse(cwd).root) {
+      throw new Error(`Cleanup requires a real project directory: ${cwd}`);
+    }
+    // Running project-installed tools as root would grant project code host-wide authority.
+    if (process.getuid?.() === 0) throw new Error('Run cleanup as the project owner, without sudo.');
+    if (process.getuid && stat.uid !== process.getuid()) throw new Error(`Cleanup root is not owned by the current user: ${cwd}`);
+    for (const category of new Set(options.categories)) {
+      if (category === 'pnpm') {
+        plan.actions.push({ category, cwd, command: 'pnpm', applyArgs: ['store', 'prune'], scope: 'Prune unreferenced packages from the pnpm store configured for this project. The store may be shared. pnpm provides no prune dry-run.' });
+        continue;
+      }
+      const binary = category === 'rust' ? 'tsrust' : 'tsdocker';
+      const command = plugins.path.join(cwd, 'node_modules', '.bin', binary);
+      const args = category === 'rust' ? ['prune', '--days', String(options.days)] : ['prune'];
+      const action: ICleanupAction = {
+        category, cwd, command, previewArgs: args, applyArgs: [...args, '--apply'],
+        scope: category === 'rust'
+          ? `Project's marked managed Rust targets; newest-file retention ${options.days} days, revalidated by tsrust.`
+          : 'Project registry caches and tsdocker-owned abandoned containers in the current Docker context; container scope may include other projects. tsdocker revalidates owner identity and active mounts.',
+      };
+      try {
+        await plugins.fs.access(command, plugins.constants.X_OK);
+        const packagePath = plugins.path.join(cwd, 'node_modules', '@git.zone', binary, 'package.json');
+        const manifest = JSON.parse(await plugins.fs.readFile(packagePath, 'utf8')) as { name?: string; version?: string };
+        if (manifest.name !== `@git.zone/${binary}`) throw new Error('Unexpected owning package.');
+        const version = /^(\d+)\.(\d+)\.(\d+)$/.exec(manifest.version ?? '')?.slice(1).map(Number);
+        const minimum = category === 'docker' ? [3, 6, 0] : [1, 13, 2];
+        const different = version?.findIndex((part, index) => part !== minimum[index]);
+        if (!version || (different !== undefined && different !== -1 && version[different] < minimum[different])) {
+          action.blocked = `@git.zone/${binary} ${minimum.join('.')} or later is required for the documented prune contract.`;
+        }
+      } catch {
+        action.blocked = `Install a current @git.zone/${binary} in this project before cleanup. No tool is downloaded automatically.`;
+      }
+      plan.actions.push(action);
+    }
+  }
+  return plan;
+}