@git.zone/tsdisk 1.2.1 → 1.4.0

package/dist_ts/tsdisk.progress.d.ts

@@ -0,0 +1,31 @@
+import { type IUsageEntry } from './tsdisk.usage.js';
+import type { IToolCacheFinding } from './tsdisk.toolcaches.js';
+export interface IReclaimEstimate {
+    candidateBytes: number;
+    unknownSizeCount: number;
+    protectedCount: number;
+    confirmedReclaimableBytes: null;
+    status: 'owner-review-required';
+}
+/** Do not sum parents and children, or treat a protected descendant as removable. */
+export declare function estimateReclaimableSpace(findings: IToolCacheFinding[]): IReclaimEstimate;
+export interface IDiskProgress {
+    stage: string;
+    cacheCount: number;
+    measuredBytes: number;
+    reclaim: IReclaimEstimate;
+    largest: IUsageEntry[];
+}
+export declare function formatBytes(bytes: number): string;
+/** Timer ownership is explicit; callers stop it in finally even on failure. */
+export declare class DiskProgressReporter {
+    private write;
+    private timer?;
+    private startedAt;
+    private state;
+    constructor(write: (line: string) => void);
+    update(update: Partial<IDiskProgress>): void;
+    start(): void;
+    private print;
+    stop(stage?: string): void;
+}

package/dist_ts/tsdisk.progress.js

@@ -0,0 +1,64 @@
+import { containsPath } from './tsdisk.usage.js';
+/** Do not sum parents and children, or treat a protected descendant as removable. */
+export function estimateReclaimableSpace(findings) {
+    const protectedPaths = findings.filter((finding) => finding.marker?.safeToPrune === false).map((finding) => finding.path);
+    const candidates = findings.filter((finding) => !protectedPaths.some((path) => containsPath(path, finding.path) || containsPath(finding.path, path)));
+    const selected = [];
+    for (const finding of [...candidates].sort((a, b) => a.path.length - b.path.length)) {
+        if (finding.bytes === undefined || selected.some((parent) => containsPath(parent.path, finding.path)))
+            continue;
+        selected.push(finding);
+    }
+    return {
+        candidateBytes: selected.reduce((sum, finding) => sum + (finding.bytes ?? 0), 0),
+        unknownSizeCount: candidates.filter((finding) => finding.bytes === undefined).length,
+        protectedCount: protectedPaths.length,
+        confirmedReclaimableBytes: null,
+        status: 'owner-review-required',
+    };
+}
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return 'n/a';
+    const units = ['B', 'KiB', 'MiB', 'GiB', 'TiB'];
+    let value = bytes;
+    let index = 0;
+    while (value >= 1024 && index < units.length - 1) {
+        value /= 1024;
+        index++;
+    }
+    return `${value.toFixed(index === 0 || value >= 100 ? 0 : value >= 10 ? 1 : 2)} ${units[index]}`;
+}
+/** Timer ownership is explicit; callers stop it in finally even on failure. */
+export class DiskProgressReporter {
+    write;
+    timer;
+    startedAt = Date.now();
+    state = { stage: 'starting', cacheCount: 0, measuredBytes: 0, reclaim: estimateReclaimableSpace([]), largest: [] };
+    constructor(write) {
+        this.write = write;
+    }
+    update(update) { Object.assign(this.state, update); }
+    start() {
+        if (this.timer)
+            return;
+        this.startedAt = Date.now();
+        this.print();
+        this.timer = setInterval(() => this.print(), 5000);
+        this.timer.unref();
+    }
+    print() {
+        const state = this.state;
+        const top = state.largest.slice(0, 3).map((entry) => `${formatBytes(entry.bytes)}${entry.complete ? '' : '+'} ${JSON.stringify(entry.path)}`).join('; ');
+        this.write(`[tsdisk ${Math.floor((Date.now() - this.startedAt) / 1000)}s] ${state.stage} | measured ${formatBytes(state.measuredBytes)} | ${state.cacheCount} caches | potential cleanup ${formatBytes(state.reclaim.candidateBytes)} (owner review; ${state.reclaim.unknownSizeCount} unsized) | confirmed reclaimable: unknown${top ? ` | largest: ${top}` : ''}`);
+    }
+    stop(stage = 'finished') {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.state.stage = stage;
+        this.print();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tsdisk.scan.d.ts

@@ -3,6 +3,7 @@ export interface IWorkspaceScanOptions {
     maxDepth: number;
     timeoutMs: number;
     maxEntries: number;
+    onProgress?: (result: IWorkspaceScanResult) => void;
 }
 export interface IScanIssue {
     path: string;
@@ -15,5 +16,7 @@ export interface IWorkspaceScanResult {
     issues: IScanIssue[];
     complete: boolean;
     visitedEntries: number;
+    issueCounts: Partial<Record<IScanIssue['reason'], number>>;
+    usagePriorityPaths: string[];
 }
 export declare function scanWorkspace(root: string, options: IWorkspaceScanOptions): Promise<IWorkspaceScanResult>;

package/dist_ts/tsdisk.scan.js

@@ -8,12 +8,14 @@ export async function scanWorkspace(root, options) {
             throw new Error(`Invalid scan option ${name}: ${value}`);
         }
     }
-    const result = { root: plugins.path.resolve(root), findings: [], issues: [], complete: true, visitedEntries: 0 };
+    const result = { root: plugins.path.resolve(root), findings: [], issues: [], issueCounts: {}, usagePriorityPaths: [], complete: true, visitedEntries: 0 };
     const deadline = Date.now() + options.timeoutMs;
     let stopped = false;
     const issue = (path, reason, detail) => {
         result.complete = false;
-        result.issues.push({ path, reason, detail });
+        result.issueCounts[reason] = (result.issueCounts[reason] ?? 0) + 1;
+        if (result.issues.length < 200)
+            result.issues.push({ path, reason, detail });
     };
     const limited = (path) => {
         if (stopped)
@@ -39,6 +41,8 @@ export async function scanWorkspace(root, options) {
         issue(result.root, 'read-error', error instanceof Error ? error.message : String(error));
         return result;
     }
+    const queue = [{ directory: result.root, depth: 0 }];
+    let queueLimited = false;
     const visit = async (directory, depth) => {
         if (limited(directory))
             return;
@@ -53,11 +57,16 @@ export async function scanWorkspace(root, options) {
                 issue(directory, 'mount-boundary', 'Different filesystem skipped.');
                 return;
             }
-            const entries = await plugins.fs.readdir(directory, { withFileTypes: true });
+            if (plugins.path.basename(directory) === '.nogit')
+                result.usagePriorityPaths.push(directory);
             let marker;
-            if (entries.some((entry) => entry.name === toolCacheMarkerFile)) {
-                const markerPath = plugins.path.join(directory, toolCacheMarkerFile);
-                const markerStat = await plugins.fs.lstat(markerPath);
+            const markerPath = plugins.path.join(directory, toolCacheMarkerFile);
+            const markerStat = await plugins.fs.lstat(markerPath).catch((error) => {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            });
+            if (markerStat) {
                 if (!markerStat.isFile() || markerStat.size > 65536) {
                     issue(markerPath, 'invalid-marker', 'Marker must be a regular file of at most 64 KiB.');
                 }
@@ -74,20 +83,25 @@ export async function scanWorkspace(root, options) {
             // Cache contents are not workspaces. Registry session directories can carry their own markers.
             if (classification && heuristic?.kind !== 'docker-registry-cache')
                 return;
-            const children = entries.filter((entry) => !excludedDirectories.has(entry.name));
-            if (depth >= options.maxDepth) {
-                if (children.some((entry) => entry.isDirectory() || entry.isSymbolicLink()))
+            let enumerated = 0;
+            const children = await plugins.fs.opendir(directory);
+            for await (const child of children) {
+                // A huge flat directory must not consume the budget of sibling projects.
+                if (++enumerated > 4096) {
+                    issue(directory, 'entry-limit', 'Directory listing stopped at 4096 entries; sibling directories are still scanned.');
+                    break;
+                }
+                if (excludedDirectories.has(child.name))
+                    continue;
+                if (!child.isDirectory() && !child.isSymbolicLink())
+                    continue;
+                if (depth >= options.maxDepth) {
                     issue(directory, 'depth-limit', `Maximum scan depth ${options.maxDepth} reached.`);
-                return;
-            }
-            for (const child of children) {
+                    break;
+                }
                 const childPath = plugins.path.join(directory, child.name);
                 if (limited(childPath))
                     return;
-                if (!child.isDirectory() && !child.isSymbolicLink()) {
-                    result.visitedEntries++;
-                    continue;
-                }
                 if (child.isSymbolicLink()) {
                     result.visitedEntries++;
                     issue(childPath, 'symlink', 'Symbolic link skipped.');
@@ -105,14 +119,29 @@ export async function scanWorkspace(root, options) {
                         continue;
                     }
                 }
-                await visit(childPath, depth + 1);
+                if (queue.length >= options.maxEntries) {
+                    if (!queueLimited)
+                        issue(directory, 'entry-limit', 'Directory queue budget exhausted; already queued siblings are still scanned.');
+                    queueLimited = true;
+                    continue;
+                }
+                queue.push({ directory: childPath, depth: depth + 1 });
             }
         }
         catch (error) {
             issue(directory, 'read-error', error instanceof Error ? error.message : String(error));
         }
     };
-    await visit(result.root, 0);
+    // Breadth first: canonical projects precede deeply nested retained worktrees.
+    let lastProgress = 0;
+    for (let index = 0; index < queue.length && !stopped; index++) {
+        await visit(queue[index].directory, queue[index].depth);
+        if (Date.now() - lastProgress >= 250) {
+            options.onProgress?.(result);
+            lastProgress = Date.now();
+        }
+    }
+    options.onProgress?.(result);
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tsdisk.scan.js","sourceRoot":"","sources":["../ts/tsdisk.scan.ts"],"names":[],"mappings":"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"}

package/dist_ts/tsdisk.usage.d.ts

@@ -0,0 +1,50 @@
+export interface IUsageEntry {
+    path: string;
+    bytes: number;
+    complete: boolean;
+}
+export interface IUsageReport {
+    roots: string[];
+    measuredBytes: number;
+    entries: IUsageEntry[];
+    records: number;
+    complete: boolean;
+    code: number;
+    stderr: string;
+}
+export declare function containsPath(parent: string, child: string): boolean;
+/** Preserve explicitly selected nested mounts; subsume overlapping roots on the same device. */
+export declare function normalizeScanRoots(roots: string[]): Promise<string[]>;
+/** 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 declare class UsageAccumulator {
+    private roots;
+    private trackedPaths;
+    private priorityPaths;
+    private pending;
+    private active;
+    private largest;
+    private tracked;
+    private minimumLargestBytes;
+    private operandBytes;
+    private accountingRoots;
+    private currentRoot?;
+    measuredBytes: number;
+    records: number;
+    currentPath: string;
+    constructor(roots: string[], trackedPaths?: Set<string>, priorityPaths?: string[]);
+    consume(chunk: string): void;
+    private record;
+    snapshot(): IUsageEntry[];
+    get endedOnRecordBoundary(): boolean;
+}
+export interface IUsageOptions {
+    timeoutSeconds: number;
+    trackedPaths?: string[];
+    priorityPaths?: string[];
+    onProgress?: (usage: UsageAccumulator) => void;
+}
+/** One streaming native pass; no output export, no symlink traversal, no raw file content reads. */
+export declare function measureDiskUsage(roots: string[], options: IUsageOptions): Promise<IUsageReport>;

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.2.1",
+  "version": "1.4.0",
   "private": false,
   "description": "A disk usage diagnostic CLI for finding large files, caches, logs, and Docker storage.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -24,7 +24,9 @@ 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.
+
+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.
 
@@ -66,11 +68,15 @@ tsdisk --version
 
 `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`, `sections`, and `complete`. Each command section records its command, arguments, exit code, stdout, stderr, and completeness. Missing tools and insufficient permissions remain visible. JSON output contains one document; diagnostics never print progress into it.
+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.
 
-Discovery is bounded to depth 8, 50,000 visited entries, and 45 seconds per root. Sizing has a 45-second budget and a 500-cache limit. Additional command diagnostics have a 120-second total budget, with at most 15 seconds per command. 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`.
+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
 
@@ -91,11 +97,26 @@ Rust rechecks retention, markers, cache identity, and active use at execution ti
 
 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.
+Cleanup runs as the project owner and refuses filesystem roots and symlink project paths.
+With project-local `@git.zone/tsdocker` 3.7.0 or later, Docker previews report whether
+cache permissions require sudo. After successful previews and cleanup confirmation,
+tsdisk invokes sudo's native password prompt in the terminal. The password never
+enters tsdisk, arguments, environment variables, JSON, or log files. The owning tool
+then elevates only approved cache file removal; project code and Docker commands
+continue as your user. Rust and pnpm cleanup are never elevated.
+
+Use `--no-sudo` to refuse elevated cleanup. Without a terminal, caches requiring sudo
+block the batch unless `--sudo` is explicit and sudo can authenticate without a prompt.
+`--yes` accepts the cleanup plan but does not supply or bypass sudo authentication.
+JSON stdout remains one document; sudo prompts and notices go to the terminal/stderr.
+Authentication failure or cancellation prevents all apply commands. Older Docker
+tools retain their ordinary cleanup behavior and must be upgraded for sudo support;
+tsdisk never reruns an old project binary as root. No plans or application state are
+persisted. This Linux CLI uses `du`, `df`, `findmnt`, and GNU `timeout` from the host.
 
 ## Library API
 
-`scanWorkspace(root, { maxDepth, maxEntries, timeoutMs })` returns findings, issues, completion status, and the visited-entry count. `collectProjectToolCacheReport(context, roots?)` adds sizing. `collectDiskReport(context, roots?)` adds host command diagnostics. 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.
+`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
 

package/ts/00_commitinfo_data.ts

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