@graypark/loophaus 3.5.1 → 3.6.1

package/commands/loop-plan.md

@@ -11,6 +11,28 @@ The user runs `/loop-plan` once and gets a single merged branch with all work do
 
 ---
 
+## Phase 0: Cleanup Previous Data
+
+Before starting a new plan, apply the cleanup policy from `.loophaus/config.json`:
+
+```javascript
+import { applyOnNewPlanPolicy } from "../core/cleanup.js";
+const cleanResult = await applyOnNewPlanPolicy();
+```
+
+| Policy | Behavior |
+|--------|----------|
+| `"keep"` (default) | Do nothing — old traces/results persist alongside new data |
+| `"archive"` | Move trace.jsonl + results.tsv + sessions/ to `.loophaus/archive/{date}/` |
+| `"delete"` | Remove trace.jsonl + results.tsv + sessions/ (benchmark.tsv always preserved) |
+
+If cleanup was performed, briefly note it (e.g., "Archived previous loop data.") then continue.
+
+To configure: `loophaus clean --config` to view, or create `.loophaus/config.json`:
+```json
+{ "cleanup": { "onNewPlan": "archive", "traceRetentionDays": 30, "sessionRetentionDays": 7 } }
+```
+
 ## Phase 1: Discovery Interview
 
 Ask 3-5 focused questions about $ARGUMENTS:

package/dist/bin/install.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=install.d.ts.map

package/dist/bin/install.js

@@ -5,4 +5,3 @@ import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const loophausCli = resolve(dirname(__filename), "loophaus.js");
 await import(loophausCli);
-//# sourceMappingURL=install.js.map

package/dist/bin/loophaus.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=loophaus.d.ts.map

package/dist/bin/loophaus.js

@@ -16,11 +16,12 @@ const showHelp = args.includes("--help") || args.includes("-h");
 const KNOWN_FLAGS = new Set([
     "--help", "-h", "--version", "--dry-run", "--force", "--local", "--verbose",
     "--host", "--claude", "--kiro", "--name", "--speed", "--count", "--base", "--story",
+    "--all", "--traces", "--sessions", "--results", "--before", "--config",
 ]);
 const VALID_COMMANDS = [
     "install", "uninstall", "status", "stats", "loops", "watch",
     "replay", "compare", "worktree", "parallel", "quality",
-    "sessions", "resume", "help",
+    "sessions", "resume", "benchmark", "clean", "help",
 ];
 function validateFlags() {
     for (const arg of args) {
@@ -111,6 +112,8 @@ Usage:
   npx @graypark/loophaus worktree <create|remove|list>
   npx @graypark/loophaus parallel <prd.json> [--count N] [--base branch]
   npx @graypark/loophaus quality [--story US-001]
+  npx @graypark/loophaus benchmark
+  npx @graypark/loophaus clean [--all|--traces|--sessions|--results] [--before DATE]
   npx @graypark/loophaus sessions
   npx @graypark/loophaus resume <session-id>
   npx @graypark/loophaus --version
@@ -579,6 +582,107 @@ async function runQuality() {
         }
     }
 }
+async function runBenchmarkCmd() {
+    const { runBenchmark, logBenchmark, readBenchmarkHistory, scoreBenchmark } = await import("../core/benchmark.js");
+    const s = spinner("Running benchmark...");
+    let result;
+    try {
+        result = await runBenchmark();
+    }
+    finally {
+        s.stop();
+    }
+    await logBenchmark(result);
+    console.log("Project Benchmark");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+    console.log(`  Score: ${result.score}/100 (${result.grade})\n`);
+    const labels = {
+        tests: "Tests",
+        typecheck: "Typecheck",
+        build: "Build",
+        testTime: "Test Time",
+        coverage: "Coverage",
+        pkgSize: "Pkg Size",
+    };
+    for (const [key, info] of Object.entries(result.breakdown)) {
+        const bar = "\u2588".repeat(info.score) + "\u2591".repeat(10 - info.score);
+        const label = (labels[key] || key).padEnd(12);
+        console.log(`  ${label} ${bar} ${info.score}/10`);
+    }
+    // Trend
+    const history = await readBenchmarkHistory();
+    if (history.length > 1) {
+        const prev = history[history.length - 2];
+        const diff = result.score - prev.score;
+        const arrow = diff > 0 ? `\x1b[32m+${diff}\x1b[0m` : diff < 0 ? `\x1b[31m${diff}\x1b[0m` : "0";
+        console.log(`\n  Trend: ${prev.score} → ${result.score} (${arrow})`);
+        console.log(`  Prev:  v${prev.version} @ ${prev.commit} (${prev.ts.split("T")[0]})`);
+    }
+    console.log(`\n  Recorded to .loophaus/benchmark.tsv (${history.length} entries)`);
+}
+async function runCleanCmd() {
+    const { cleanAll, cleanTraces, cleanSessions, cleanResults, readConfig } = await import("../core/cleanup.js");
+    const hasFlag = (f) => args.includes(f);
+    if (hasFlag("--config")) {
+        const config = await readConfig();
+        console.log("Cleanup Config (.loophaus/config.json)");
+        console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+        console.log(`  onNewPlan:           ${config.cleanup.onNewPlan}`);
+        console.log(`  traceRetentionDays:  ${config.cleanup.traceRetentionDays}`);
+        console.log(`  sessionRetentionDays: ${config.cleanup.sessionRetentionDays}`);
+        return;
+    }
+    if (!hasFlag("--all") && !hasFlag("--traces") && !hasFlag("--sessions") && !hasFlag("--results")) {
+        console.log(`Usage: loophaus clean [options]
+
+Options:
+  --all        Remove traces + results + sessions (not benchmark.tsv)
+  --traces     Remove trace.jsonl only
+  --sessions   Remove session checkpoints
+  --results    Remove results.tsv only
+  --before DATE  Only remove data before this date (sessions only)
+  --config     Show current cleanup policy`);
+        return;
+    }
+    const beforeRaw = getFlag("--before");
+    const before = beforeRaw ? new Date(beforeRaw) : undefined;
+    let result;
+    if (hasFlag("--all")) {
+        result = await cleanAll();
+    }
+    else {
+        result = { removed: [], archived: [], skipped: [] };
+        if (hasFlag("--traces")) {
+            const r = await cleanTraces();
+            result.removed.push(...r.removed);
+            result.skipped.push(...r.skipped);
+        }
+        if (hasFlag("--results")) {
+            const r = await cleanResults();
+            result.removed.push(...r.removed);
+            result.skipped.push(...r.skipped);
+        }
+        if (hasFlag("--sessions")) {
+            const r = await cleanSessions({ before });
+            result.removed.push(...r.removed);
+            result.skipped.push(...r.skipped);
+        }
+    }
+    console.log("Clean Complete");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    if (result.removed.length > 0) {
+        console.log(`  Removed: ${result.removed.join(", ")}`);
+    }
+    if (result.archived.length > 0) {
+        console.log(`  Archived: ${result.archived.join(", ")}`);
+    }
+    if (result.skipped.length > 0) {
+        console.log(`  Skipped: ${result.skipped.join(", ")}`);
+    }
+    if (result.removed.length === 0 && result.archived.length === 0) {
+        console.log("  Nothing to clean.");
+    }
+}
 try {
     switch (command) {
         case "install":
@@ -614,6 +718,12 @@ try {
         case "quality":
             await runQuality();
             break;
+        case "benchmark":
+            await runBenchmarkCmd();
+            break;
+        case "clean":
+            await runCleanCmd();
+            break;
         case "sessions":
             await runSessions();
             break;
@@ -651,4 +761,3 @@ catch (err) {
     }
     process.exit(1);
 }
-//# sourceMappingURL=loophaus.js.map

package/dist/bin/uninstall.d.ts

@@ -5,4 +5,3 @@ export interface UninstallOptions {
     claude?: boolean;
 }
 export declare function uninstall({ dryRun, local, claude, }?: UninstallOptions): Promise<void>;
-//# sourceMappingURL=uninstall.d.ts.map

package/dist/bin/uninstall.js

@@ -206,4 +206,3 @@ if (isDirectRun) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=uninstall.js.map

package/dist/commands/loop-plan.md

@@ -11,6 +11,28 @@ The user runs `/loop-plan` once and gets a single merged branch with all work do
 
 ---
 
+## Phase 0: Cleanup Previous Data
+
+Before starting a new plan, apply the cleanup policy from `.loophaus/config.json`:
+
+```javascript
+import { applyOnNewPlanPolicy } from "../core/cleanup.js";
+const cleanResult = await applyOnNewPlanPolicy();
+```
+
+| Policy | Behavior |
+|--------|----------|
+| `"keep"` (default) | Do nothing — old traces/results persist alongside new data |
+| `"archive"` | Move trace.jsonl + results.tsv + sessions/ to `.loophaus/archive/{date}/` |
+| `"delete"` | Remove trace.jsonl + results.tsv + sessions/ (benchmark.tsv always preserved) |
+
+If cleanup was performed, briefly note it (e.g., "Archived previous loop data.") then continue.
+
+To configure: `loophaus clean --config` to view, or create `.loophaus/config.json`:
+```json
+{ "cleanup": { "onNewPlan": "archive", "traceRetentionDays": 30, "sessionRetentionDays": 7 } }
+```
+
 ## Phase 1: Discovery Interview
 
 Ask 3-5 focused questions about $ARGUMENTS:

package/dist/core/benchmark.d.ts

@@ -0,0 +1,38 @@
+export interface BenchmarkMetrics {
+    testsPassed: number;
+    testsFailed: number;
+    testsTotal: number;
+    testTimeMs: number;
+    typecheckErrors: number;
+    buildSuccess: boolean;
+    coveragePct: number;
+    pkgSizeKb: number;
+}
+export interface BenchmarkResult {
+    score: number;
+    grade: string;
+    breakdown: Record<string, {
+        value: number;
+        max: number;
+        score: number;
+    }>;
+    metrics: BenchmarkMetrics;
+}
+export interface BenchmarkEntry {
+    ts: string;
+    commit: string;
+    version: string;
+    score: number;
+    grade: string;
+    testsPassed: number;
+    testsTotal: number;
+    testTimeMs: number;
+    typecheckErrors: number;
+    buildSuccess: boolean;
+    coveragePct: number;
+    pkgSizeKb: number;
+}
+export declare function scoreBenchmark(metrics: BenchmarkMetrics): BenchmarkResult;
+export declare function runBenchmark(cwd?: string): Promise<BenchmarkResult>;
+export declare function logBenchmark(result: BenchmarkResult, cwd?: string): Promise<void>;
+export declare function readBenchmarkHistory(cwd?: string): Promise<BenchmarkEntry[]>;

package/dist/core/benchmark.js

@@ -0,0 +1,207 @@
+// core/benchmark.ts
+// Project-level quality measurement (autoresearch pattern: val_bpb → project score)
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readFile, appendFile, mkdir, stat } from "node:fs/promises";
+import { join, dirname } from "node:path";
+const execFileAsync = promisify(execFile);
+export function scoreBenchmark(metrics) {
+    const breakdown = {};
+    // Tests: 0-10 based on pass rate
+    const testRate = metrics.testsTotal > 0 ? metrics.testsPassed / metrics.testsTotal : 0;
+    breakdown.tests = { value: metrics.testsPassed, max: metrics.testsTotal, score: Math.round(testRate * 10) };
+    // Typecheck: 10 if 0 errors, degrade
+    const tcScore = metrics.typecheckErrors === 0 ? 10 : metrics.typecheckErrors <= 5 ? 6 : metrics.typecheckErrors <= 20 ? 3 : 0;
+    breakdown.typecheck = { value: metrics.typecheckErrors, max: 0, score: tcScore };
+    // Build: binary
+    breakdown.build = { value: metrics.buildSuccess ? 1 : 0, max: 1, score: metrics.buildSuccess ? 10 : 0 };
+    // Test time: < 2s = 10, < 5s = 8, < 10s = 6, < 30s = 4, else 2
+    const ttScore = metrics.testTimeMs < 2000 ? 10 : metrics.testTimeMs < 5000 ? 8 : metrics.testTimeMs < 10000 ? 6 : metrics.testTimeMs < 30000 ? 4 : 2;
+    breakdown.testTime = { value: metrics.testTimeMs, max: 2000, score: ttScore };
+    // Coverage: direct percentage mapping to 0-10
+    const covScore = Math.min(10, Math.round(metrics.coveragePct / 10));
+    breakdown.coverage = { value: metrics.coveragePct, max: 100, score: covScore };
+    // Package size: < 50KB = 10, < 100KB = 8, < 200KB = 6, < 500KB = 4, else 2
+    const sizeScore = metrics.pkgSizeKb < 50 ? 10 : metrics.pkgSizeKb < 100 ? 8 : metrics.pkgSizeKb < 200 ? 6 : metrics.pkgSizeKb < 500 ? 4 : 2;
+    breakdown.pkgSize = { value: metrics.pkgSizeKb, max: 50, score: sizeScore };
+    // Weighted average (tests 3x, typecheck 2.5x, build 1.5x, coverage 2x, testTime 0.5x, pkgSize 0.5x)
+    const weights = { tests: 3, typecheck: 2.5, build: 1.5, coverage: 2, testTime: 0.5, pkgSize: 0.5 };
+    let weightedSum = 0;
+    let totalWeight = 0;
+    for (const [key, w] of Object.entries(weights)) {
+        weightedSum += breakdown[key].score * w;
+        totalWeight += 10 * w;
+    }
+    const score = Math.round((weightedSum / totalWeight) * 100);
+    const grade = score >= 90 ? "A+" : score >= 85 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+    return { score, grade, breakdown, metrics };
+}
+export async function runBenchmark(cwd) {
+    const dir = cwd || process.cwd();
+    const metrics = {
+        testsPassed: 0,
+        testsFailed: 0,
+        testsTotal: 0,
+        testTimeMs: 0,
+        typecheckErrors: 0,
+        buildSuccess: false,
+        coveragePct: 0,
+        pkgSizeKb: 0,
+    };
+    // 1. Tests
+    const testStart = Date.now();
+    try {
+        const { stdout } = await execFileAsync("npx", ["vitest", "run", "--reporter=json"], { cwd: dir, timeout: 120_000 });
+        metrics.testTimeMs = Date.now() - testStart;
+        try {
+            const json = JSON.parse(stdout);
+            metrics.testsPassed = json.numPassedTests ?? 0;
+            metrics.testsFailed = json.numFailedTests ?? 0;
+            metrics.testsTotal = json.numTotalTests ?? 0;
+        }
+        catch {
+            // JSON parse failed, try regex fallback
+            const passMatch = stdout.match(/(\d+) passed/);
+            const failMatch = stdout.match(/(\d+) failed/);
+            if (passMatch)
+                metrics.testsPassed = parseInt(passMatch[1]);
+            if (failMatch)
+                metrics.testsFailed = parseInt(failMatch[1]);
+            metrics.testsTotal = metrics.testsPassed + metrics.testsFailed;
+        }
+    }
+    catch (err) {
+        metrics.testTimeMs = Date.now() - testStart;
+        const output = err.stdout || "";
+        const passMatch = output.match(/(\d+) passed/);
+        if (passMatch)
+            metrics.testsPassed = parseInt(passMatch[1]);
+        const failMatch = output.match(/(\d+) failed/);
+        if (failMatch)
+            metrics.testsFailed = parseInt(failMatch[1]);
+        metrics.testsTotal = metrics.testsPassed + metrics.testsFailed;
+    }
+    // 2. Typecheck
+    try {
+        await execFileAsync("npx", ["tsc", "--noEmit"], { cwd: dir, timeout: 60_000 });
+        metrics.typecheckErrors = 0;
+    }
+    catch (err) {
+        const output = err.stdout || err.stderr || "";
+        const errorCount = (output.match(/error TS/g) || []).length;
+        metrics.typecheckErrors = errorCount || 1;
+    }
+    // 3. Build
+    try {
+        await execFileAsync("npm", ["run", "build"], { cwd: dir, timeout: 60_000 });
+        metrics.buildSuccess = true;
+    }
+    catch {
+        metrics.buildSuccess = false;
+    }
+    // 4. Coverage
+    try {
+        const summaryPath = join(dir, "coverage", "coverage-summary.json");
+        const raw = await readFile(summaryPath, "utf-8");
+        const summary = JSON.parse(raw);
+        metrics.coveragePct = summary.total?.lines?.pct ?? 0;
+    }
+    catch {
+        // Run coverage if summary doesn't exist
+        try {
+            await execFileAsync("npx", ["vitest", "run", "--coverage"], { cwd: dir, timeout: 120_000 });
+            const summaryPath = join(dir, "coverage", "coverage-summary.json");
+            const raw = await readFile(summaryPath, "utf-8");
+            const summary = JSON.parse(raw);
+            metrics.coveragePct = summary.total?.lines?.pct ?? 0;
+        }
+        catch {
+            metrics.coveragePct = 0;
+        }
+    }
+    // 5. Package size
+    try {
+        const distDir = join(dir, "dist");
+        const s = await stat(distDir);
+        if (s.isDirectory()) {
+            const { stdout } = await execFileAsync("du", ["-sk", distDir], { timeout: 10_000 });
+            const match = stdout.match(/^(\d+)/);
+            metrics.pkgSizeKb = match ? parseInt(match[1]) : 0;
+        }
+    }
+    catch {
+        metrics.pkgSizeKb = 0;
+    }
+    return scoreBenchmark(metrics);
+}
+function getBenchmarkPath(cwd) {
+    return join(cwd || process.cwd(), ".loophaus", "benchmark.tsv");
+}
+const HEADER = "ts\tcommit\tversion\tscore\tgrade\ttests_passed\ttests_total\ttest_time_ms\ttypecheck_errors\tbuild_ok\tcoverage_pct\tpkg_size_kb\n";
+export async function logBenchmark(result, cwd) {
+    const benchPath = getBenchmarkPath(cwd);
+    await mkdir(dirname(benchPath), { recursive: true });
+    let commitHash = "unknown";
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { timeout: 5_000 });
+        commitHash = stdout.trim();
+    }
+    catch { /* not in git */ }
+    let version = "unknown";
+    try {
+        const pkgPath = join(cwd || process.cwd(), "package.json");
+        const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+        version = pkg.version || "unknown";
+    }
+    catch { /* no package.json */ }
+    // Write header if file is new
+    try {
+        await stat(benchPath);
+    }
+    catch {
+        await appendFile(benchPath, HEADER, "utf-8");
+    }
+    const m = result.metrics;
+    const line = [
+        new Date().toISOString(),
+        commitHash,
+        version,
+        result.score,
+        result.grade,
+        m.testsPassed,
+        m.testsTotal,
+        m.testTimeMs,
+        m.typecheckErrors,
+        m.buildSuccess ? 1 : 0,
+        m.coveragePct.toFixed(1),
+        m.pkgSizeKb,
+    ].join("\t") + "\n";
+    await appendFile(benchPath, line, "utf-8");
+}
+export async function readBenchmarkHistory(cwd) {
+    const benchPath = getBenchmarkPath(cwd);
+    try {
+        const raw = await readFile(benchPath, "utf-8");
+        const lines = raw.trim().split("\n").slice(1); // skip header
+        return lines.map(line => {
+            const cols = line.split("\t");
+            return {
+                ts: cols[0] || "",
+                commit: cols[1] || "",
+                version: cols[2] || "",
+                score: parseInt(cols[3]) || 0,
+                grade: cols[4] || "",
+                testsPassed: parseInt(cols[5]) || 0,
+                testsTotal: parseInt(cols[6]) || 0,
+                testTimeMs: parseInt(cols[7]) || 0,
+                typecheckErrors: parseInt(cols[8]) || 0,
+                buildSuccess: cols[9] === "1",
+                coveragePct: parseFloat(cols[10]) || 0,
+                pkgSizeKb: parseInt(cols[11]) || 0,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}

package/dist/core/cleanup.d.ts

@@ -0,0 +1,23 @@
+export interface CleanupConfig {
+    cleanup: {
+        onNewPlan: "archive" | "delete" | "keep";
+        traceRetentionDays: number;
+        sessionRetentionDays: number;
+    };
+}
+export declare function readConfig(cwd?: string): Promise<CleanupConfig>;
+export declare function writeConfig(config: CleanupConfig, cwd?: string): Promise<void>;
+export interface CleanResult {
+    removed: string[];
+    archived: string[];
+    skipped: string[];
+}
+export declare function cleanTraces(cwd?: string): Promise<CleanResult>;
+export declare function cleanResults(cwd?: string): Promise<CleanResult>;
+export declare function cleanSessions(options?: {
+    cwd?: string;
+    before?: Date;
+}): Promise<CleanResult>;
+export declare function cleanAll(cwd?: string): Promise<CleanResult>;
+export declare function archiveCurrentData(cwd?: string): Promise<CleanResult>;
+export declare function applyOnNewPlanPolicy(cwd?: string): Promise<CleanResult>;

package/dist/core/cleanup.js

@@ -0,0 +1,144 @@
+// core/cleanup.ts
+// Data lifecycle management for .loophaus/ directory
+import { readFile, writeFile, readdir, rm, rename, mkdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+const DEFAULT_CONFIG = {
+    cleanup: {
+        onNewPlan: "keep",
+        traceRetentionDays: 30,
+        sessionRetentionDays: 7,
+    },
+};
+// Files that are NEVER deleted by any clean operation
+const PROTECTED_FILES = new Set(["benchmark.tsv", "config.json"]);
+function getLoophausDir(cwd) {
+    return join(cwd || process.cwd(), ".loophaus");
+}
+export async function readConfig(cwd) {
+    const configPath = join(getLoophausDir(cwd), "config.json");
+    try {
+        const raw = await readFile(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            cleanup: { ...DEFAULT_CONFIG.cleanup, ...parsed.cleanup },
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export async function writeConfig(config, cwd) {
+    const dir = getLoophausDir(cwd);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+}
+export async function cleanTraces(cwd) {
+    const dir = getLoophausDir(cwd);
+    const result = { removed: [], archived: [], skipped: [] };
+    const tracePath = join(dir, "trace.jsonl");
+    try {
+        await rm(tracePath);
+        result.removed.push("trace.jsonl");
+    }
+    catch {
+        result.skipped.push("trace.jsonl");
+    }
+    return result;
+}
+export async function cleanResults(cwd) {
+    const dir = getLoophausDir(cwd);
+    const result = { removed: [], archived: [], skipped: [] };
+    const resultsPath = join(dir, "results.tsv");
+    try {
+        await rm(resultsPath);
+        result.removed.push("results.tsv");
+    }
+    catch {
+        result.skipped.push("results.tsv");
+    }
+    return result;
+}
+export async function cleanSessions(options) {
+    const dir = join(getLoophausDir(options?.cwd), "sessions");
+    const result = { removed: [], archived: [], skipped: [] };
+    try {
+        const files = await readdir(dir);
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            const filePath = join(dir, file);
+            if (options?.before) {
+                const s = await stat(filePath);
+                if (s.mtime >= options.before) {
+                    result.skipped.push(file);
+                    continue;
+                }
+            }
+            await rm(filePath);
+            result.removed.push(file);
+        }
+    }
+    catch {
+        // sessions/ doesn't exist
+    }
+    return result;
+}
+export async function cleanAll(cwd) {
+    const result = { removed: [], archived: [], skipped: [] };
+    const r1 = await cleanTraces(cwd);
+    const r2 = await cleanResults(cwd);
+    const r3 = await cleanSessions({ cwd });
+    result.removed.push(...r1.removed, ...r2.removed, ...r3.removed);
+    result.skipped.push(...r1.skipped, ...r2.skipped, ...r3.skipped);
+    // Explicitly note protected files
+    result.skipped.push("benchmark.tsv (protected)", "config.json (protected)");
+    return result;
+}
+export async function archiveCurrentData(cwd) {
+    const dir = getLoophausDir(cwd);
+    const result = { removed: [], archived: [], skipped: [] };
+    const dateStr = new Date().toISOString().split("T")[0];
+    const archiveDir = join(dir, "archive", dateStr);
+    await mkdir(archiveDir, { recursive: true });
+    const filesToArchive = ["trace.jsonl", "results.tsv"];
+    for (const file of filesToArchive) {
+        const src = join(dir, file);
+        const dest = join(archiveDir, file);
+        try {
+            await rename(src, dest);
+            result.archived.push(`${file} → archive/${dateStr}/${file}`);
+        }
+        catch {
+            result.skipped.push(file);
+        }
+    }
+    // Archive sessions
+    const sessionsDir = join(dir, "sessions");
+    try {
+        const files = await readdir(sessionsDir);
+        if (files.length > 0) {
+            const sessArchive = join(archiveDir, "sessions");
+            await mkdir(sessArchive, { recursive: true });
+            for (const file of files) {
+                await rename(join(sessionsDir, file), join(sessArchive, file));
+                result.archived.push(`sessions/${file}`);
+            }
+        }
+    }
+    catch {
+        // no sessions
+    }
+    return result;
+}
+export async function applyOnNewPlanPolicy(cwd) {
+    const config = await readConfig(cwd);
+    switch (config.cleanup.onNewPlan) {
+        case "archive":
+            return archiveCurrentData(cwd);
+        case "delete":
+            return cleanAll(cwd);
+        case "keep":
+        default:
+            return { removed: [], archived: [], skipped: ["policy: keep (no cleanup)"] };
+    }
+}

package/dist/core/cost-tracker.d.ts

@@ -30,4 +30,3 @@ export declare function estimateCost(model: string, inputTokens: number, outputT
 export declare function formatCost(cost: number): string;
 export declare function createTracker(): CostTracker;
 export { MODEL_PRICES };
-//# sourceMappingURL=cost-tracker.d.ts.map

package/dist/core/cost-tracker.js

@@ -38,4 +38,3 @@ export function createTracker() {
     };
 }
 export { MODEL_PRICES };
-//# sourceMappingURL=cost-tracker.js.map

package/dist/core/engine.d.ts

@@ -1,4 +1,3 @@
 import type { LoopState, StopHookInput, StopHookResult } from "./types.js";
 export declare function evaluateStopHook(input: StopHookInput, state: LoopState): StopHookResult;
 export declare function extractPromise(text: string, promisePhrase: string): boolean;
-//# sourceMappingURL=engine.d.ts.map

package/dist/core/engine.js

@@ -106,4 +106,3 @@ export function extractPromise(text, promisePhrase) {
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-//# sourceMappingURL=engine.js.map

package/dist/core/event-logger.d.ts

@@ -2,4 +2,3 @@ import type { LoopEvent } from "./types.js";
 export declare function getTracePath(cwd?: string): string;
 export declare function logEvents(events: LoopEvent[], metadata?: Record<string, unknown>, cwd?: string): Promise<void>;
 export declare function readTrace(cwd?: string): Promise<Record<string, unknown>[]>;
-//# sourceMappingURL=event-logger.d.ts.map