@poetic-ai/poetic 1.42.0

package/dist/chunk-SLS2N4PH.js

@@ -0,0 +1,2213 @@
+import {
+  createBranchCleanupManager
+} from "./chunk-7IL4A2PP.js";
+import {
+  processScanner
+} from "./chunk-U2S3YEX3.js";
+import {
+  processRegistry
+} from "./chunk-XPHKYHO4.js";
+import {
+  processRemoteBranchCleanupQueue
+} from "./chunk-BXI4NXL3.js";
+import {
+  WORKFLOW_HEARTBEAT_STALE_AFTER_MS,
+  getWorkflowExecutionStatus,
+  getWorkflowLastActivityMs
+} from "./chunk-CQM3A35X.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-4CUY7AFY.js";
+import {
+  DbSizeManager,
+  resolveRetentionConfig
+} from "./chunk-J62KPGII.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  WorktreeCleanupManager
+} from "./chunk-DF5SLDE4.js";
+import {
+  collectActiveRunPids
+} from "./chunk-I5WRT7ZR.js";
+import {
+  pruneGitWorktreeEntries
+} from "./chunk-5EERLVZB.js";
+import {
+  formatBytes
+} from "./chunk-JLS65NUQ.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  findProjectRoot
+} from "./chunk-L6OM4A22.js";
+import {
+  resolveWorktreeBase
+} from "./chunk-UUH2RVKS.js";
+
+// src/core/cleanup/stale-cleanup-orchestrator.ts
+import { appendFile, mkdir as mkdir4, readdir as readdir3, readFile as readFile7, stat as stat8, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname, resolve as resolve6 } 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;
+  constructor(config, telemetryDir) {
+    this.config = config;
+    const poeticDir = getRuntimeEnv("POETIC_TELEMETRY_DIR") || path.join(process.cwd(), ".poetic");
+    this.telemetryDir = telemetryDir || path.join(poeticDir, "telemetry");
+  }
+  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.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 signalResult = await this.cleanupSignalFiles(
+        this.telemetryDir,
+        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.telemetryDir, "db", "variants.db") },
+        { label: "validations.db", path: path.join(this.telemetryDir, "db", "validations.db") },
+        { label: "invocations.db", path: path.join(this.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 { mkdir, opendir, readFile as readFile2, rename as rename2, 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";
+  }
+}
+function monthBucket(mtimeMs) {
+  const date = new Date(mtimeMs);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+async function uniqueArchivePath(targetPath) {
+  try {
+    await stat3(targetPath);
+  } catch {
+    return targetPath;
+  }
+  for (let index = 1; index < 1e3; index++) {
+    const candidate = `${targetPath}.${index}`;
+    try {
+      await stat3(candidate);
+    } catch {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find free archive path for ${targetPath}`);
+}
+async function cleanupBackgroundStateFiles(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve(cwd, ".poetic/telemetry/state/background");
+  const archiveDir = options.archiveDir ?? resolve(cwd, ".poetic/telemetry/state/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 {
+            const archiveMonthDir = resolve(archiveDir, monthBucket(timestampMs));
+            await mkdir(archiveMonthDir, { recursive: true });
+            const targetPath = await uniqueArchivePath(resolve(archiveMonthDir, d.name));
+            await rename2(fullPath, targetPath);
+            item.archivePath = targetPath;
+            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/competition-state-cleanup.ts
+import { opendir as opendir2, readFile as readFile3, rm as rm3, stat as stat4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+function parseIsoDateMs2(value) {
+  if (!value) return null;
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return null;
+  return ms;
+}
+function isTerminalCandidate(candidate) {
+  if (candidate.submittedOnly === true) return false;
+  if (typeof candidate.success === "boolean") return true;
+  if (candidate.timedOut === true) return true;
+  if (typeof candidate.errorMessage === "string" && candidate.errorMessage.trim().length > 0) {
+    return true;
+  }
+  return false;
+}
+function getHandleCandidates(handle) {
+  if (Array.isArray(handle.candidates)) return handle.candidates;
+  if (Array.isArray(handle.variants)) return handle.variants;
+  return [];
+}
+function isTerminalHandle(handle) {
+  const candidates = getHandleCandidates(handle);
+  if (candidates.length === 0) return false;
+  return candidates.every(isTerminalCandidate);
+}
+function describeNonTerminalMetadata(handle) {
+  const candidates = getHandleCandidates(handle);
+  const hasSubmittedOnly = candidates.length > 0 && candidates.every((candidate) => candidate.submittedOnly === true);
+  const hasStatusFields = candidates.some((candidate) => {
+    if (typeof candidate.success === "boolean") return true;
+    if (candidate.timedOut === true) return true;
+    if (typeof candidate.errorMessage === "string" && candidate.errorMessage.trim().length > 0) {
+      return true;
+    }
+    return false;
+  });
+  return {
+    hasSubmittedOnly,
+    hasStatusFields
+  };
+}
+function evaluateNonTerminalState(ageMs, metadata, policy) {
+  if (policy === "strict") {
+    return { keep: true, reason: "non_terminal" };
+  }
+  const hours = ageMs / (60 * 60 * 1e3);
+  const days = ageMs / (24 * 60 * 60 * 1e3);
+  if (days >= 30) {
+    return { keep: false, reason: "non_terminal_stale" };
+  }
+  if (metadata.hasSubmittedOnly && days >= 7) {
+    return { keep: false, reason: "non_terminal_submitted_expired" };
+  }
+  if (metadata.hasSubmittedOnly && hours >= 48) {
+    return { keep: true, reason: "non_terminal_submitted_grace" };
+  }
+  if (!metadata.hasStatusFields && hours >= 48) {
+    return { keep: false, reason: "non_terminal_missing_status" };
+  }
+  return { keep: true, reason: "non_terminal" };
+}
+async function cleanupCompetitionStateFiles(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve2(cwd, ".poetic/telemetry/state/competitions");
+  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;
+  };
+  const entries = [];
+  try {
+    const dir = await opendir2(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        if (!d.name.endsWith(".json")) continue;
+        const fullPath = resolve2(rootDir, d.name);
+        report.scanned++;
+        try {
+          const st = await stat4(fullPath);
+          const sizeBytes = st.size;
+          const tsMsFromStat = st.mtimeMs;
+          const raw = await readFile3(fullPath, "utf8");
+          let parsed;
+          try {
+            parsed = parseJsonWithContext(raw, `Competition state (${d.name})`);
+          } catch {
+            const ageDays = Math.floor((now.getTime() - tsMsFromStat) / (24 * 60 * 60 * 1e3));
+            bump(report.keptBecause, "invalid_json");
+            report.kept++;
+            report.items.push({
+              path: fullPath,
+              sizeBytes,
+              ageDays,
+              terminal: false,
+              decision: "keep",
+              reason: "invalid_json"
+            });
+            continue;
+          }
+          const updatedMs = parseIsoDateMs2(parsed.updatedAt) ?? parseIsoDateMs2(parsed.createdAt);
+          const terminal = isTerminalHandle(parsed);
+          const metadata = describeNonTerminalMetadata(parsed);
+          entries.push({
+            name: d.name,
+            fullPath,
+            sizeBytes,
+            tsMs: updatedMs ?? tsMsFromStat,
+            terminal,
+            metadata
+          });
+        } 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,
+            terminal: false,
+            decision: "keep",
+            reason: "read_error"
+          });
+        }
+      }
+    } finally {
+      await dir.close().catch(() => {
+      });
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    report.errors.push(`Failed to read ${rootDir}: ${msg}`);
+    return report;
+  }
+  const keepLast = Math.max(0, options.keepLast);
+  const keepLastSet = /* @__PURE__ */ new Set();
+  if (keepLast > 0) {
+    const sorted = [...entries].sort((a, b) => b.tsMs - a.tsMs);
+    for (const e of sorted.slice(0, keepLast)) {
+      keepLastSet.add(e.fullPath);
+    }
+  }
+  for (const entry of entries) {
+    const ageMs = now.getTime() - entry.tsMs;
+    const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
+    const terminal = entry.terminal;
+    const metadata = entry.metadata;
+    const policy = options.nonTerminalPolicy ?? (options.keepNonTerminal ? "strict" : "smart");
+    const isTooOld = ageMs > maxAgeMs;
+    let decision = "keep";
+    let reason = "too_recent";
+    if (keepLastSet.has(entry.fullPath)) {
+      decision = "keep";
+      reason = "keep_last";
+      bump(report.keptBecause, reason);
+    } else if (!isTooOld) {
+      decision = "keep";
+      reason = "too_recent";
+      bump(report.keptBecause, reason);
+    } else if (!terminal) {
+      const disposition = evaluateNonTerminalState(ageMs, metadata, policy);
+      if (disposition.keep) {
+        decision = "keep";
+        reason = disposition.reason;
+        bump(report.keptBecause, reason);
+      } else {
+        decision = "delete";
+        reason = disposition.reason;
+        bump(report.deletedBecause, reason);
+      }
+    } else {
+      decision = "delete";
+      reason = "stale_terminal";
+      bump(report.deletedBecause, reason);
+    }
+    if (decision === "delete") {
+      report.eligible++;
+      if (options.dryRun) {
+        report.freedBytes += entry.sizeBytes;
+      } else {
+        try {
+          await rm3(entry.fullPath, { force: true });
+          const eventsPath = entry.fullPath.replace(/\.json$/, ".events.jsonl");
+          await rm3(eventsPath, { force: true }).catch(() => {
+          });
+          report.deleted++;
+          report.freedBytes += entry.sizeBytes;
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          report.errors.push(`${entry.name}: delete failed: ${msg}`);
+          decision = "keep";
+          reason = "read_error";
+          bump(report.keptBecause, reason);
+        }
+      }
+    }
+    if (decision === "keep") report.kept++;
+    report.items.push({
+      path: entry.fullPath,
+      sizeBytes: entry.sizeBytes,
+      ageDays,
+      terminal,
+      decision,
+      reason
+    });
+  }
+  if (options.dryRun) {
+    report.deleted = report.eligible;
+  }
+  if (!options.verbose) {
+    report.items = report.items.slice(0, 200);
+  }
+  return report;
+}
+
+// src/core/cleanup/flywheel-tmp-cleanup.ts
+import { mkdir as mkdir2, opendir as opendir3, readFile as readFile4, rename as rename3, stat as stat5 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+var RESERVED_ENTRIES = /* @__PURE__ */ new Set(["legacy-archive", "detached", "cache"]);
+function monthBucket2(mtimeMs) {
+  const date = new Date(mtimeMs);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+async function uniqueArchivePath2(targetPath) {
+  try {
+    await stat5(targetPath);
+  } catch {
+    return targetPath;
+  }
+  for (let index = 1; index < 1e3; index++) {
+    const candidate = `${targetPath}.${index}`;
+    try {
+      await stat5(candidate);
+    } catch {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find free archive path for ${targetPath}`);
+}
+async function collectDirectoryInfo(dir) {
+  let sizeBytes = 0;
+  let newestMtimeMs = null;
+  async function walk(current) {
+    const entries = await opendir3(current);
+    try {
+      for await (const entry of entries) {
+        const fullPath = resolve3(current, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+          continue;
+        }
+        if (!entry.isFile()) continue;
+        const fileStats = await stat5(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 stat5(dir);
+    newestMtimeMs = rootStats.mtimeMs;
+  }
+  return { sizeBytes, newestMtimeMs };
+}
+async function readWorkflowManifest(workflowDir) {
+  const manifestPath = resolve3(workflowDir, "manifest.json");
+  try {
+    const raw = await readFile4(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 cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowMs = now.getTime();
+  const rootDir = resolve3(cwd, ".poetic/tmp/flywheel");
+  const archiveDir = options.archiveDir ?? resolve3(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 opendir3(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isDirectory()) continue;
+        const fullPath = resolve3(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 {
+            const archiveMonthDir = resolve3(archiveDir, monthBucket2(timestampMs));
+            await mkdir2(archiveMonthDir, { recursive: true });
+            const targetPath = await uniqueArchivePath2(resolve3(archiveMonthDir, d.name));
+            await rename3(fullPath, targetPath);
+            item.archivePath = targetPath;
+            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 opendir4, readFile as readFile5, rm as rm4, 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 isTuiSession(value) {
+  return value.version === 1 && typeof value.sessionId === "string" && value.sessionId.trim().length > 0 && Array.isArray(value.turns);
+}
+async function cleanupTuiSessionStateFiles(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve4(cwd, ".poetic/telemetry/state/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 opendir4(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        if (!d.name.endsWith(".json")) continue;
+        const fullPath = resolve4(rootDir, d.name);
+        report.scanned++;
+        let sizeBytes = 0;
+        let timestampMs = 0;
+        try {
+          const st = await stat6(fullPath);
+          sizeBytes = st.size;
+          timestampMs = st.mtimeMs;
+          const raw = await readFile5(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 = parseIsoDateMs3(parsed.updatedAt) ?? parseIsoDateMs3(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 rm4(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/variant-telemetry-state-cleanup.ts
+import { mkdir as mkdir3, opendir as opendir5, readFile as readFile6, rename as rename4, stat as stat7 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+function parseIsoDateMs4(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;
+}
+function monthBucket3(mtimeMs) {
+  const date = new Date(mtimeMs);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+async function uniqueArchivePath3(targetPath) {
+  try {
+    await stat7(targetPath);
+  } catch {
+    return targetPath;
+  }
+  for (let index = 1; index < 1e3; index++) {
+    const candidate = `${targetPath}.${index}`;
+    try {
+      await stat7(candidate);
+    } catch {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find free archive path for ${targetPath}`);
+}
+async function cleanupVariantTelemetryStateFiles(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const rootDir = resolve5(cwd, ".poetic/telemetry/state/variants");
+  const archiveDir = options.archiveDir ?? resolve5(cwd, ".poetic/telemetry/state/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 opendir5(rootDir);
+    try {
+      for await (const d of dir) {
+        if (!d.isFile()) continue;
+        const fullPath = resolve5(rootDir, d.name);
+        report.scanned++;
+        if (isActiveVariantArtifact(d.name)) {
+          let sizeBytes2 = 0;
+          let timestampMs2 = 0;
+          try {
+            const st = await stat7(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 stat7(fullPath);
+          sizeBytes = st.size;
+          timestampMs = st.mtimeMs;
+          const raw = await readFile6(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 = parseIsoDateMs4(parsed.updatedAt) ?? parseIsoDateMs4(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 {
+            const archiveMonthDir = resolve5(archiveDir, monthBucket3(timestampMs));
+            await mkdir3(archiveMonthDir, { recursive: true });
+            const targetPath = await uniqueArchivePath3(resolve5(archiveMonthDir, d.name));
+            await rename4(fullPath, targetPath);
+            item.archivePath = targetPath;
+            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 = ".poetic/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(),
+      resolve6(tmpdir(), "poetic-worktrees"),
+      resolve6(repoRoot, ".poetic/labs")
+    ])
+  );
+}
+async function loadJudgedTaskIdsBestEffort() {
+  try {
+    const { openConfiguredTelemetryDb } = await import("./storage-access-F6ALDN4S.js");
+    const { listJudgedTaskIds } = await import("./competition-outcome-tracker-R32OOZ43.js");
+    const { TelemetryPathResolver } = await import("./telemetry-path-resolver-7ICSG276.js");
+    const { resolvePoeticRoot } = await import("./poetic-root-V5DNXEAE.js");
+    const poeticDir = resolve6(resolvePoeticRoot(process.cwd()), ".poetic");
+    const projectId = TelemetryPathResolver.getInstance().getProjectId(poeticDir, {
+      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 { resolvePoeticRoot } = await import("./poetic-root-V5DNXEAE.js");
+  const synthesisDir = resolve6(
+    resolvePoeticRoot(process.cwd()),
+    ".poetic",
+    "telemetry",
+    "synthesis"
+  );
+  const ids = /* @__PURE__ */ new Set();
+  try {
+    for (const entry of await readdir3(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.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 ?? [],
+          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 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) => 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: 0, cleaned: 0, freedBytes: 0 },
+          details: { pids: [], errors: [], tmuxSessions: [], skippedActiveRunPids }
+        };
+      }
+      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,
+          cleaned: (options.dryRun ? result.attempted : result.killed) + tmuxCleaned,
+          freedBytes: 0
+          // Processes don't have a size
+        },
+        details: {
+          pids: result.pids,
+          tmuxSessions: reapedTmuxSessions,
+          errors: result.errors,
+          killed: result.killed,
+          failed: result.failed,
+          skippedActiveRunPids
+        }
+      };
+    } 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 cleanupBranches(options) {
+    try {
+      const repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+      if (!options.dryRun) {
+        await pruneGitWorktreeEntries({ cwd: repoRoot });
+      }
+      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 archive-by-rename (git branch -m into
+          // poetic/archive/<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-JOGKTLWA.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-LJPF2BOW.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.
+   *
+   * Note: The primary telemetry databases live under `.poetic/telemetry/db/`.
+   * 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 repoRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+      const dbPath = resolve6(repoRoot, ".poetic/telemetry/db/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 = resolve6(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 mkdir4(dirname(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 stat8(metricsPath);
+  } catch {
+    return;
+  }
+  const content = await readFile7(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-SLS2N4PH.js.map