@git.zone/tsrust 1.5.0 → 1.6.0

package/.smartconfig.json

@@ -1,5 +1,6 @@
 {
   "@git.zone/cli": {
+    "schemaVersion": 2,
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -20,12 +21,20 @@
     },
     "release": {
       "targets": {
+        "git": {
+          "enabled": true,
+          "remote": "origin",
+          "pushBranch": true,
+          "pushTags": true
+        },
         "npm": {
+          "enabled": true,
           "registries": [
             "https://verdaccio.lossless.digital",
             "https://registry.npmjs.org"
           ],
-          "accessLevel": "public"
+          "accessLevel": "public",
+          "alreadyPublished": "success"
         }
       }
     }

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tsrust',
-    version: '1.5.0',
+    version: '1.6.0',
     description: 'A tool for compiling Rust projects, detecting Cargo workspaces, building with cargo, and placing binaries in a conventional dist_rust directory.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtKQUFrSjtDQUNoSyxDQUFBIn0=

package/dist_ts/mod_cargo/classes.cargorunner.d.ts

@@ -16,11 +16,14 @@ export declare class CargoRunner {
         target?: string;
         crtStatic?: boolean;
         rustflags?: string[];
+        targetDir?: string;
     }): Promise<ICargoRunResult>;
     private shellQuote;
     /**
      * Ensures a rustup target is installed. If not present, installs it via `rustup target add`.
      */
     ensureTarget(triple: string): Promise<void>;
-    clean(): Promise<ICargoRunResult>;
+    clean(options?: {
+        targetDir?: string;
+    }): Promise<ICargoRunResult>;
 }

package/dist_ts/mod_cargo/classes.cargorunner.js

@@ -21,7 +21,7 @@ export class CargoRunner {
     async build(options = {}) {
         if (options.clean) {
             console.log('Cleaning previous build...');
-            await this.clean();
+            await this.clean({ targetDir: options.targetDir });
         }
         // crt-static may only be injected together with an explicit --target:
         // without one, cargo applies RUSTFLAGS to host artifacts too, and rustc
@@ -39,8 +39,9 @@ export class CargoRunner {
             rustflags.unshift('-C', 'target-feature=+crt-static');
         }
         const rustflagsPrefix = rustflags.length ? `RUSTFLAGS=${this.shellQuote(rustflags.join(' '))} ` : '';
-        const command = `${this.envPrefix}cd ${this.rustDir} && ${rustflagsPrefix}cargo build${profile}${targetFlag}`;
-        console.log(`Running: ${rustflagsPrefix}cargo build${profile}${targetFlag}`);
+        const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+        const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`;
+        console.log(`Running: ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`);
         const result = await this.shell.exec(command);
         return {
             success: result.exitCode === 0,
@@ -66,8 +67,9 @@ export class CargoRunner {
             throw new Error(`Failed to install rustup target ${triple}`);
         }
     }
-    async clean() {
-        const command = `${this.envPrefix}cd ${this.rustDir} && cargo clean`;
+    async clean(options = {}) {
+        const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+        const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}cargo clean`;
         const result = await this.shell.exec(command);
         return {
             success: result.exitCode === 0,
@@ -76,4 +78,4 @@ export class CargoRunner {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_cargo/classes.targetcache.d.ts

@@ -0,0 +1,37 @@
+export declare const toolCacheMarkerFile = ".gitzone-tool-cache.json";
+export declare const tsrustCacheOwner = "@git.zone/tsrust";
+export declare const targetCacheKind = "rust-target-cache";
+export interface IToolCacheMarker {
+    owner: string;
+    kind: string;
+    safeToPrune: boolean;
+    createdAt: string;
+    schemaVersion: 1;
+}
+export interface ITsrustPruneCandidate {
+    path: string;
+    workspace: string;
+    bytes: number;
+    marked: boolean;
+    shouldPrune: boolean;
+    reason: string;
+    truncated?: boolean;
+}
+export interface ITsrustPruneOptions {
+    workspace: string;
+    targetDir?: string;
+    days?: number;
+    maxSizeBytes?: number;
+}
+export declare function createTargetCacheMarker(): IToolCacheMarker;
+export declare function isValidTargetCacheMarker(markerArg: unknown): markerArg is IToolCacheMarker;
+export declare function getDefaultManagedTargetDir(workspaceArg: string): string;
+export declare function isSafeManagedTargetDir(workspaceArg: string, targetDirArg: string): boolean;
+export declare function resolveManagedTargetDir(workspaceArg: string, configTargetDirArg?: string): string;
+export declare function getCargoArtifactDir(targetDirArg: string, profileArg: string, targetTripleArg?: string): string;
+export declare function parseSizeToBytes(valueArg: string | undefined): number | undefined;
+export declare function writeTargetCacheMarker(targetDirArg: string): Promise<void>;
+export declare function readTargetCacheMarker(targetDirArg: string): Promise<IToolCacheMarker | undefined>;
+export declare function getDirectorySize(pathArg: string): Promise<number>;
+export declare function createTsrustPrunePlan(optionsArg: ITsrustPruneOptions): Promise<ITsrustPruneCandidate[]>;
+export declare function applyTsrustPrunePlan(planArg: ITsrustPruneCandidate[]): Promise<void>;

package/dist_ts/mod_cargo/classes.targetcache.js

@@ -0,0 +1,260 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export const toolCacheMarkerFile = '.gitzone-tool-cache.json';
+export const tsrustCacheOwner = '@git.zone/tsrust';
+export const targetCacheKind = 'rust-target-cache';
+export function createTargetCacheMarker() {
+    return {
+        owner: tsrustCacheOwner,
+        kind: targetCacheKind,
+        safeToPrune: true,
+        createdAt: new Date().toISOString(),
+        schemaVersion: 1,
+    };
+}
+export function isValidTargetCacheMarker(markerArg) {
+    const marker = markerArg;
+    return marker.owner === tsrustCacheOwner
+        && marker.kind === targetCacheKind
+        && marker.safeToPrune === true
+        && marker.schemaVersion === 1;
+}
+export function getDefaultManagedTargetDir(workspaceArg) {
+    return path.resolve(workspaceArg, '.nogit', 'tsrust-target');
+}
+export function isSafeManagedTargetDir(workspaceArg, targetDirArg) {
+    const workspace = path.resolve(workspaceArg);
+    const targetDir = path.resolve(targetDirArg);
+    const relative = path.relative(workspace, targetDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative === path.join('.nogit', 'tsrust-target')
+        || relative.startsWith(`${path.join('.nogit', 'tsrust-')}`)
+        || relative.startsWith(`${path.join('.nogit', 'tsrust')}${path.sep}`);
+}
+export function resolveManagedTargetDir(workspaceArg, configTargetDirArg) {
+    const configured = process.env.TSRUST_TARGET_DIR || configTargetDirArg;
+    const targetDir = configured
+        ? path.isAbsolute(configured) ? configured : path.resolve(workspaceArg, configured)
+        : getDefaultManagedTargetDir(workspaceArg);
+    if (!isSafeManagedTargetDir(workspaceArg, targetDir)) {
+        throw new Error(`Refusing unsafe tsrust target dir outside workspace .nogit/: ${targetDir}`);
+    }
+    return targetDir;
+}
+export function getCargoArtifactDir(targetDirArg, profileArg, targetTripleArg) {
+    return targetTripleArg
+        ? path.join(targetDirArg, targetTripleArg, profileArg)
+        : path.join(targetDirArg, profileArg);
+}
+export function parseSizeToBytes(valueArg) {
+    if (!valueArg) {
+        return undefined;
+    }
+    const match = valueArg.trim().match(/^(\d+(?:\.\d+)?)(b|kb|kib|mb|mib|gb|gib)?$/i);
+    if (!match) {
+        return undefined;
+    }
+    const value = Number(match[1]);
+    const unit = (match[2] || 'b').toLowerCase();
+    const multiplier = unit === 'gb' || unit === 'gib'
+        ? 1024 ** 3
+        : unit === 'mb' || unit === 'mib'
+            ? 1024 ** 2
+            : unit === 'kb' || unit === 'kib'
+                ? 1024
+                : 1;
+    return Math.round(value * multiplier);
+}
+export async function writeTargetCacheMarker(targetDirArg) {
+    await fs.mkdir(targetDirArg, { recursive: true });
+    const existingMarker = await readTargetCacheMarker(targetDirArg);
+    if (existingMarker) {
+        return;
+    }
+    const entries = await fs.readdir(targetDirArg);
+    if (entries.length > 0) {
+        throw new Error(`Refusing to mark pre-existing non-empty tsrust target cache: ${targetDirArg}`);
+    }
+    await fs.writeFile(path.join(targetDirArg, toolCacheMarkerFile), `${JSON.stringify(createTargetCacheMarker(), null, 2)}\n`);
+}
+export async function readTargetCacheMarker(targetDirArg) {
+    try {
+        const markerRaw = await fs.readFile(path.join(targetDirArg, toolCacheMarkerFile), 'utf8');
+        const marker = JSON.parse(markerRaw);
+        return isValidTargetCacheMarker(marker) ? marker : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function pathExists(pathArg) {
+    try {
+        await fs.stat(pathArg);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getDirectorySize(pathArg) {
+    let total = 0;
+    let entries;
+    try {
+        entries = await fs.readdir(pathArg, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(pathArg, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySize(entryPath);
+        }
+        else if (entry.isFile()) {
+            try {
+                total += (await fs.stat(entryPath)).size;
+            }
+            catch {
+                // Ignore files that disappear while planning a prune.
+            }
+        }
+    }
+    return total;
+}
+async function getDirectoryUsage(pathArg, maxEntriesArg = 100_000) {
+    let bytes = 0;
+    let newestMtimeMs = 0;
+    let visitedEntries = 0;
+    let truncated = false;
+    const visit = async (entryPathArg) => {
+        if (visitedEntries >= maxEntriesArg) {
+            truncated = true;
+            return;
+        }
+        visitedEntries++;
+        let stat;
+        try {
+            stat = await fs.stat(entryPathArg);
+        }
+        catch {
+            return;
+        }
+        newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
+        if (stat.isFile()) {
+            bytes += stat.size;
+            return;
+        }
+        if (!stat.isDirectory()) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(entryPathArg, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (visitedEntries >= maxEntriesArg) {
+                truncated = true;
+                return;
+            }
+            await visit(path.join(entryPathArg, entry.name));
+        }
+    };
+    await visit(pathArg);
+    return { bytes, newestMtimeMs, truncated };
+}
+async function getNewestMtimeMs(pathArg) {
+    let newest = 0;
+    try {
+        const stat = await fs.stat(pathArg);
+        newest = stat.mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(pathArg, { withFileTypes: true });
+    }
+    catch {
+        return newest;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(pathArg, entry.name);
+        if (entry.isDirectory()) {
+            newest = Math.max(newest, await getNewestMtimeMs(entryPath));
+        }
+        else if (entry.isFile()) {
+            try {
+                newest = Math.max(newest, (await fs.stat(entryPath)).mtimeMs);
+            }
+            catch {
+                // Ignore files that disappear while planning a prune.
+            }
+        }
+    }
+    return newest;
+}
+export async function createTsrustPrunePlan(optionsArg) {
+    const workspace = path.resolve(optionsArg.workspace);
+    const managedTargetDir = optionsArg.targetDir
+        ? resolveManagedTargetDir(workspace, optionsArg.targetDir)
+        : resolveManagedTargetDir(workspace);
+    const candidates = [
+        managedTargetDir,
+        path.join(workspace, 'rust', 'target'),
+        path.join(workspace, 'ts_rust', 'target'),
+    ];
+    const uniqueCandidates = [...new Set(candidates.map((candidate) => path.resolve(candidate)))];
+    const pruneCandidates = [];
+    const maxAgeMs = typeof optionsArg.days === 'number' ? optionsArg.days * 24 * 60 * 60 * 1000 : undefined;
+    for (const candidate of uniqueCandidates) {
+        if (!(await pathExists(candidate))) {
+            continue;
+        }
+        const marker = await readTargetCacheMarker(candidate);
+        const usage = await getDirectoryUsage(candidate);
+        const isManagedTarget = isSafeManagedTargetDir(workspace, candidate);
+        const ageMatches = typeof maxAgeMs === 'number' ? Date.now() - usage.newestMtimeMs >= maxAgeMs : false;
+        const bytes = usage.bytes;
+        const sizeMatches = typeof optionsArg.maxSizeBytes === 'number' ? bytes >= optionsArg.maxSizeBytes : false;
+        const shouldPrune = !!marker && isManagedTarget && (ageMatches || sizeMatches);
+        const reason = marker
+            ? !isManagedTarget
+                ? 'marked Rust target outside managed tsrust target allowlist; report-only'
+                : shouldPrune
+                    ? [ageMatches ? `older than ${optionsArg.days} day(s)` : '', sizeMatches ? `at least ${optionsArg.maxSizeBytes} bytes` : ''].filter(Boolean).join(', ')
+                    : 'marked tsrust target cache; below prune thresholds'
+            : 'unmarked conventional Rust target; report-only';
+        pruneCandidates.push({
+            path: candidate,
+            workspace,
+            bytes,
+            marked: !!marker,
+            shouldPrune,
+            reason,
+            truncated: usage.truncated,
+        });
+    }
+    return pruneCandidates;
+}
+export async function applyTsrustPrunePlan(planArg) {
+    for (const candidate of planArg) {
+        if (!candidate.shouldPrune) {
+            continue;
+        }
+        if (!isSafeManagedTargetDir(candidate.workspace, candidate.path)) {
+            throw new Error(`Refusing unsafe Rust target cache path: ${candidate.path}`);
+        }
+        const marker = await readTargetCacheMarker(candidate.path);
+        if (!marker) {
+            throw new Error(`Refusing to remove unmarked Rust target cache: ${candidate.path}`);
+        }
+        await fs.rm(candidate.path, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.targetcache.js","sourceRoot":"","sources":["../../ts/mod_cargo/classes.targetcache.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_cargo/index.d.ts

@@ -1,2 +1,3 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
+export * from './classes.targetcache.js';

package/dist_ts/mod_cargo/index.js

@@ -1,3 +1,4 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9tb2RfY2FyZ28vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyJ9
+export * from './classes.targetcache.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9tb2RfY2FyZ28vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxjQUFjLDBCQUEwQixDQUFDIn0=

package/dist_ts/mod_cli/classes.tsrustcli.d.ts

@@ -11,8 +11,10 @@ export declare class TsRustCli {
      */
     private resolveToolchain;
     private registerStandardCommand;
+    private shouldPruneAfterBuild;
     private buildRustflags;
     private registerCleanCommand;
+    private registerPruneCommand;
     private detectRustDir;
     run(): void;
 }

package/dist_ts/mod_cli/classes.tsrustcli.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as plugins from '../plugins.js';
 import { CargoConfig } from '../mod_cargo/index.js';
 import { CargoRunner } from '../mod_cargo/index.js';
+import { applyTsrustPrunePlan, createTsrustPrunePlan, getCargoArtifactDir, parseSizeToBytes, resolveManagedTargetDir, writeTargetCacheMarker, } from '../mod_cargo/index.js';
 import { ElfInspector } from '../mod_elf/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
@@ -59,6 +60,7 @@ export class TsRustCli {
     registerCommands() {
         this.registerStandardCommand();
         this.registerCleanCommand();
+        this.registerPruneCommand();
     }
     /**
      * Resolves the Rust toolchain to use. Tries system cargo first,
@@ -107,6 +109,8 @@ export class TsRustCli {
             const shouldClean = !!argvArg.clean;
             const distDir = path.join(this.cwd, 'dist_rust');
             const profile = isDebug ? 'debug' : 'release';
+            const managedTargetDir = resolveManagedTargetDir(this.cwd, this.config.targetDir);
+            await writeTargetCacheMarker(managedTargetDir);
             // Parse --target flag (can appear multiple times), fall back to smartconfig.json config
             const cliTargets = argvArg.target;
             const targets = cliTargets
@@ -140,13 +144,13 @@ export class TsRustCli {
                         target: triple,
                         crtStatic: useStatic && wantsCrtStatic(triple),
                         rustflags,
+                        targetDir: managedTargetDir,
                     });
                     if (!buildResult.success) {
                         console.error(`Build failed for target ${triple} with exit code ${buildResult.exitCode}`);
                         process.exit(1);
                     }
-                    // Cross-compiled binaries go to target/<triple>/<profile>/
-                    const targetDir = path.join(rustDir, 'target', triple, profile);
+                    const targetDir = getCargoArtifactDir(managedTargetDir, profile, triple);
                     for (const binName of workspaceInfo.binTargets) {
                         const srcBinary = path.join(targetDir, binName);
                         const destName = `${binName}_${friendly}`;
@@ -191,14 +195,13 @@ export class TsRustCli {
                     target: nativeTriple,
                     crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
                     rustflags,
+                    targetDir: managedTargetDir,
                 });
                 if (!buildResult.success) {
                     console.error(`Build failed with exit code ${buildResult.exitCode}`);
                     process.exit(1);
                 }
-                const targetDir = nativeTriple
-                    ? path.join(rustDir, 'target', nativeTriple, profile)
-                    : path.join(rustDir, 'target', profile);
+                const targetDir = getCargoArtifactDir(managedTargetDir, profile, nativeTriple);
                 await FsHelpers.ensureEmptyDir(distDir);
                 for (const binName of workspaceInfo.binTargets) {
                     const srcBinary = path.join(targetDir, binName);
@@ -220,10 +223,23 @@ export class TsRustCli {
                     }
                 }
             }
+            if (this.shouldPruneAfterBuild()) {
+                const plan = await createTsrustPrunePlan({
+                    workspace: this.cwd,
+                    targetDir: managedTargetDir,
+                    days: 0,
+                });
+                await applyTsrustPrunePlan(plan);
+                console.log('Pruned marked tsrust target cache after successful build.');
+            }
             const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
             console.log(`\nDone in ${elapsed}s`);
         });
     }
+    shouldPruneAfterBuild() {
+        const normalized = process.env.TSRUST_PRUNE_AFTER_BUILD?.toLowerCase();
+        return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'y' || this.config.pruneAfterBuild === true;
+    }
     buildRustflags(rustDir) {
         const rustflags = [...(this.config.rustflags || [])];
         if (this.config.remapLocalPaths) {
@@ -248,7 +264,7 @@ export class TsRustCli {
                 const envPrefix = await this.resolveToolchain();
                 console.log('Running cargo clean...');
                 const runner = new CargoRunner(rustDir, envPrefix);
-                await runner.clean();
+                await runner.clean({ targetDir: resolveManagedTargetDir(this.cwd, this.config.targetDir) });
                 console.log('Cargo clean complete.');
             }
             // Remove dist_rust/
@@ -260,6 +276,35 @@ export class TsRustCli {
             console.log('Clean complete.');
         });
     }
+    registerPruneCommand() {
+        this.cli.addCommand('prune').subscribe(async (argvArg) => {
+            const workspace = argvArg.workspace || this.cwd;
+            const daysArg = argvArg.days;
+            const days = daysArg === undefined ? 14 : Number(daysArg);
+            const maxSizeBytes = parseSizeToBytes(argvArg.maxSize);
+            const apply = !!argvArg.apply;
+            const plan = await createTsrustPrunePlan({
+                workspace,
+                targetDir: resolveManagedTargetDir(workspace, this.config.targetDir),
+                days: Number.isFinite(days) ? days : 14,
+                maxSizeBytes,
+            });
+            console.log(apply ? 'tsrust prune apply plan:' : 'tsrust prune dry-run plan:');
+            if (plan.length === 0) {
+                console.log('No Rust target caches found.');
+            }
+            for (const candidate of plan) {
+                const action = candidate.shouldPrune ? (apply ? 'remove' : 'would remove') : 'report';
+                console.log(`${action}: ${candidate.path} (${FsHelpers.formatFileSize(candidate.bytes)}) - ${candidate.reason}`);
+            }
+            if (apply) {
+                await applyTsrustPrunePlan(plan);
+            }
+            else {
+                console.log('Dry-run only. Re-run with --apply to remove marked tsrust target caches.');
+            }
+        });
+    }
     async detectRustDir() {
         // Check rust/ first
         const rustDir = path.join(this.cwd, 'rust');
@@ -281,4 +326,4 @@ export const runCli = async () => {
     const cli = new TsRustCli();
     cli.run();
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tsrustcli.js","sourceRoot":"","sources":["../../ts/mod_cli/classes.tsrustcli.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tsrustcli.js","sourceRoot":"","sources":["../../ts/mod_cli/classes.tsrustcli.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsrust",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "private": false,
   "description": "A tool for compiling Rust projects, detecting Cargo workspaces, building with cargo, and placing binaries in a conventional dist_rust directory.",
   "main": "dist_ts/index.js",
@@ -41,7 +41,7 @@
     "@git.zone/tsbuild": "^4.4.2",
     "@git.zone/tsrun": "^2.0.4",
     "@git.zone/tstest": "^3.6.6",
-    "@types/node": "^25.9.2"
+    "@types/node": "^25.9.3"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -1,6 +1,6 @@
 # @git.zone/tsrust
 
-A CLI build tool for Rust projects that follows the same conventions as `@git.zone/tsbuild`. It detects your `rust/` source directory, parses `Cargo.toml` (including workspaces), runs `cargo build --release`, and copies the resulting binaries into a clean `dist_rust/` directory at the project root.
+A CLI build tool for Rust projects that follows the same conventions as `@git.zone/tsbuild`. It detects your `rust/` source directory, parses `Cargo.toml` (including workspaces), runs `cargo build --release` with a managed target cache, and copies the resulting binaries into a clean `dist_rust/` directory at the project root.
 
 ## Issue Reporting and Security
 
@@ -48,8 +48,9 @@ This will:
 2. Locate your `rust/` directory (containing `Cargo.toml`)
 3. Parse the workspace to discover all `[[bin]]` targets
 4. Run `cargo build --release` with full streaming output
-5. Copy each binary to `dist_rust/` with executable permissions (`chmod 755`)
-6. Report file sizes and total build time
+5. Store Cargo intermediates in `.nogit/tsrust-target` by default
+6. Copy each binary to `dist_rust/` with executable permissions (`chmod 755`)
+7. Report file sizes and total build time
 
 **Example output:**
 
@@ -58,7 +59,7 @@ Using cargo 1.90.0 (840b83a10 2025-07-30)
 Found Rust project at: rust
 Detected Cargo workspace
 Binary targets: rustproxy
-Running: cargo build --release
+Running: CARGO_TARGET_DIR="/path/to/project/.nogit/tsrust-target" cargo build --release
    Compiling rustproxy v0.1.0
     Finished `release` profile [optimized] target(s) in 29.01s
 Copied rustproxy (13.4 MB) -> dist_rust/rustproxy
@@ -85,7 +86,7 @@ Build with the debug profile instead of release:
 tsrust --debug
 ```
 
-Binaries are taken from `rust/target/debug/` instead of `rust/target/release/`.
+Binaries are taken from `.nogit/tsrust-target/debug/` instead of `.nogit/tsrust-target/release/`.
 
 ### 🧹 Clean Before Building
 
@@ -138,13 +139,17 @@ You can set default cross-compilation targets in your project's `.smartconfig.js
 ```json
 {
   "@git.zone/tsrust": {
-    "targets": ["linux_arm64", "linux_amd64"]
+    "targets": ["linux_arm64", "linux_amd64"],
+    "targetDir": ".nogit/tsrust-target",
+    "pruneAfterBuild": false
   }
 }
 ```
 
 When targets are configured in `.smartconfig.json`, simply running `tsrust` will cross-compile for all listed targets. CLI `--target` flags take full precedence — if any `--target` is provided, the `.smartconfig.json` targets are ignored entirely.
 
+`targetDir` is optional. It must point to a tsrust-owned path under `.nogit/`, such as `.nogit/tsrust-target` or `.nogit/tsrust-custom-target`. You can also set `TSRUST_TARGET_DIR` for one-off runs. `pruneAfterBuild: true` or `TSRUST_PRUNE_AFTER_BUILD=true` removes the marked managed target cache after binaries have been copied to `dist_rust/`.
+
 ### Static Linking
 
 `tsrust` can produce fully statically linked Linux binaries (static-pie) that run on both glibc distros (Debian/Ubuntu) and musl distros (Alpine). Enable it via `.smartconfig.json`:
@@ -211,6 +216,29 @@ tsrust clean
 
 This runs `cargo clean` in the Rust directory and deletes the `dist_rust/` output directory.
 
+### 🧹 Prune Rust Target Caches
+
+Report Rust target caches without deleting anything:
+
+```bash
+tsrust prune
+```
+
+Apply cleanup to marked tsrust-managed target caches:
+
+```bash
+tsrust prune --apply --days 14 --max-size 5GiB
+```
+
+| Option | Description |
+| --- | --- |
+| `--apply` | Remove marked managed target caches that match the filters |
+| `--days <n>` | Prune marked caches whose newest file is at least `n` days old; default `14` |
+| `--max-size <size>` | Prune marked caches at or above a size such as `5GiB` |
+| `--workspace <path>` | Inspect another workspace path |
+
+Conventional `rust/target` and `ts_rust/target` directories are report-only, even if they carry a marker. Only managed `.nogit/tsrust*` target directories are eligible for `--apply`; arbitrary app data is never marked or removed.
+
 ## Project Structure
 
 `tsrust` expects your project to follow this layout:
@@ -230,6 +258,8 @@ my-project/
 │           └── src/
 ├── dist_rust/              # 📦 Output: compiled binaries go here
 │   └── my-binary
+├── .nogit/
+│   └── tsrust-target/      # 🧹 Managed Cargo target cache
 ├── ts/                     #    (your TypeScript code, built by tsbuild)
 ├── dist_ts/                #    (TypeScript output)
 └── package.json
@@ -253,7 +283,7 @@ If no `rust/` directory is found, `tsrust` checks for `ts_rust/` as a fallback.
 `tsrust` exports its internals for use in other Node.js/TypeScript tools:
 
 ```typescript
-import { CargoConfig, CargoRunner, FsHelpers, TsRustCli } from '@git.zone/tsrust';
+import { CargoConfig, CargoRunner, FsHelpers, TsRustCli, resolveManagedTargetDir } from '@git.zone/tsrust';
 
 // Parse a Cargo workspace
 const config = new CargoConfig('/path/to/rust');
@@ -263,7 +293,8 @@ console.log(info.binTargets);    // ['rustproxy']
 
 // Run cargo build
 const runner = new CargoRunner('/path/to/rust');
-const result = await runner.build({ debug: false, clean: false });
+const targetDir = resolveManagedTargetDir('/path/to/project');
+const result = await runner.build({ debug: false, clean: false, targetDir });
 console.log(result.success);     // true
 console.log(result.exitCode);    // 0
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsrust',
-  version: '1.5.0',
+  version: '1.6.0',
   description: 'A tool for compiling Rust projects, detecting Cargo workspaces, building with cargo, and placing binaries in a conventional dist_rust directory.'
 }

package/ts/mod_cargo/classes.cargorunner.ts

@@ -29,10 +29,10 @@ export class CargoRunner {
     return result.stdout.trim();
   }
 
-  public async build(options: { debug?: boolean; clean?: boolean; target?: string; crtStatic?: boolean; rustflags?: string[] } = {}): Promise<ICargoRunResult> {
+  public async build(options: { debug?: boolean; clean?: boolean; target?: string; crtStatic?: boolean; rustflags?: string[]; targetDir?: string } = {}): Promise<ICargoRunResult> {
     if (options.clean) {
       console.log('Cleaning previous build...');
-      await this.clean();
+      await this.clean({ targetDir: options.targetDir });
     }
 
     // crt-static may only be injected together with an explicit --target:
@@ -53,9 +53,10 @@ export class CargoRunner {
       rustflags.unshift('-C', 'target-feature=+crt-static');
     }
     const rustflagsPrefix = rustflags.length ? `RUSTFLAGS=${this.shellQuote(rustflags.join(' '))} ` : '';
-    const command = `${this.envPrefix}cd ${this.rustDir} && ${rustflagsPrefix}cargo build${profile}${targetFlag}`;
+    const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+    const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`;
 
-    console.log(`Running: ${rustflagsPrefix}cargo build${profile}${targetFlag}`);
+    console.log(`Running: ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`);
     const result = await this.shell.exec(command);
 
     return {
@@ -85,8 +86,9 @@ export class CargoRunner {
     }
   }
 
-  public async clean(): Promise<ICargoRunResult> {
-    const command = `${this.envPrefix}cd ${this.rustDir} && cargo clean`;
+  public async clean(options: { targetDir?: string } = {}): Promise<ICargoRunResult> {
+    const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+    const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}cargo clean`;
     const result = await this.shell.exec(command);
 
     return {

package/ts/mod_cargo/classes.targetcache.ts

@@ -0,0 +1,304 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export const toolCacheMarkerFile = '.gitzone-tool-cache.json';
+export const tsrustCacheOwner = '@git.zone/tsrust';
+export const targetCacheKind = 'rust-target-cache';
+
+export interface IToolCacheMarker {
+  owner: string;
+  kind: string;
+  safeToPrune: boolean;
+  createdAt: string;
+  schemaVersion: 1;
+}
+
+export interface ITsrustPruneCandidate {
+  path: string;
+  workspace: string;
+  bytes: number;
+  marked: boolean;
+  shouldPrune: boolean;
+  reason: string;
+  truncated?: boolean;
+}
+
+export interface ITsrustPruneOptions {
+  workspace: string;
+  targetDir?: string;
+  days?: number;
+  maxSizeBytes?: number;
+}
+
+export function createTargetCacheMarker(): IToolCacheMarker {
+  return {
+    owner: tsrustCacheOwner,
+    kind: targetCacheKind,
+    safeToPrune: true,
+    createdAt: new Date().toISOString(),
+    schemaVersion: 1,
+  };
+}
+
+export function isValidTargetCacheMarker(markerArg: unknown): markerArg is IToolCacheMarker {
+  const marker = markerArg as Partial<IToolCacheMarker>;
+  return marker.owner === tsrustCacheOwner
+    && marker.kind === targetCacheKind
+    && marker.safeToPrune === true
+    && marker.schemaVersion === 1;
+}
+
+export function getDefaultManagedTargetDir(workspaceArg: string): string {
+  return path.resolve(workspaceArg, '.nogit', 'tsrust-target');
+}
+
+export function isSafeManagedTargetDir(workspaceArg: string, targetDirArg: string): boolean {
+  const workspace = path.resolve(workspaceArg);
+  const targetDir = path.resolve(targetDirArg);
+  const relative = path.relative(workspace, targetDir);
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+    return false;
+  }
+  return relative === path.join('.nogit', 'tsrust-target')
+    || relative.startsWith(`${path.join('.nogit', 'tsrust-')}`)
+    || relative.startsWith(`${path.join('.nogit', 'tsrust')}${path.sep}`);
+}
+
+export function resolveManagedTargetDir(workspaceArg: string, configTargetDirArg?: string): string {
+  const configured = process.env.TSRUST_TARGET_DIR || configTargetDirArg;
+  const targetDir = configured
+    ? path.isAbsolute(configured) ? configured : path.resolve(workspaceArg, configured)
+    : getDefaultManagedTargetDir(workspaceArg);
+  if (!isSafeManagedTargetDir(workspaceArg, targetDir)) {
+    throw new Error(`Refusing unsafe tsrust target dir outside workspace .nogit/: ${targetDir}`);
+  }
+  return targetDir;
+}
+
+export function getCargoArtifactDir(targetDirArg: string, profileArg: string, targetTripleArg?: string): string {
+  return targetTripleArg
+    ? path.join(targetDirArg, targetTripleArg, profileArg)
+    : path.join(targetDirArg, profileArg);
+}
+
+export function parseSizeToBytes(valueArg: string | undefined): number | undefined {
+  if (!valueArg) {
+    return undefined;
+  }
+  const match = valueArg.trim().match(/^(\d+(?:\.\d+)?)(b|kb|kib|mb|mib|gb|gib)?$/i);
+  if (!match) {
+    return undefined;
+  }
+  const value = Number(match[1]);
+  const unit = (match[2] || 'b').toLowerCase();
+  const multiplier = unit === 'gb' || unit === 'gib'
+    ? 1024 ** 3
+    : unit === 'mb' || unit === 'mib'
+      ? 1024 ** 2
+      : unit === 'kb' || unit === 'kib'
+        ? 1024
+        : 1;
+  return Math.round(value * multiplier);
+}
+
+export async function writeTargetCacheMarker(targetDirArg: string): Promise<void> {
+  await fs.mkdir(targetDirArg, { recursive: true });
+  const existingMarker = await readTargetCacheMarker(targetDirArg);
+  if (existingMarker) {
+    return;
+  }
+  const entries = await fs.readdir(targetDirArg);
+  if (entries.length > 0) {
+    throw new Error(`Refusing to mark pre-existing non-empty tsrust target cache: ${targetDirArg}`);
+  }
+  await fs.writeFile(
+    path.join(targetDirArg, toolCacheMarkerFile),
+    `${JSON.stringify(createTargetCacheMarker(), null, 2)}\n`,
+  );
+}
+
+export async function readTargetCacheMarker(targetDirArg: string): Promise<IToolCacheMarker | undefined> {
+  try {
+    const markerRaw = await fs.readFile(path.join(targetDirArg, toolCacheMarkerFile), 'utf8');
+    const marker = JSON.parse(markerRaw);
+    return isValidTargetCacheMarker(marker) ? marker : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function pathExists(pathArg: string): Promise<boolean> {
+  try {
+    await fs.stat(pathArg);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getDirectorySize(pathArg: string): Promise<number> {
+  let total = 0;
+  let entries;
+  try {
+    entries = await fs.readdir(pathArg, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(pathArg, entry.name);
+    if (entry.isDirectory()) {
+      total += await getDirectorySize(entryPath);
+    } else if (entry.isFile()) {
+      try {
+        total += (await fs.stat(entryPath)).size;
+      } catch {
+        // Ignore files that disappear while planning a prune.
+      }
+    }
+  }
+
+  return total;
+}
+
+async function getDirectoryUsage(pathArg: string, maxEntriesArg = 100_000): Promise<{ bytes: number; newestMtimeMs: number; truncated: boolean }> {
+  let bytes = 0;
+  let newestMtimeMs = 0;
+  let visitedEntries = 0;
+  let truncated = false;
+
+  const visit = async (entryPathArg: string): Promise<void> => {
+    if (visitedEntries >= maxEntriesArg) {
+      truncated = true;
+      return;
+    }
+    visitedEntries++;
+
+    let stat;
+    try {
+      stat = await fs.stat(entryPathArg);
+    } catch {
+      return;
+    }
+    newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
+    if (stat.isFile()) {
+      bytes += stat.size;
+      return;
+    }
+    if (!stat.isDirectory()) {
+      return;
+    }
+
+    let entries;
+    try {
+      entries = await fs.readdir(entryPathArg, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visitedEntries >= maxEntriesArg) {
+        truncated = true;
+        return;
+      }
+      await visit(path.join(entryPathArg, entry.name));
+    }
+  };
+
+  await visit(pathArg);
+  return { bytes, newestMtimeMs, truncated };
+}
+
+async function getNewestMtimeMs(pathArg: string): Promise<number> {
+  let newest = 0;
+  try {
+    const stat = await fs.stat(pathArg);
+    newest = stat.mtimeMs;
+  } catch {
+    return 0;
+  }
+
+  let entries;
+  try {
+    entries = await fs.readdir(pathArg, { withFileTypes: true });
+  } catch {
+    return newest;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(pathArg, entry.name);
+    if (entry.isDirectory()) {
+      newest = Math.max(newest, await getNewestMtimeMs(entryPath));
+    } else if (entry.isFile()) {
+      try {
+        newest = Math.max(newest, (await fs.stat(entryPath)).mtimeMs);
+      } catch {
+        // Ignore files that disappear while planning a prune.
+      }
+    }
+  }
+
+  return newest;
+}
+
+export async function createTsrustPrunePlan(optionsArg: ITsrustPruneOptions): Promise<ITsrustPruneCandidate[]> {
+  const workspace = path.resolve(optionsArg.workspace);
+  const managedTargetDir = optionsArg.targetDir
+    ? resolveManagedTargetDir(workspace, optionsArg.targetDir)
+    : resolveManagedTargetDir(workspace);
+  const candidates = [
+    managedTargetDir,
+    path.join(workspace, 'rust', 'target'),
+    path.join(workspace, 'ts_rust', 'target'),
+  ];
+  const uniqueCandidates = [...new Set(candidates.map((candidate) => path.resolve(candidate)))];
+  const pruneCandidates: ITsrustPruneCandidate[] = [];
+  const maxAgeMs = typeof optionsArg.days === 'number' ? optionsArg.days * 24 * 60 * 60 * 1000 : undefined;
+
+  for (const candidate of uniqueCandidates) {
+    if (!(await pathExists(candidate))) {
+      continue;
+    }
+    const marker = await readTargetCacheMarker(candidate);
+    const usage = await getDirectoryUsage(candidate);
+    const isManagedTarget = isSafeManagedTargetDir(workspace, candidate);
+    const ageMatches = typeof maxAgeMs === 'number' ? Date.now() - usage.newestMtimeMs >= maxAgeMs : false;
+    const bytes = usage.bytes;
+    const sizeMatches = typeof optionsArg.maxSizeBytes === 'number' ? bytes >= optionsArg.maxSizeBytes : false;
+    const shouldPrune = !!marker && isManagedTarget && (ageMatches || sizeMatches);
+    const reason = marker
+      ? !isManagedTarget
+        ? 'marked Rust target outside managed tsrust target allowlist; report-only'
+        : shouldPrune
+        ? [ageMatches ? `older than ${optionsArg.days} day(s)` : '', sizeMatches ? `at least ${optionsArg.maxSizeBytes} bytes` : ''].filter(Boolean).join(', ')
+        : 'marked tsrust target cache; below prune thresholds'
+      : 'unmarked conventional Rust target; report-only';
+
+    pruneCandidates.push({
+      path: candidate,
+      workspace,
+      bytes,
+      marked: !!marker,
+      shouldPrune,
+      reason,
+      truncated: usage.truncated,
+    });
+  }
+
+  return pruneCandidates;
+}
+
+export async function applyTsrustPrunePlan(planArg: ITsrustPruneCandidate[]): Promise<void> {
+  for (const candidate of planArg) {
+    if (!candidate.shouldPrune) {
+      continue;
+    }
+    if (!isSafeManagedTargetDir(candidate.workspace, candidate.path)) {
+      throw new Error(`Refusing unsafe Rust target cache path: ${candidate.path}`);
+    }
+    const marker = await readTargetCacheMarker(candidate.path);
+    if (!marker) {
+      throw new Error(`Refusing to remove unmarked Rust target cache: ${candidate.path}`);
+    }
+    await fs.rm(candidate.path, { recursive: true, force: true });
+  }
+}

package/ts/mod_cargo/index.ts

@@ -1,2 +1,3 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
+export * from './classes.targetcache.js';

package/ts/mod_cli/classes.tsrustcli.ts

@@ -3,6 +3,14 @@ import * as os from 'os';
 import * as plugins from '../plugins.js';
 import { CargoConfig } from '../mod_cargo/index.js';
 import { CargoRunner } from '../mod_cargo/index.js';
+import {
+  applyTsrustPrunePlan,
+  createTsrustPrunePlan,
+  getCargoArtifactDir,
+  parseSizeToBytes,
+  resolveManagedTargetDir,
+  writeTargetCacheMarker,
+} from '../mod_cargo/index.js';
 import { ElfInspector } from '../mod_elf/index.js';
 import { FsHelpers } from '../mod_fs/index.js';
 import { ToolchainManager } from '../mod_toolchain/index.js';
@@ -48,6 +56,8 @@ interface ITsrustConfig {
   static?: boolean;
   rustflags?: string[];
   remapLocalPaths?: boolean;
+  targetDir?: string;
+  pruneAfterBuild?: boolean;
 }
 
 /** crt-static injection only applies to glibc targets; musl is static by default. */
@@ -75,6 +85,7 @@ export class TsRustCli {
   private registerCommands(): void {
     this.registerStandardCommand();
     this.registerCleanCommand();
+    this.registerPruneCommand();
   }
 
   /**
@@ -135,6 +146,8 @@ export class TsRustCli {
       const shouldClean = !!(argvArg as any).clean;
       const distDir = path.join(this.cwd, 'dist_rust');
       const profile = isDebug ? 'debug' : 'release';
+      const managedTargetDir = resolveManagedTargetDir(this.cwd, this.config.targetDir);
+      await writeTargetCacheMarker(managedTargetDir);
 
       // Parse --target flag (can appear multiple times), fall back to smartconfig.json config
       const cliTargets = (argvArg as any).target;
@@ -175,6 +188,7 @@ export class TsRustCli {
             target: triple,
             crtStatic: useStatic && wantsCrtStatic(triple),
             rustflags,
+            targetDir: managedTargetDir,
           });
 
           if (!buildResult.success) {
@@ -182,8 +196,7 @@ export class TsRustCli {
             process.exit(1);
           }
 
-          // Cross-compiled binaries go to target/<triple>/<profile>/
-          const targetDir = path.join(rustDir, 'target', triple, profile);
+          const targetDir = getCargoArtifactDir(managedTargetDir, profile, triple);
 
           for (const binName of workspaceInfo.binTargets) {
             const srcBinary = path.join(targetDir, binName);
@@ -234,6 +247,7 @@ export class TsRustCli {
           target: nativeTriple,
           crtStatic: !!nativeTriple && wantsCrtStatic(nativeTriple),
           rustflags,
+          targetDir: managedTargetDir,
         });
 
         if (!buildResult.success) {
@@ -241,9 +255,7 @@ export class TsRustCli {
           process.exit(1);
         }
 
-        const targetDir = nativeTriple
-          ? path.join(rustDir, 'target', nativeTriple, profile)
-          : path.join(rustDir, 'target', profile);
+        const targetDir = getCargoArtifactDir(managedTargetDir, profile, nativeTriple);
 
         await FsHelpers.ensureEmptyDir(distDir);
 
@@ -272,11 +284,26 @@ export class TsRustCli {
         }
       }
 
+      if (this.shouldPruneAfterBuild()) {
+        const plan = await createTsrustPrunePlan({
+          workspace: this.cwd,
+          targetDir: managedTargetDir,
+          days: 0,
+        });
+        await applyTsrustPrunePlan(plan);
+        console.log('Pruned marked tsrust target cache after successful build.');
+      }
+
       const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
       console.log(`\nDone in ${elapsed}s`);
     });
   }
 
+  private shouldPruneAfterBuild(): boolean {
+    const normalized = process.env.TSRUST_PRUNE_AFTER_BUILD?.toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'y' || this.config.pruneAfterBuild === true;
+  }
+
   private buildRustflags(rustDir: string): string[] {
     const rustflags = [...(this.config.rustflags || [])];
     if (this.config.remapLocalPaths) {
@@ -303,7 +330,7 @@ export class TsRustCli {
         const envPrefix = await this.resolveToolchain();
         console.log('Running cargo clean...');
         const runner = new CargoRunner(rustDir, envPrefix);
-        await runner.clean();
+        await runner.clean({ targetDir: resolveManagedTargetDir(this.cwd, this.config.targetDir) });
         console.log('Cargo clean complete.');
       }
 
@@ -318,6 +345,36 @@ export class TsRustCli {
     });
   }
 
+  private registerPruneCommand(): void {
+    this.cli.addCommand('prune').subscribe(async (argvArg) => {
+      const workspace = ((argvArg as any).workspace as string | undefined) || this.cwd;
+      const daysArg = (argvArg as any).days;
+      const days = daysArg === undefined ? 14 : Number(daysArg);
+      const maxSizeBytes = parseSizeToBytes((argvArg as any).maxSize as string | undefined);
+      const apply = !!(argvArg as any).apply;
+      const plan = await createTsrustPrunePlan({
+        workspace,
+        targetDir: resolveManagedTargetDir(workspace, this.config.targetDir),
+        days: Number.isFinite(days) ? days : 14,
+        maxSizeBytes,
+      });
+
+      console.log(apply ? 'tsrust prune apply plan:' : 'tsrust prune dry-run plan:');
+      if (plan.length === 0) {
+        console.log('No Rust target caches found.');
+      }
+      for (const candidate of plan) {
+        const action = candidate.shouldPrune ? (apply ? 'remove' : 'would remove') : 'report';
+        console.log(`${action}: ${candidate.path} (${FsHelpers.formatFileSize(candidate.bytes)}) - ${candidate.reason}`);
+      }
+      if (apply) {
+        await applyTsrustPrunePlan(plan);
+      } else {
+        console.log('Dry-run only. Re-run with --apply to remove marked tsrust target caches.');
+      }
+    });
+  }
+
   private async detectRustDir(): Promise<string | null> {
     // Check rust/ first
     const rustDir = path.join(this.cwd, 'rust');