@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-K2ZMW2Z5.js

@@ -0,0 +1,2147 @@
+import {
+  moveToMonthlyArchive
+} from "./chunk-2JIX3EKV.js";
+import {
+  processRemoteBranchCleanupQueue
+} from "./chunk-SDJV2DTQ.js";
+import {
+  processScanner
+} from "./chunk-47X5LM7B.js";
+import {
+  getProcessRegistryStateDirectory,
+  isSignalEligible,
+  processRegistry
+} from "./chunk-QP5ST7RI.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-B7PYTV72.js";
+import {
+  cleanupCompetitionStateFiles,
+  createBranchCleanupManager,
+  resolveCleanupBuildDir
+} from "./chunk-ZVVD2XGV.js";
+import {
+  WORKFLOW_HEARTBEAT_STALE_AFTER_MS,
+  getWorkflowExecutionStatus,
+  getWorkflowLastActivityMs
+} from "./chunk-6TRD7TEE.js";
+import {
+  DbSizeManager,
+  resolveRetentionConfig
+} from "./chunk-QWMQ74KD.js";
+import {
+  WorktreeCleanupManager,
+  cleanupSessionsCategory
+} from "./chunk-UPHU64NB.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  collectActiveRunPids
+} from "./chunk-2NMNFUQA.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  isDualContainedInManagedRoots
+} from "./chunk-ALDTFNZ3.js";
+import {
+  LabPathResolver,
+  TelemetryPathResolver
+} from "./chunk-C3KCMAJP.js";
+import {
+  resolveRunStateDir
+} from "./chunk-AJN5Y5YZ.js";
+import {
+  findProjectRoot
+} from "./chunk-35J4NE6S.js";
+import {
+  getDataDir,
+  getStableRepoIdentity,
+  resolveWorktreeBase
+} from "./chunk-56WPYDJH.js";
+import {
+  visibleWorktreeBase
+} from "./chunk-RSYTSBOO.js";
+import {
+  getRuntimeEnv,
+  resolveBuildDirFromContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/cleanup/stale-cleanup-orchestrator.ts
+import { appendFile, mkdir, readdir as readdir4, readFile as readFile6, stat as stat7, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname as dirname3, resolve as resolve5 } from "path";
+import { execa } from "execa";
+
+// src/telemetry/cleanup.ts
+import * as fs from "fs";
+import { readFile, rename, writeFile } from "fs/promises";
+import * as path from "path";
+import { promisify } from "util";
+var stat2 = promisify(fs.stat);
+var readdir2 = promisify(fs.readdir);
+var unlink2 = promisify(fs.unlink);
+var rm2 = promisify(fs.rm);
+function cleanupActionLabel(action, dryRun) {
+  if (!dryRun) {
+    return action;
+  }
+  switch (action) {
+    case "DELETED":
+      return "WOULD DELETE";
+    case "ARCHIVED":
+      return "WOULD ARCHIVE";
+    case "SIZE-CAP":
+      return "WOULD SIZE-CAP";
+    default:
+      return `WOULD ${action}`;
+  }
+}
+async function getPathSize(filePath, stats) {
+  const entryStats = stats ?? await stat2(filePath);
+  if (!entryStats.isDirectory()) {
+    return entryStats.size;
+  }
+  let total = 0;
+  const entries = await readdir2(filePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const childPath = path.join(filePath, entry.name);
+    if (entry.isDirectory()) {
+      total += await getPathSize(childPath);
+    } else if (entry.isFile()) {
+      const childStats = await stat2(childPath);
+      total += childStats.size;
+    }
+  }
+  return total;
+}
+function monthKeyFromBackupName(name) {
+  const isoMatch = name.match(/^(\d{4})-(\d{2})/);
+  if (isoMatch?.[1] && isoMatch[2]) {
+    return `${isoMatch[1]}${isoMatch[2]}`;
+  }
+  const compactMatch = name.match(/(\d{6})/);
+  if (compactMatch?.[1]) {
+    return compactMatch[1];
+  }
+  return "unknown";
+}
+var TelemetryCleanup = class _TelemetryCleanup {
+  config;
+  telemetryDir;
+  dbLayout;
+  constructor(config, telemetryDir) {
+    this.config = config;
+    const legacyRoot = getRuntimeEnv("BUILD_TELEMETRY_DIR");
+    const buildDir = legacyRoot || resolveBuildDirFromContext();
+    this.telemetryDir = telemetryDir || path.join(buildDir, "telemetry");
+    this.dbLayout = telemetryDir || legacyRoot ? { telemetryDir: this.telemetryDir, dbDir: path.join(this.telemetryDir, "db") } : TelemetryPathResolver.getInstance().resolveDbLayout(buildDir);
+  }
+  async cleanup(options = {}) {
+    const result = {
+      deletedBackups: 0,
+      deletedLogs: 0,
+      deletedSignalFiles: 0,
+      deletedMergeLedgerLines: 0,
+      freedSpaceBytes: 0,
+      vacuumExecuted: false
+    };
+    try {
+      const backupsDir = path.join(this.telemetryDir, "backups");
+      if (fs.existsSync(backupsDir)) {
+        const backupResult = await this.cleanupBackups(backupsDir, options);
+        result.deletedBackups = backupResult.deleted;
+        result.freedSpaceBytes += backupResult.freedBytes;
+      }
+      const logsDir = path.join(this.dbLayout.telemetryDir, "logs");
+      if (fs.existsSync(logsDir)) {
+        const effectiveLogsDays = options.logsDaysOverride ?? this.config.logs_days;
+        const logResult = await this.cleanupLogs(logsDir, effectiveLogsDays, options);
+        result.deletedLogs = logResult.deleted;
+        result.freedSpaceBytes += logResult.freedBytes;
+      }
+      const signalDirs = /* @__PURE__ */ new Set([this.telemetryDir]);
+      if (!LabPathResolver.getInstance().isLabMode()) {
+        signalDirs.add(
+          TelemetryPathResolver.getInstance().resolveTelemetryDir(path.dirname(this.telemetryDir))
+        );
+      }
+      for (const signalDir of signalDirs) {
+        const signalResult = await this.cleanupSignalFiles(
+          signalDir,
+          this.config.signal_files_retention_days,
+          options
+        );
+        result.deletedSignalFiles += signalResult.deleted;
+        result.freedSpaceBytes += signalResult.freedBytes;
+      }
+      const mergeLedgerResult = await this.cleanupMergeLedger(
+        this.telemetryDir,
+        this.config.signal_files_retention_days,
+        options
+      );
+      result.deletedMergeLedgerLines = mergeLedgerResult.deleted;
+      result.freedSpaceBytes += mergeLedgerResult.freedBytes;
+      const effectiveVacuum = options.vacuumOverride ?? this.config.vacuum_on_cleanup;
+      if (effectiveVacuum && !options.dryRun) {
+        const vacuumResult = await this.vacuumDatabase(options);
+        result.vacuumExecuted = vacuumResult;
+      }
+    } catch (error) {
+      console.error("Cleanup error:", error);
+      throw error;
+    }
+    return result;
+  }
+  async cleanupBackups(backupsDir, options) {
+    const files = await readdir2(backupsDir);
+    const now = Date.now();
+    const retentionMs = this.config.backups_days * 24 * 60 * 60 * 1e3;
+    const maxBackupBytes = this.config.backups_max_bytes ?? Number.POSITIVE_INFINITY;
+    const filesByMonth = /* @__PURE__ */ new Map();
+    const entries = [];
+    const deletedFiles = /* @__PURE__ */ new Set();
+    let deleted = 0;
+    let freedBytes = 0;
+    const deleteEntry = async (entry, label) => {
+      if (deletedFiles.has(entry.name)) return;
+      if (!options.dryRun) {
+        if (entry.isDirectory) {
+          await rm2(entry.path, { recursive: true, force: true });
+        } else {
+          await unlink2(entry.path);
+        }
+      }
+      deletedFiles.add(entry.name);
+      deleted++;
+      freedBytes += entry.size;
+      if (options.verbose) {
+        console.log(
+          `  [${cleanupActionLabel(label, options.dryRun ?? false)}] ${entry.name} (${formatBytes(entry.size)})`
+        );
+      }
+    };
+    for (const file of files) {
+      const filePath = path.join(backupsDir, file);
+      const stats = await stat2(filePath);
+      const size = await getPathSize(filePath, stats);
+      const month = monthKeyFromBackupName(file);
+      const entry = {
+        name: file,
+        path: filePath,
+        month,
+        mtime: stats.mtimeMs,
+        size,
+        isDirectory: stats.isDirectory()
+      };
+      entries.push(entry);
+      if (!filesByMonth.has(month)) {
+        filesByMonth.set(month, []);
+      }
+      filesByMonth.get(month)?.push(entry);
+    }
+    const monthsToKeep = Array.from(filesByMonth.keys()).sort().reverse().slice(0, this.config.backups_monthly_count);
+    for (const [month, monthFiles] of filesByMonth) {
+      const newestMonthlyArchive = [...monthFiles].sort((a, b) => b.mtime - a.mtime)[0];
+      for (const entry of monthFiles) {
+        const ageMs = now - entry.mtime;
+        if (ageMs <= retentionMs) continue;
+        if (!monthsToKeep.includes(month)) {
+          await deleteEntry(entry, "DELETED");
+          continue;
+        }
+        if (entry.name !== newestMonthlyArchive?.name) {
+          await deleteEntry(entry, "ARCHIVED");
+        }
+      }
+    }
+    const remaining = entries.filter((entry) => !deletedFiles.has(entry.name));
+    let remainingBytes = remaining.reduce((sum, entry) => sum + entry.size, 0);
+    const oldestFirst = [...remaining].sort((a, b) => a.mtime - b.mtime);
+    while (remainingBytes > maxBackupBytes && oldestFirst.length > 1) {
+      const entry = oldestFirst.shift();
+      if (!entry) break;
+      await deleteEntry(entry, "SIZE-CAP");
+      remainingBytes -= entry.size;
+    }
+    return { deleted, freedBytes };
+  }
+  async cleanupLogs(logsDir, logsDays, options) {
+    const files = await readdir2(logsDir);
+    const now = Date.now();
+    const retentionMs = logsDays * 24 * 60 * 60 * 1e3;
+    let deleted = 0;
+    let freedBytes = 0;
+    for (const file of files) {
+      const filePath = path.join(logsDir, file);
+      let stats;
+      try {
+        stats = await stat2(filePath);
+      } catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      const ageMs = now - stats.mtimeMs;
+      if (ageMs > retentionMs) {
+        let deleteStats = stats;
+        let freedBytesForEntry = await getPathSize(filePath, deleteStats);
+        if (!options.dryRun) {
+          try {
+            const latest = await stat2(filePath);
+            if (latest.mtimeMs !== stats.mtimeMs || latest.size !== stats.size) {
+              if (options.verbose) {
+                console.log(`  [SKIP] ${file} changed during cleanup`);
+              }
+              continue;
+            }
+            deleteStats = latest;
+            freedBytesForEntry = await getPathSize(filePath, deleteStats);
+          } catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+              continue;
+            }
+            throw error;
+          }
+          if (deleteStats.isDirectory()) {
+            await rm2(filePath, { recursive: true, force: true });
+          } else {
+            await unlink2(filePath);
+          }
+        }
+        deleted++;
+        freedBytes += freedBytesForEntry;
+        if (options.verbose) {
+          console.log(
+            `  [${cleanupActionLabel("DELETED", options.dryRun ?? false)}] ${file} (${formatBytes(freedBytesForEntry)})`
+          );
+        }
+      }
+    }
+    return { deleted, freedBytes };
+  }
+  async cleanupSignalFiles(telemetryDir, retentionDays, options) {
+    let deleted = 0;
+    let freedBytes = 0;
+    if (!fs.existsSync(telemetryDir)) {
+      return { deleted, freedBytes };
+    }
+    let files;
+    try {
+      files = await readdir2(telemetryDir);
+    } catch {
+      return { deleted, freedBytes };
+    }
+    const now = Date.now();
+    const retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
+    for (const file of files) {
+      if (!/^signals-.*\.jsonl$/.test(file)) continue;
+      const filePath = path.join(telemetryDir, file);
+      let stats;
+      try {
+        stats = await stat2(filePath);
+      } catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") continue;
+        throw error;
+      }
+      if (!stats.isFile()) continue;
+      const ageMs = now - stats.mtimeMs;
+      if (ageMs <= retentionMs) continue;
+      if (!options.dryRun) {
+        try {
+          const latest = await stat2(filePath);
+          if (latest.mtimeMs !== stats.mtimeMs || latest.size !== stats.size) {
+            if (options.verbose) {
+              console.log(`  [SKIP] ${file} changed during cleanup`);
+            }
+            continue;
+          }
+        } catch (error) {
+          const err = error;
+          if (err.code === "ENOENT") continue;
+          throw error;
+        }
+        await unlink2(filePath);
+      }
+      deleted++;
+      freedBytes += stats.size;
+      if (options.verbose) {
+        console.log(
+          `  [${cleanupActionLabel("DELETED", options.dryRun ?? false)}] ${file} (${formatBytes(stats.size)})`
+        );
+      }
+    }
+    return { deleted, freedBytes };
+  }
+  async cleanupMergeLedger(telemetryDir, retentionDays, options) {
+    let deleted = 0;
+    let freedBytes = 0;
+    const ledgerPath = path.join(telemetryDir, "merge-ledger.jsonl");
+    if (!fs.existsSync(ledgerPath)) {
+      return { deleted, freedBytes };
+    }
+    let stats;
+    try {
+      stats = await stat2(ledgerPath);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return { deleted, freedBytes };
+      }
+      throw error;
+    }
+    if (!stats.isFile()) {
+      return { deleted, freedBytes };
+    }
+    const originalContent = await readFile(ledgerPath, "utf8");
+    const now = Date.now();
+    const retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
+    const keptLines = [];
+    for (const line of originalContent.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      try {
+        const record = JSON.parse(trimmed);
+        const mergedAtMs = record.mergedAt ? Date.parse(record.mergedAt) : Number.NaN;
+        if (!Number.isFinite(mergedAtMs) || now - mergedAtMs <= retentionMs) {
+          keptLines.push(trimmed);
+          continue;
+        }
+        deleted++;
+      } catch {
+        keptLines.push(trimmed);
+      }
+    }
+    if (deleted === 0) {
+      return { deleted, freedBytes };
+    }
+    const newContent = keptLines.length > 0 ? `${keptLines.join("\n")}
+` : "";
+    freedBytes = Math.max(0, stats.size - Buffer.byteLength(newContent, "utf8"));
+    if (!options.dryRun) {
+      if (newContent) {
+        const tmpPath = `${ledgerPath}.${process.pid}.tmp`;
+        try {
+          await writeFile(tmpPath, newContent, "utf8");
+          await rename(tmpPath, ledgerPath);
+        } catch (writeError) {
+          try {
+            await unlink2(tmpPath);
+          } catch {
+          }
+          throw writeError;
+        }
+      } else {
+        await unlink2(ledgerPath);
+      }
+    }
+    if (options.verbose && deleted > 0) {
+      console.log(`  [TRIMMED] merge-ledger.jsonl (${deleted} stale lines)`);
+    }
+    return { deleted, freedBytes };
+  }
+  async vacuumDatabase(options) {
+    try {
+      const sqlite3 = await import("better-sqlite3").catch(() => null);
+      if (!sqlite3) {
+        if (options.verbose) {
+          console.log("  [SKIP] SQLite not available for VACUUM");
+        }
+        return false;
+      }
+      const dbPaths = [
+        { label: "variants.db", path: path.join(this.dbLayout.dbDir, "variants.db") },
+        { label: "validations.db", path: path.join(this.dbLayout.dbDir, "validations.db") },
+        { label: "invocations.db", path: path.join(this.dbLayout.telemetryDir, "invocations.db") }
+      ];
+      const existing = dbPaths.filter((entry) => fs.existsSync(entry.path));
+      if (existing.length === 0) {
+        if (options.verbose) {
+          console.log("  [SKIP] No telemetry databases found to VACUUM");
+        }
+        return false;
+      }
+      let vacuumedAny = false;
+      for (const entry of existing) {
+        try {
+          const db = sqlite3.default(entry.path);
+          db.exec("VACUUM");
+          db.close();
+          vacuumedAny = true;
+          if (options.verbose) {
+            console.log(`  [VACUUMED] ${entry.label}`);
+          }
+        } catch (error) {
+          if (options.verbose) {
+            console.error(`  [ERROR] VACUUM failed for ${entry.label}:`, error);
+          }
+        }
+      }
+      return vacuumedAny;
+    } catch (error) {
+      if (options.verbose) {
+        console.error("  [ERROR] VACUUM operation failed:", error);
+      }
+      return false;
+    }
+  }
+  static async fromConfig(configPath, telemetryDir) {
+    const resolved = resolveRetentionConfig({ configFilePath: configPath ?? void 0 });
+    const config = {
+      backups_days: resolved.backupsDays,
+      backups_monthly_count: resolved.backupsMonthlyCount,
+      backups_max_bytes: resolved.backupsMaxBytes,
+      logs_days: resolved.logsDays,
+      vacuum_on_cleanup: resolved.vacuumOnCleanup,
+      signal_files_retention_days: resolved.signalFilesRetentionDays
+    };
+    return new _TelemetryCleanup(config, telemetryDir);
+  }
+};
+
+// src/core/cleanup/background-state-cleanup.ts
+import { opendir, readFile as readFile2, stat as stat3 } from "fs/promises";
+import { resolve } from "path";
+function parseIsoDateMs(value) {
+  if (!value) return null;
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return null;
+  return ms;
+}
+function isBackgroundHandle(value) {
+  return typeof value.taskId === "string" && value.taskId.trim().length > 0 && typeof value.status === "string" && value.status.trim().length > 0;
+}
+function isActiveBackgroundRun(handle) {
+  return handle.status === "running";
+}
+function isLivePid(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return false;
+    return "unknown";
+  }
+}
+async function cleanupBackgroundStateFiles(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const stateDir = resolveRunStateDir(resolveCleanupBuildDir(options.cwd));
+  const rootDir = resolve(stateDir, "background");
+  const archiveDir = options.archiveDir ?? resolve(stateDir, "background-archive");
+  const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    rootDir,
+    archiveDir,
+    scanned: 0,
+    eligible: 0,
+    archived: 0,
+    kept: 0,
+    freedBytes: 0,
+    keptBecause: {},
+    archivedBecause: {},
+    items: [],
+    errors: []
+  };
+  const bump = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  try {
+    const dir = await opendir(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        if (!d.name.endsWith(".json")) continue;
+        const fullPath = resolve(rootDir, d.name);
+        report.scanned++;
+        let sizeBytes = 0;
+        let timestampMs = 0;
+        let archiveDeadActiveRun = false;
+        try {
+          const st = await stat3(fullPath);
+          sizeBytes = st.size;
+          timestampMs = st.mtimeMs;
+          const raw = await readFile2(fullPath, "utf8");
+          let parsed;
+          try {
+            parsed = parseJsonWithContext(
+              raw,
+              `Background state (${d.name})`
+            );
+          } catch {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "invalid_json");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "invalid_json"
+            });
+            continue;
+          }
+          if (!isBackgroundHandle(parsed)) {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "not_background_handle");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "not_background_handle"
+            });
+            continue;
+          }
+          timestampMs = parseIsoDateMs(parsed.updatedAt) ?? parseIsoDateMs(parsed.startedAt) ?? parseIsoDateMs(parsed.createdAt) ?? timestampMs;
+          if (isActiveBackgroundRun(parsed)) {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            const live = isLivePid(parsed.pid);
+            if (live === true || live === "unknown") {
+              bump(report.keptBecause, "active_run");
+              report.kept++;
+              report.items.push({
+                path: fullPath,
+                sizeBytes,
+                ageDays: ageDays2,
+                decision: "keep",
+                reason: "active_run"
+              });
+              continue;
+            }
+            archiveDeadActiveRun = true;
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${d.name}: stat/read failed: ${msg}`);
+          bump(report.keptBecause, "read_error");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            decision: "keep",
+            reason: "read_error"
+          });
+          continue;
+        }
+        const ageMs = now.getTime() - timestampMs;
+        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+        if (ageMs <= maxAgeMs && !archiveDeadActiveRun) {
+          bump(report.keptBecause, "too_recent");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "too_recent"
+          });
+          continue;
+        }
+        report.eligible++;
+        const item = {
+          path: fullPath,
+          sizeBytes,
+          ageDays,
+          decision: "archive",
+          reason: "stale_background"
+        };
+        if (options.dryRun) {
+          bump(report.archivedBecause, "stale_background");
+          report.freedBytes += sizeBytes;
+        } else {
+          try {
+            item.archivePath = await moveToMonthlyArchive(
+              fullPath,
+              archiveDir,
+              d.name,
+              timestampMs
+            );
+            report.archived++;
+            bump(report.archivedBecause, "stale_background");
+            report.freedBytes += sizeBytes;
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            report.errors.push(`${d.name}: archive failed: ${msg}`);
+            item.decision = "keep";
+            item.reason = "read_error";
+            report.kept++;
+            bump(report.keptBecause, "read_error");
+            report.items.push(item);
+            continue;
+          }
+        }
+        report.items.push(item);
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch {
+    return report;
+  }
+  if (options.dryRun) {
+    report.archived = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/flywheel-tmp-cleanup.ts
+import { opendir as opendir2, readFile as readFile3, stat as stat4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var RESERVED_ENTRIES = /* @__PURE__ */ new Set(["legacy-archive", "detached", "cache"]);
+async function collectDirectoryInfo(dir) {
+  let sizeBytes = 0;
+  let newestMtimeMs = null;
+  async function walk(current) {
+    const entries = await opendir2(current);
+    try {
+      for await (const entry of entries) {
+        const fullPath = resolve2(current, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+          continue;
+        }
+        if (!entry.isFile()) continue;
+        const fileStats = await stat4(fullPath);
+        sizeBytes += fileStats.size;
+        newestMtimeMs = newestMtimeMs === null ? fileStats.mtimeMs : Math.max(newestMtimeMs, fileStats.mtimeMs);
+      }
+    } finally {
+      await entries.close().catch(() => {
+      });
+    }
+  }
+  await walk(dir);
+  if (newestMtimeMs === null) {
+    const rootStats = await stat4(dir);
+    newestMtimeMs = rootStats.mtimeMs;
+  }
+  return { sizeBytes, newestMtimeMs };
+}
+async function readWorkflowManifest(workflowDir) {
+  const manifestPath = resolve2(workflowDir, "manifest.json");
+  try {
+    const raw = await readFile3(manifestPath, "utf8");
+    const manifest = parseJsonWithContext(
+      raw,
+      `Flywheel manifest (${manifestPath})`
+    );
+    return { manifest };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { manifest: null, readError: msg };
+  }
+}
+function isActiveWorkflow(manifest, now) {
+  if (getWorkflowExecutionStatus({ manifest, now, branchExists: true }) === "running") {
+    return true;
+  }
+  if (manifest.appliedAt || manifest.stagedAt || manifest.applyError) {
+    return false;
+  }
+  const lastActivityMs = getWorkflowLastActivityMs(manifest);
+  if (lastActivityMs === void 0) {
+    return false;
+  }
+  return now - lastActivityMs <= WORKFLOW_HEARTBEAT_STALE_AFTER_MS;
+}
+async function cleanupFlywheelTmpEntries(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const rootDir = resolve2(resolveCleanupBuildDir(options.cwd), "tmp/flywheel");
+  const archiveDir = options.archiveDir ?? resolve2(rootDir, "legacy-archive");
+  const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    rootDir,
+    archiveDir,
+    scanned: 0,
+    eligible: 0,
+    archived: 0,
+    kept: 0,
+    freedBytes: 0,
+    keptBecause: {},
+    archivedBecause: {},
+    items: [],
+    errors: []
+  };
+  const bump = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  try {
+    const dir = await opendir2(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isDirectory()) continue;
+        const fullPath = resolve2(rootDir, d.name);
+        report.scanned++;
+        if (RESERVED_ENTRIES.has(d.name)) {
+          bump(report.keptBecause, "reserved_entry");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            decision: "keep",
+            reason: "reserved_entry"
+          });
+          continue;
+        }
+        let sizeBytes = 0;
+        let timestampMs = 0;
+        try {
+          const info = await collectDirectoryInfo(fullPath);
+          sizeBytes = info.sizeBytes;
+          timestampMs = info.newestMtimeMs ?? 0;
+          const { manifest } = await readWorkflowManifest(fullPath);
+          if (manifest && isActiveWorkflow(manifest, nowMs)) {
+            bump(report.keptBecause, "active_run");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: Math.floor((nowMs - timestampMs) / (24 * 60 * 60 * 1e3)),
+              decision: "keep",
+              reason: "active_run"
+            });
+            continue;
+          }
+          if (!manifest) {
+            bump(report.keptBecause, "not_workflow_dir");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: Math.floor((nowMs - timestampMs) / (24 * 60 * 60 * 1e3)),
+              decision: "keep",
+              reason: "not_workflow_dir"
+            });
+            continue;
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${d.name}: stat/read failed: ${msg}`);
+          bump(report.keptBecause, "read_error");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            decision: "keep",
+            reason: "read_error"
+          });
+          continue;
+        }
+        const ageMs = nowMs - timestampMs;
+        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+        if (ageMs <= maxAgeMs) {
+          bump(report.keptBecause, "too_recent");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "too_recent"
+          });
+          continue;
+        }
+        report.eligible++;
+        const item = {
+          path: fullPath,
+          sizeBytes,
+          ageDays,
+          decision: "archive",
+          reason: "stale_workflow"
+        };
+        if (options.dryRun) {
+          bump(report.archivedBecause, "stale_workflow");
+          report.freedBytes += sizeBytes;
+        } else {
+          try {
+            item.archivePath = await moveToMonthlyArchive(
+              fullPath,
+              archiveDir,
+              d.name,
+              timestampMs
+            );
+            report.archived++;
+            bump(report.archivedBecause, "stale_workflow");
+            report.freedBytes += sizeBytes;
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            report.errors.push(`${d.name}: archive failed: ${msg}`);
+            item.decision = "keep";
+            item.reason = "read_error";
+            report.kept++;
+            bump(report.keptBecause, "read_error");
+            report.items.push(item);
+            continue;
+          }
+        }
+        report.items.push(item);
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch {
+    return report;
+  }
+  if (options.dryRun) {
+    report.archived = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/tui-session-state-cleanup.ts
+import { opendir as opendir3, readFile as readFile4, rm as rm3, stat as stat5 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+function parseIsoDateMs2(value) {
+  if (!value) return null;
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return null;
+  return ms;
+}
+function isTuiSession(value) {
+  return value.version === 1 && typeof value.sessionId === "string" && value.sessionId.trim().length > 0 && Array.isArray(value.turns);
+}
+async function cleanupTuiSessionStateFiles(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve3(resolveRunStateDir(resolveCleanupBuildDir(options.cwd)), "tui-sessions");
+  const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    rootDir,
+    scanned: 0,
+    eligible: 0,
+    deleted: 0,
+    kept: 0,
+    freedBytes: 0,
+    keptBecause: {},
+    deletedBecause: {},
+    items: [],
+    errors: []
+  };
+  const bump = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  try {
+    const dir = await opendir3(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        if (!d.name.endsWith(".json")) continue;
+        const fullPath = resolve3(rootDir, d.name);
+        report.scanned++;
+        let sizeBytes = 0;
+        let timestampMs = 0;
+        try {
+          const st = await stat5(fullPath);
+          sizeBytes = st.size;
+          timestampMs = st.mtimeMs;
+          const raw = await readFile4(fullPath, "utf8");
+          let parsed;
+          try {
+            parsed = parseJsonWithContext(raw, `TUI session state (${d.name})`);
+          } catch {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "invalid_json");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "invalid_json"
+            });
+            continue;
+          }
+          if (!isTuiSession(parsed)) {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "not_tui_session");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "not_tui_session"
+            });
+            continue;
+          }
+          timestampMs = parseIsoDateMs2(parsed.updatedAt) ?? parseIsoDateMs2(parsed.createdAt) ?? timestampMs;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${d.name}: stat/read failed: ${msg}`);
+          bump(report.keptBecause, "read_error");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            decision: "keep",
+            reason: "read_error"
+          });
+          continue;
+        }
+        const ageMs = now.getTime() - timestampMs;
+        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+        if (ageMs <= maxAgeMs) {
+          bump(report.keptBecause, "too_recent");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "too_recent"
+          });
+          continue;
+        }
+        report.eligible++;
+        if (options.dryRun) {
+          bump(report.deletedBecause, "stale_session");
+          report.freedBytes += sizeBytes;
+        } else {
+          try {
+            await rm3(fullPath, { force: true });
+            report.deleted++;
+            bump(report.deletedBecause, "stale_session");
+            report.freedBytes += sizeBytes;
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            report.errors.push(`${d.name}: delete failed: ${msg}`);
+            report.kept++;
+            bump(report.keptBecause, "read_error");
+            continue;
+          }
+        }
+        report.items.push({
+          path: fullPath,
+          sizeBytes,
+          ageDays,
+          decision: "delete",
+          reason: "stale_session"
+        });
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch {
+    return report;
+  }
+  if (options.dryRun) {
+    report.deleted = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/user-data-cleanup.ts
+import { lstat, readdir as readdir3, rmdir, unlink as unlink3 } from "fs/promises";
+import * as path2 from "path";
+var DEFAULT_PROJECT_DATA_AGE_DAYS = 30;
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var REGISTRY_TEMP_MAX_AGE_MS = MS_PER_DAY;
+var PROJECT_ID_PATTERN = /^[0-9a-f]{12}$/;
+var REGISTRY_TEMP_PATTERN = /^processes\.json\.tmp\./;
+var GENERATED_EMPTY_FILES = /* @__PURE__ */ new Set(["initialization.lock", ".cleanup.lock"]);
+var MAX_ENTRIES_PER_PROJECT = 64;
+async function scanProjectDir(dir) {
+  let newestMtimeMs = (await lstat(dir)).mtimeMs;
+  let seen = 0;
+  const dirs = [dir];
+  const files = [];
+  const notGenerated = { generatedOnly: false, dirs, files };
+  const pending = [dir];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    const entries = await readdir3(current, { withFileTypes: true });
+    for (const entry of entries) {
+      seen += 1;
+      if (seen > MAX_ENTRIES_PER_PROJECT) return { ...notGenerated, newestMtimeMs };
+      const entryPath = path2.join(current, entry.name);
+      if (entry.isDirectory() && !entry.name.endsWith(".lock")) {
+        pending.push(entryPath);
+        dirs.push(entryPath);
+        continue;
+      }
+      if (entry.isFile() && GENERATED_EMPTY_FILES.has(entry.name)) {
+        const stat8 = await lstat(entryPath);
+        if (stat8.size === 0) {
+          newestMtimeMs = Math.max(newestMtimeMs, stat8.mtimeMs);
+          files.push(entryPath);
+          continue;
+        }
+      }
+      return { ...notGenerated, newestMtimeMs };
+    }
+  }
+  return { generatedOnly: true, newestMtimeMs, dirs, files };
+}
+async function removeVerifiedSkeleton(scan, projectsDir) {
+  const root = scan.dirs[0];
+  if (path2.dirname(root) !== projectsDir || !isDualContainedInManagedRoots(root, [projectsDir])) {
+    throw new Error(`Refusing to delete ${root}: not a project folder under ${projectsDir}`);
+  }
+  try {
+    for (const file of scan.files) {
+      const stat8 = await lstat(file);
+      if (stat8.isFile() && stat8.size === 0) await unlink3(file);
+    }
+    for (const d of [...scan.dirs].reverse()) await rmdir(d);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOTEMPTY" || code === "ENOENT" || code === "EEXIST" || code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+  return true;
+}
+function currentProjectId() {
+  try {
+    return getStableRepoIdentity(process.cwd());
+  } catch {
+    return void 0;
+  }
+}
+async function cleanupGeneratedOnlyProjectDirs(options) {
+  const projectsDir = path2.join(options.dataDir ?? getDataDir(), "projects");
+  const cutoff = (options.now ?? Date.now()) - (options.maxAgeDays ?? DEFAULT_PROJECT_DATA_AGE_DAYS) * MS_PER_DAY;
+  const keepId = currentProjectId();
+  const result = {
+    scanned: 0,
+    candidates: [],
+    removed: [],
+    keptWithContent: 0,
+    keptRecent: 0,
+    errors: []
+  };
+  let names;
+  try {
+    names = await readdir3(projectsDir);
+  } catch (error) {
+    if (error.code === "ENOENT") return result;
+    throw error;
+  }
+  for (const name of names) {
+    if (!PROJECT_ID_PATTERN.test(name) || name === keepId) continue;
+    const dir = path2.join(projectsDir, name);
+    try {
+      if (!(await lstat(dir)).isDirectory()) continue;
+      result.scanned += 1;
+      const scan = await scanProjectDir(dir);
+      if (!scan.generatedOnly) {
+        result.keptWithContent += 1;
+        continue;
+      }
+      if (scan.newestMtimeMs >= cutoff) {
+        result.keptRecent += 1;
+        continue;
+      }
+      result.candidates.push(dir);
+      if (options.dryRun) continue;
+      if (await removeVerifiedSkeleton(scan, projectsDir)) {
+        result.removed.push(dir);
+      } else {
+        result.keptWithContent += 1;
+      }
+    } catch (error) {
+      result.errors.push({
+        path: dir,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+async function cleanupStaleRegistryTempFiles(options) {
+  const stateDir = options.stateDir ?? getProcessRegistryStateDirectory();
+  const cutoff = (options.now ?? Date.now()) - REGISTRY_TEMP_MAX_AGE_MS;
+  const result = { candidates: [], removed: 0 };
+  let names;
+  try {
+    names = await readdir3(stateDir);
+  } catch (error) {
+    if (error.code === "ENOENT") return result;
+    throw error;
+  }
+  for (const name of names) {
+    if (!REGISTRY_TEMP_PATTERN.test(name)) continue;
+    const filePath = path2.join(stateDir, name);
+    try {
+      const stat8 = await lstat(filePath);
+      if (!stat8.isFile() || stat8.mtimeMs >= cutoff) continue;
+      result.candidates.push(filePath);
+      if (!options.dryRun) {
+        await unlink3(filePath);
+        result.removed += 1;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+
+// src/core/cleanup/variant-telemetry-state-cleanup.ts
+import { opendir as opendir4, readFile as readFile5, stat as stat6 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+function parseIsoDateMs3(value) {
+  if (!value) return null;
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return null;
+  return ms;
+}
+function isActiveVariantArtifact(fileName) {
+  return fileName.endsWith(".partial.json") || fileName.endsWith(".partial.json.pid") || fileName.endsWith(".partial.json.sigterm");
+}
+function isVariantState(value) {
+  return typeof value.taskId === "string" && value.taskId.trim().length > 0 || typeof value.variant === "string" && value.variant.trim().length > 0 || typeof value.provider === "string" && value.provider.trim().length > 0 && typeof value.strategy === "string" && value.strategy.trim().length > 0;
+}
+async function cleanupVariantTelemetryStateFiles(options) {
+  const buildDir = resolveCleanupBuildDir(options.cwd);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const stateDir = resolveRunStateDir(buildDir);
+  const rootDir = resolve4(stateDir, "variants");
+  const archiveDir = options.archiveDir ?? resolve4(stateDir, "variants-archive");
+  const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1e3;
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    rootDir,
+    archiveDir,
+    scanned: 0,
+    eligible: 0,
+    archived: 0,
+    kept: 0,
+    freedBytes: 0,
+    keptBecause: {},
+    archivedBecause: {},
+    items: [],
+    errors: []
+  };
+  const bump = (map, key) => {
+    map[key] = (map[key] ?? 0) + 1;
+  };
+  try {
+    const dir = await opendir4(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        const fullPath = resolve4(rootDir, d.name);
+        report.scanned++;
+        if (isActiveVariantArtifact(d.name)) {
+          let sizeBytes2 = 0;
+          let timestampMs2 = 0;
+          try {
+            const st = await stat6(fullPath);
+            sizeBytes2 = st.size;
+            timestampMs2 = st.mtimeMs;
+          } catch {
+            bump(report.keptBecause, "read_error");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes: 0,
+              ageDays: 0,
+              decision: "keep",
+              reason: "read_error"
+            });
+            continue;
+          }
+          bump(report.keptBecause, "active_run");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: sizeBytes2,
+            ageDays: Math.floor((now.getTime() - timestampMs2) / (24 * 60 * 60 * 1e3)),
+            decision: "keep",
+            reason: "active_run"
+          });
+          continue;
+        }
+        if (!d.name.endsWith(".json")) {
+          bump(report.keptBecause, "not_variant_state");
+          report.kept++;
+          continue;
+        }
+        let sizeBytes = 0;
+        let timestampMs = 0;
+        let parsedTaskId = null;
+        try {
+          const st = await stat6(fullPath);
+          sizeBytes = st.size;
+          timestampMs = st.mtimeMs;
+          const raw = await readFile5(fullPath, "utf8");
+          let parsed;
+          try {
+            parsed = parseJsonWithContext(raw, `Variant state (${d.name})`);
+          } catch {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "invalid_json");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "invalid_json"
+            });
+            continue;
+          }
+          if (!isVariantState(parsed)) {
+            const ageDays2 = Math.floor((now.getTime() - timestampMs) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "not_variant_state");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays: ageDays2,
+              decision: "keep",
+              reason: "not_variant_state"
+            });
+            continue;
+          }
+          timestampMs = parseIsoDateMs3(parsed.updatedAt) ?? parseIsoDateMs3(parsed.createdAt) ?? timestampMs;
+          parsedTaskId = typeof parsed.taskId === "string" ? parsed.taskId : null;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${d.name}: stat/read failed: ${msg}`);
+          bump(report.keptBecause, "read_error");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes: 0,
+            ageDays: 0,
+            decision: "keep",
+            reason: "read_error"
+          });
+          continue;
+        }
+        const ageMs = now.getTime() - timestampMs;
+        const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+        if (ageMs <= maxAgeMs) {
+          bump(report.keptBecause, "too_recent");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "too_recent"
+          });
+          continue;
+        }
+        if (options.synthesisTaskIdsUnavailable) {
+          bump(report.keptBecause, "synthesis_retention_unknown");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "synthesis_retention_unknown"
+          });
+          continue;
+        }
+        if (options.keepJudgedTaskIds && parsedTaskId && options.keepJudgedTaskIds.has(parsedTaskId) && ageMs <= maxAgeMs * (options.judgedRetentionMultiplier ?? 3)) {
+          bump(report.keptBecause, "judged_retention");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "judged_retention"
+          });
+          continue;
+        }
+        if (options.keepSynthesisTaskIds && parsedTaskId && options.keepSynthesisTaskIds.has(parsedTaskId) && ageMs <= maxAgeMs * (options.judgedRetentionMultiplier ?? 3)) {
+          bump(report.keptBecause, "synthesis_retention");
+          report.kept++;
+          report.items.push({
+            path: fullPath,
+            sizeBytes,
+            ageDays,
+            decision: "keep",
+            reason: "synthesis_retention"
+          });
+          continue;
+        }
+        report.eligible++;
+        const item = {
+          path: fullPath,
+          sizeBytes,
+          ageDays,
+          decision: "archive",
+          reason: "stale_variant"
+        };
+        if (options.dryRun) {
+          bump(report.archivedBecause, "stale_variant");
+          report.freedBytes += sizeBytes;
+        } else {
+          try {
+            item.archivePath = await moveToMonthlyArchive(
+              fullPath,
+              archiveDir,
+              d.name,
+              timestampMs
+            );
+            report.archived++;
+            bump(report.archivedBecause, "stale_variant");
+            report.freedBytes += sizeBytes;
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            report.errors.push(`${d.name}: archive failed: ${msg}`);
+            item.decision = "keep";
+            item.reason = "read_error";
+            report.kept++;
+            bump(report.keptBecause, "read_error");
+            report.items.push(item);
+            continue;
+          }
+        }
+        report.items.push(item);
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch {
+    return report;
+  }
+  if (options.dryRun) {
+    report.archived = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/stale-cleanup-orchestrator.ts
+var DEFAULT_STALE_CLEANUP_LOG_AGE_DAYS = 7;
+var DEFAULT_STALE_CLEANUP_BRANCH_AGE_DAYS = 7;
+var DEFAULT_STALE_CLEANUP_STATE_AGE_DAYS = 30;
+var DEFAULT_STALE_CLEANUP_AUTOLOOP_AGE_DAYS = 14;
+var DEFAULT_STALE_CLEANUP_UNIFIED_STATE_AGE_DAYS = 14;
+var CLEANUP_METRICS_RELATIVE_PATH = ".build-project/tmp/cleanup-metrics.jsonl";
+var CLEANUP_METRICS_MAX_BYTES = 1e6;
+var CLEANUP_METRICS_MAX_LINES = 2e3;
+function getActiveRunSentinelRoots() {
+  const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+  return Array.from(
+    /* @__PURE__ */ new Set([
+      resolveWorktreeBase(),
+      resolve5(visibleWorktreeBase()),
+      resolve5(tmpdir(), "build-worktrees"),
+      resolve5(repoRoot, ".build-project/labs")
+    ])
+  );
+}
+async function loadJudgedTaskIdsBestEffort() {
+  try {
+    const { openConfiguredTelemetryDb } = await import("./storage-access-I3V5LER7.js");
+    const { listJudgedTaskIds } = await import("./competition-outcome-tracker-NWSMVUPG.js");
+    const { TelemetryPathResolver: TelemetryPathResolver2 } = await import("./telemetry-path-resolver-H3NFHHQY.js");
+    const buildDir = resolveBuildDirFromContext();
+    const projectId = TelemetryPathResolver2.getInstance().getProjectId(buildDir, {
+      register: false
+    });
+    const { db } = openConfiguredTelemetryDb();
+    if (!db) return void 0;
+    try {
+      return listJudgedTaskIds(db, { projectId });
+    } finally {
+      db.close();
+    }
+  } catch {
+    return void 0;
+  }
+}
+async function loadSynthesisTaskIds() {
+  const { TelemetryPathResolver: TelemetryPathResolver2 } = await import("./telemetry-path-resolver-H3NFHHQY.js");
+  const buildDir = resolveBuildDirFromContext();
+  const dbDir = TelemetryPathResolver2.getInstance().resolveDbDir(buildDir);
+  const telemetryDir = basename(dbDir) === "db" ? dirname3(dbDir) : dbDir;
+  const synthesisDir = resolve5(telemetryDir, "synthesis");
+  const ids = /* @__PURE__ */ new Set();
+  try {
+    for (const entry of await readdir4(synthesisDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      ids.add(basename(entry.name, ".json"));
+    }
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    throw error;
+  }
+  return ids.size > 0 ? ids : void 0;
+}
+var StaleCleanupOrchestrator = class {
+  worktreeManager;
+  dbSizeManager = null;
+  constructor() {
+    this.worktreeManager = new WorktreeCleanupManager();
+  }
+  async cleanup(options) {
+    const report = {
+      mode: options.dryRun ? "dry-run" : "executed",
+      categories: [],
+      totals: { freedBytes: 0, itemsCleaned: 0 }
+    };
+    if (options.categories.includes("worktrees")) {
+      const result = await this.cleanupWorktrees(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("telemetry")) {
+      const result = await this.cleanupTelemetry(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("processes")) {
+      const result = await this.cleanupProcesses(options);
+      report.categories.push(result);
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("db")) {
+      const result = await this.cleanupDatabase(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("branches")) {
+      const result = await this.cleanupBranches(options);
+      report.categories.push(result);
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("state")) {
+      const result = await this.cleanupState(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("autoloop")) {
+      const result = await this.cleanupAutoloop(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("unified-state")) {
+      const result = await this.cleanupUnifiedState(options);
+      report.categories.push(result);
+      report.totals.freedBytes += result.summary.freedBytes;
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("sessions")) {
+      const result = await cleanupSessionsCategory(
+        findProjectRoot(process.cwd()) ?? process.cwd(),
+        { dryRun: options.dryRun }
+      );
+      report.categories.push(result);
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (options.categories.includes("projects")) {
+      const result = await this.cleanupProjects(options);
+      report.categories.push(result);
+      report.totals.itemsCleaned += result.summary.cleaned;
+    }
+    if (!options.dryRun) {
+      await trackCleanupMetrics(report, options);
+    }
+    return report;
+  }
+  async cleanupWorktrees(options) {
+    try {
+      const result = await this.worktreeManager.cleanup({
+        maxAgeMs: options.worktreeAgeMs,
+        dryRun: options.dryRun,
+        includeLabs: options.includeLabWorktrees,
+        verbose: options.verbose,
+        limit: options.worktreeLimit,
+        estimateSize: options.worktreeEstimateSize,
+        includeBrokenMetadata: options.worktreeIncludeBrokenMetadata
+      });
+      return {
+        name: "worktrees",
+        enabled: true,
+        summary: {
+          found: result.deletedWorktrees.length,
+          // In dry-run, these are "would delete"
+          cleaned: options.dryRun ? result.deletedWorktrees.length : result.deleted,
+          freedBytes: result.freedBytes
+        },
+        details: {
+          paths: result.deletedWorktrees,
+          labCleaned: result.deletedLabWorktrees,
+          labSkipped: result.skippedLabWorktrees,
+          dirtySkipped: result.skippedDirtyWorktrees ?? [],
+          uninspectableSkipped: result.skippedUninspectableWorktrees ?? [],
+          brokenMetadataCleaned: result.deletedBrokenMetadataWorktrees ?? [],
+          prunedGitWorktreeEntries: result.prunedGitWorktreeEntries ?? 0,
+          preservedWorktrees: result.preservedWorktrees ?? [],
+          retentionMaxAgeMs: result.retentionMaxAgeMs,
+          lockPreviewDegraded: result.lockPreviewDegraded ?? false,
+          lockDiagnostics: result.lockDiagnostics
+        }
+      };
+    } catch (error) {
+      return {
+        name: "worktrees",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupTelemetry(options) {
+    try {
+      const cleanup = await TelemetryCleanup.fromConfig();
+      const result = await cleanup.cleanup({
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        logsDaysOverride: options.logAgeDays,
+        vacuumOverride: options.vacuum
+      });
+      return {
+        name: "telemetry",
+        enabled: true,
+        summary: {
+          found: result.deletedBackups + result.deletedLogs + result.deletedSignalFiles + result.deletedMergeLedgerLines,
+          cleaned: result.deletedBackups + result.deletedLogs + result.deletedSignalFiles + result.deletedMergeLedgerLines,
+          freedBytes: result.freedSpaceBytes
+        },
+        details: {
+          deletedBackups: result.deletedBackups,
+          deletedLogs: result.deletedLogs,
+          deletedSignalFiles: result.deletedSignalFiles,
+          deletedMergeLedgerLines: result.deletedMergeLedgerLines,
+          vacuumExecuted: result.vacuumExecuted
+        }
+      };
+    } catch (error) {
+      return {
+        name: "telemetry",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupProcesses(options) {
+    try {
+      await processScanner.scan({ includeAll: true });
+      const scanResult = await processRegistry.scan();
+      const reapedTmuxSessions = await reapOrphanedTmuxSessions({ dryRun: options.dryRun });
+      const registryTemp = await cleanupStaleRegistryTempFiles({ dryRun: options.dryRun });
+      const registryTempCleaned = options.dryRun ? registryTemp.candidates.length : registryTemp.removed;
+      const unhealthyCount = scanResult.staleCount + scanResult.orphanedCount + scanResult.zombieCount;
+      const protectedActiveRunPids = unhealthyCount > 0 ? await collectActiveRunPids(getActiveRunSentinelRoots()) : /* @__PURE__ */ new Set();
+      const unhealthyProcessEntries = unhealthyCount > 0 ? (await processRegistry.getAll()).filter(
+        (entry) => isSignalEligible(entry) && (entry.health === "stale" || entry.health === "orphaned" || entry.health === "zombie")
+      ) : [];
+      const processTargets = unhealthyProcessEntries.filter(
+        (entry) => !protectedActiveRunPids.has(entry.pid)
+      );
+      const skippedActiveRunPids = unhealthyProcessEntries.filter((entry) => protectedActiveRunPids.has(entry.pid)).map((entry) => entry.pid);
+      const staleCount = processTargets.length;
+      if (staleCount === 0 && reapedTmuxSessions.length === 0) {
+        return {
+          name: "processes",
+          enabled: true,
+          summary: {
+            found: registryTemp.candidates.length,
+            cleaned: registryTempCleaned,
+            freedBytes: 0
+          },
+          details: {
+            pids: [],
+            errors: [],
+            tmuxSessions: [],
+            skippedActiveRunPids,
+            registryTempFiles: registryTemp.candidates
+          }
+        };
+      }
+      const result = staleCount > 0 ? await processRegistry.cleanup({
+        health: ["stale", "orphaned", "zombie"],
+        pids: processTargets.map((entry) => entry.pid),
+        dryRun: options.dryRun
+      }) : { attempted: 0, killed: 0, failed: 0, pids: [], errors: [] };
+      const tmuxCleaned = options.dryRun ? reapedTmuxSessions.length : reapedTmuxSessions.length;
+      return {
+        name: "processes",
+        enabled: true,
+        summary: {
+          found: result.attempted + reapedTmuxSessions.length + registryTemp.candidates.length,
+          cleaned: (options.dryRun ? result.attempted : result.killed) + tmuxCleaned + registryTempCleaned,
+          freedBytes: 0
+          // Processes don't have a size
+        },
+        details: {
+          pids: result.pids,
+          tmuxSessions: reapedTmuxSessions,
+          errors: result.errors,
+          killed: result.killed,
+          failed: result.failed,
+          skippedActiveRunPids,
+          registryTempFiles: registryTemp.candidates
+        }
+      };
+    } catch (error) {
+      return {
+        name: "processes",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupProjects(options) {
+    try {
+      const result = await cleanupGeneratedOnlyProjectDirs({
+        dryRun: options.dryRun,
+        maxAgeDays: options.projectDataAgeDays
+      });
+      return {
+        name: "projects",
+        enabled: true,
+        summary: {
+          found: result.candidates.length,
+          cleaned: options.dryRun ? result.candidates.length : result.removed.length,
+          freedBytes: 0
+        },
+        details: result
+      };
+    } catch (error) {
+      return {
+        name: "projects",
+        enabled: true,
+        skipped: { reason: error instanceof Error ? error.message : String(error) },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupBranches(options) {
+    try {
+      const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+      const branchManager = createBranchCleanupManager(repoRoot);
+      const result = await branchManager.archive({
+        includeBranches: true,
+        // Already gated by category check
+        includeTestBranches: options.includeTestBranches ?? false,
+        dryRun: options.dryRun,
+        allowUnmerged: options.allowUnmerged ?? false,
+        confirm: options.branchConfirm,
+        minAgeDays: options.branchAgeDays ?? DEFAULT_STALE_CLEANUP_BRANCH_AGE_DAYS,
+        maxArchiveCount: 100,
+        verbose: options.verbose
+      });
+      const archiveCandidates = result.branches.filter((b) => b.action === "archive");
+      const archiveCount = archiveCandidates.length;
+      const localCleanedCount = options.dryRun || result.mode === "executed" ? archiveCount : 0;
+      const skipReasons = result.branches.filter((b) => b.action === "skip").slice(0, 10).map((b) => ({ name: b.name, reason: b.reason }));
+      let remoteQueue = await processRemoteBranchCleanupQueue({
+        dryRun: true,
+        verbose: options.verbose,
+        cwd: repoRoot
+      });
+      const remoteDeleteCandidates = remoteQueue.wouldDelete ?? 0;
+      const remoteConfirmMatches = options.remoteBranchConfirm !== void 0 && options.remoteBranchConfirm === remoteDeleteCandidates;
+      let remoteQueueErrors = [...remoteQueue.errors];
+      if (!options.dryRun && result.mode === "executed" && options.remoteBranchConfirm !== void 0 && !remoteConfirmMatches) {
+        remoteQueueErrors.push(
+          `Remote branch cleanup queue confirmation mismatch: expected --confirm-remote ${remoteDeleteCandidates}, got ${options.remoteBranchConfirm}`
+        );
+      }
+      if (!options.dryRun && result.mode === "executed" && remoteConfirmMatches) {
+        remoteQueue = await processRemoteBranchCleanupQueue({
+          dryRun: false,
+          verbose: options.verbose,
+          cwd: repoRoot
+        });
+        remoteQueueErrors = [...remoteQueueErrors, ...remoteQueue.errors];
+      }
+      const remoteCleanedCount = options.dryRun ? remoteDeleteCandidates : remoteQueue.mode === "executed" ? remoteQueue.deleted : 0;
+      const shouldPrune = options.pruneRemoteRefs === true && !options.dryRun && remoteQueue.mode === "executed";
+      const remotePrune = shouldPrune ? await execa("git", ["fetch", "--prune", "origin"], { cwd: repoRoot, reject: false }) : null;
+      return {
+        name: "branches",
+        enabled: true,
+        summary: {
+          found: archiveCount + remoteQueue.found,
+          cleaned: localCleanedCount + remoteCleanedCount,
+          // Local branch "cleanup" is a move-aside rename (git branch -m into
+          // build/removed/<date>/<name>), so it does not reduce the local ref
+          // count. Reported separately because `cleaned` alone reads as deletion:
+          // an operator running cleanup to shed refs would otherwise see a
+          // non-zero cleaned count next to an unchanged `git branch` listing.
+          archived: localCleanedCount,
+          freedBytes: 0
+          // Branches don't have a size
+        },
+        details: {
+          mode: result.mode,
+          defaultBranch: result.defaultBranch,
+          patternsUsed: result.patternsUsed,
+          scanned: result.scanned,
+          archived: archiveCount,
+          skipped: result.skipped,
+          cleaned: localCleanedCount,
+          skipReasons,
+          circuitBreakerTriggered: result.circuitBreakerTriggered,
+          errors: result.errors,
+          unbornRepository: result.unbornRepository === true,
+          remoteBranchCleanupQueue: {
+            ...remoteQueue,
+            errors: remoteQueueErrors,
+            confirmationRequired: !options.dryRun && result.mode === "executed" && remoteQueue.mode !== "executed" && remoteDeleteCandidates > 0 ? remoteDeleteCandidates : void 0,
+            confirmationProvided: options.remoteBranchConfirm
+          },
+          remotePrune: remotePrune === null ? { attempted: false } : {
+            attempted: true,
+            exitCode: remotePrune.exitCode,
+            stderr: (remotePrune.stderr ?? "").trim()
+          }
+        }
+      };
+    } catch (error) {
+      return {
+        name: "branches",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupState(options) {
+    try {
+      const nonTerminalPolicy = options.nonTerminalPolicy ?? (options.keepNonTerminalState === void 0 ? "smart" : options.keepNonTerminalState ? "strict" : "smart");
+      const maxAgeDays = options.stateAgeDays ?? DEFAULT_STALE_CLEANUP_STATE_AGE_DAYS;
+      const cleanupOptions = {
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+        maxAgeDays
+      };
+      const keepJudgedTaskIds = await loadJudgedTaskIdsBestEffort();
+      let keepSynthesisTaskIds;
+      let synthesisTaskIdsUnavailable = false;
+      try {
+        keepSynthesisTaskIds = await loadSynthesisTaskIds();
+      } catch {
+        synthesisTaskIdsUnavailable = true;
+      }
+      const result = await cleanupCompetitionStateFiles({
+        ...cleanupOptions,
+        keepNonTerminal: options.keepNonTerminalState ?? false,
+        keepLast: options.keepLastState ?? 0,
+        nonTerminalPolicy
+      });
+      const tuiSessions = await cleanupTuiSessionStateFiles(cleanupOptions);
+      const background = await cleanupBackgroundStateFiles(cleanupOptions);
+      const variants = await cleanupVariantTelemetryStateFiles({
+        ...cleanupOptions,
+        keepJudgedTaskIds,
+        keepSynthesisTaskIds,
+        synthesisTaskIdsUnavailable
+      });
+      const flywheel = await cleanupFlywheelTmpEntries(cleanupOptions);
+      const keptBecause = { ...result.keptBecause };
+      const deletedBecause = { ...result.deletedBecause };
+      const mergeKept = (prefix, map) => {
+        for (const [reason, count] of Object.entries(map)) {
+          keptBecause[`${prefix}_${reason}`] = (keptBecause[`${prefix}_${reason}`] ?? 0) + count;
+        }
+      };
+      const mergeArchived = (prefix, map) => {
+        for (const [reason, count] of Object.entries(map)) {
+          deletedBecause[`${prefix}_${reason}`] = (deletedBecause[`${prefix}_${reason}`] ?? 0) + count;
+        }
+      };
+      mergeKept("tui", tuiSessions.keptBecause);
+      mergeKept("background", background.keptBecause);
+      mergeKept("variants", variants.keptBecause);
+      mergeKept("flywheel", flywheel.keptBecause);
+      mergeArchived("tui", tuiSessions.deletedBecause);
+      mergeArchived("background", background.archivedBecause);
+      mergeArchived("variants", variants.archivedBecause);
+      mergeArchived("flywheel", flywheel.archivedBecause);
+      const found = result.eligible + tuiSessions.eligible + background.eligible + variants.eligible + flywheel.eligible;
+      const cleaned = options.dryRun ? found : result.deleted + tuiSessions.deleted + background.archived + variants.archived + flywheel.archived;
+      const freedBytes = result.freedBytes + tuiSessions.freedBytes + background.freedBytes + variants.freedBytes + flywheel.freedBytes;
+      return {
+        name: "state",
+        enabled: true,
+        summary: {
+          found,
+          cleaned,
+          freedBytes
+        },
+        details: {
+          ...result,
+          keptBecause,
+          deletedBecause,
+          tuiSessions,
+          background,
+          variants,
+          flywheel
+        }
+      };
+    } catch (error) {
+      return {
+        name: "state",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupAutoloop(options) {
+    try {
+      const { cleanupAutoloopArtifacts } = await import("./autoloop-cleanup-SI3VGAAR.js");
+      const result = await cleanupAutoloopArtifacts({
+        dryRun: options.dryRun,
+        maxAgeDays: options.autoloopAgeDays ?? DEFAULT_STALE_CLEANUP_AUTOLOOP_AGE_DAYS,
+        verbose: options.verbose
+      });
+      return {
+        name: "autoloop",
+        enabled: true,
+        summary: {
+          found: result.eligible,
+          cleaned: options.dryRun ? result.eligible : result.deleted,
+          freedBytes: result.freedBytes
+        },
+        details: result
+      };
+    } catch (error) {
+      return {
+        name: "autoloop",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupUnifiedState(options) {
+    try {
+      const { cleanupUnifiedStateFiles } = await import("./unified-state-cleanup-GGAXLHXF.js");
+      const result = await cleanupUnifiedStateFiles({
+        dryRun: options.dryRun,
+        maxAgeDays: options.unifiedStateAgeDays ?? DEFAULT_STALE_CLEANUP_UNIFIED_STATE_AGE_DAYS,
+        verbose: options.verbose
+      });
+      return {
+        name: "unified-state",
+        enabled: true,
+        summary: {
+          found: result.eligible,
+          cleaned: options.dryRun ? result.eligible : result.deleted,
+          freedBytes: result.freedBytes
+        },
+        details: result
+      };
+    } catch (error) {
+      return {
+        name: "unified-state",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  async cleanupDatabase(options) {
+    try {
+      const dbManager = await this.getDbSizeManager();
+      if (!dbManager) {
+        return {
+          name: "db",
+          enabled: true,
+          skipped: {
+            reason: "Database manager unavailable (better-sqlite3 or DB path missing)"
+          },
+          summary: { found: 0, cleaned: 0, freedBytes: 0 },
+          details: {}
+        };
+      }
+      const stats = await dbManager.getStats();
+      if (stats.level === "ok" || !options.vacuum) {
+        return {
+          name: "db",
+          enabled: true,
+          skipped: stats.level === "ok" ? {
+            reason: `Database under threshold (${stats.sizeFormatted})`,
+            blocking: false
+          } : { reason: "Vacuum not requested", blocking: false },
+          summary: { found: 0, cleaned: 0, freedBytes: 0 },
+          details: { level: stats.level, size: stats.sizeFormatted }
+        };
+      }
+      const result = await dbManager.cleanup({
+        olderThan: stats.level === "warning" ? 90 : 180,
+        // More aggressive for warning level
+        vacuum: true,
+        dryRun: options.dryRun
+      });
+      return {
+        name: "db",
+        enabled: true,
+        summary: {
+          found: result.deletedRecords ?? 0,
+          cleaned: result.deletedRecords ?? 0,
+          freedBytes: result.freedBytes ?? 0
+        },
+        details: {
+          level: stats.level,
+          deletedRecords: result.deletedRecords,
+          vacuumed: !options.dryRun
+        }
+      };
+    } catch (error) {
+      return {
+        name: "db",
+        enabled: true,
+        skipped: {
+          reason: error instanceof Error ? error.message : String(error)
+        },
+        summary: { found: 0, cleaned: 0, freedBytes: 0 },
+        details: {}
+      };
+    }
+  }
+  /**
+   * Lazily create a DbSizeManager with the canonical telemetry DB path.
+   * Returns null if better-sqlite3 is unavailable or the DB cannot be opened.
+   *
+   * The directory follows the resolved telemetry layout, including explicit overrides.
+   * We target `variants.db` as it's the primary/largest database.
+   */
+  async getDbSizeManager() {
+    if (this.dbSizeManager) {
+      return this.dbSizeManager;
+    }
+    try {
+      const sqlite = await import("better-sqlite3").catch(() => null);
+      if (!sqlite) {
+        return null;
+      }
+      const { TelemetryPathResolver: TelemetryPathResolver2 } = await import("./telemetry-path-resolver-H3NFHHQY.js");
+      const dbPath = resolve5(
+        TelemetryPathResolver2.getInstance().resolveDbDir(resolveBuildDirFromContext()),
+        "variants.db"
+      );
+      const { existsSync: existsSync2 } = await import("fs");
+      if (!existsSync2(dbPath)) {
+        return null;
+      }
+      const DatabaseCtor = sqlite.default;
+      const dbInstance = new DatabaseCtor(dbPath);
+      this.dbSizeManager = new DbSizeManager(dbPath, dbInstance);
+      return this.dbSizeManager;
+    } catch {
+      return null;
+    }
+  }
+};
+function createStaleCleanupOrchestrator() {
+  return new StaleCleanupOrchestrator();
+}
+async function trackCleanupMetrics(report, options) {
+  const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+  const metricsPath = resolve5(repoRoot, CLEANUP_METRICS_RELATIVE_PATH);
+  const payload = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: report.mode,
+    categories: report.categories.map((category) => ({
+      name: category.name,
+      cleaned: category.summary.cleaned,
+      found: category.summary.found
+    })),
+    totals: report.totals,
+    options: {
+      categories: options.categories,
+      includeLabWorktrees: options.includeLabWorktrees ?? false
+    }
+  };
+  try {
+    await mkdir(dirname3(metricsPath), { recursive: true });
+    await appendFile(metricsPath, `${JSON.stringify(payload)}
+`, "utf8");
+    await compactCleanupMetrics(metricsPath);
+  } catch (error) {
+    console.debug("Failed to record cleanup metrics", error);
+  }
+}
+async function compactCleanupMetrics(metricsPath) {
+  let stats;
+  try {
+    stats = await stat7(metricsPath);
+  } catch {
+    return;
+  }
+  const content = await readFile6(metricsPath, "utf8");
+  const lines = content.split("\n").filter((line) => line.length > 0);
+  if (stats.size <= CLEANUP_METRICS_MAX_BYTES && lines.length <= CLEANUP_METRICS_MAX_LINES) {
+    return;
+  }
+  const retained = lines.slice(-CLEANUP_METRICS_MAX_LINES);
+  await writeFile2(metricsPath, `${retained.join("\n")}
+`, "utf8");
+}
+
+export {
+  DEFAULT_STALE_CLEANUP_LOG_AGE_DAYS,
+  DEFAULT_STALE_CLEANUP_BRANCH_AGE_DAYS,
+  DEFAULT_STALE_CLEANUP_STATE_AGE_DAYS,
+  DEFAULT_STALE_CLEANUP_AUTOLOOP_AGE_DAYS,
+  DEFAULT_STALE_CLEANUP_UNIFIED_STATE_AGE_DAYS,
+  StaleCleanupOrchestrator,
+  createStaleCleanupOrchestrator
+};
+//# sourceMappingURL=chunk-K2ZMW2Z5.js.map