@graypark/loophaus 3.6.0 → 3.7.0

package/commands/loop-plan.md

@@ -11,6 +11,53 @@ The user runs `/loop-plan` once and gets a single merged branch with all work do
 
 ---
 
+## Pre-flight: Update Check
+
+Run this silently before starting:
+
+```bash
+_UPDATE=$(loophaus update-check 2>/dev/null | grep "UPGRADE_AVAILABLE" || true)
+```
+
+If `_UPDATE` contains `UPGRADE_AVAILABLE`:
+1. Show: `loophaus update available: v{current} → v{latest}`
+2. Ask user:
+   - **A) Upgrade now** → run `loophaus upgrade`, then continue
+   - **B) Always auto-upgrade** → run `loophaus config set autoUpgrade true && loophaus upgrade`, then continue
+   - **C) Not now** → run `loophaus config set updateCheck snoozed` silently, then continue
+   - **D) Never ask again** → run `loophaus config set updateCheck false`, then continue
+
+If auto-upgrade is enabled (`loophaus config get autoUpgrade` returns `true`):
+- Skip prompt, run `loophaus upgrade` silently, continue.
+
+If no update or check fails: continue silently (never block the user).
+
+## Pre-flight: Skill Routing Check
+
+Check if the project has a CLAUDE.md with loophaus skill routing:
+
+```bash
+CLAUDE_MD="$(pwd)/CLAUDE.md"
+ROUTING_MARKER=".loophaus/routing-offered.json"
+```
+
+If CLAUDE.md exists but has no `## loophaus skill routing` section, AND routing hasn't been offered before:
+1. Suggest adding this section to CLAUDE.md:
+   ```markdown
+   ## loophaus skill routing
+   
+   | User intent | Route to |
+   |-------------|----------|
+   | Feature implementation, refactoring, multi-step task | `/loophaus:loop-plan` |
+   | "start the loop", "continue implementing" | `/loophaus:loop` |
+   | "stop the loop", "cancel" | `/loophaus:loop-stop` |
+   | "what's the status", "how far along" | `/loophaus:loop-pulse` |
+   ```
+2. If user agrees, add the section to CLAUDE.md
+3. Write `{ "offeredAt": "<ISO date>" }` to `.loophaus/routing-offered.json` so we don't ask again
+
+If CLAUDE.md doesn't exist or routing already offered: skip silently.
+
 ## Phase 0: Cleanup Previous Data
 
 Before starting a new plan, apply the cleanup policy from `.loophaus/config.json`:

package/commands/loop.md

@@ -6,6 +6,17 @@ allowed-tools: ["Bash(${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh:*)"]
 
 # /loop — Start Iterative Dev Loop
 
+## Pre-flight
+
+```bash
+_UPDATE=$(loophaus update-check 2>/dev/null | grep "UPGRADE_AVAILABLE" || true)
+```
+If update available and autoUpgrade enabled: run `loophaus upgrade` silently.
+If update available and not auto: show one-line notice `loophaus v{new} available. Run: loophaus upgrade`.
+Otherwise: continue silently.
+
+---
+
 Execute the setup script to initialize the loop:
 
 ```!

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,12 +16,13 @@ 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",
+    "--all", "--traces", "--sessions", "--results", "--before", "--config", "--quiet",
 ]);
 const VALID_COMMANDS = [
     "install", "uninstall", "status", "stats", "loops", "watch",
     "replay", "compare", "worktree", "parallel", "quality",
-    "sessions", "resume", "benchmark", "clean", "help",
+    "sessions", "resume", "benchmark", "clean", "config",
+    "update-check", "upgrade", "help",
 ];
 function validateFlags() {
     for (const arg of args) {
@@ -114,6 +115,9 @@ Usage:
   npx @graypark/loophaus quality [--story US-001]
   npx @graypark/loophaus benchmark
   npx @graypark/loophaus clean [--all|--traces|--sessions|--results] [--before DATE]
+  npx @graypark/loophaus config [list|get|set] [key] [value]
+  npx @graypark/loophaus update-check
+  npx @graypark/loophaus upgrade
   npx @graypark/loophaus sessions
   npx @graypark/loophaus resume <session-id>
   npx @graypark/loophaus --version
@@ -156,6 +160,11 @@ async function detectHosts() {
     return hosts;
 }
 async function runInstall() {
+    const { getPackageVersion } = await import("../lib/paths.js");
+    const version = getPackageVersion();
+    const quiet = args.includes("--quiet");
+    const loophausDir = join(process.env.HOME || "~", ".loophaus");
+    const welcomePath = join(loophausDir, ".welcome-seen");
     let targets = [];
     if (host) {
         targets = [host];
@@ -192,6 +201,57 @@ async function runInstall() {
             s?.stop();
         }
     }
+    if (quiet || dryRun)
+        return;
+    // First-run welcome or upgrade notice
+    const { mkdir: mk, writeFile: wf, readFile: rf } = await import("node:fs/promises");
+    await mk(loophausDir, { recursive: true });
+    let isFirstRun = false;
+    try {
+        const seen = await rf(welcomePath, "utf-8");
+        // Existing install — show What's New if version changed
+        if (seen.trim() !== version) {
+            await wf(welcomePath, version, "utf-8");
+            try {
+                const changelog = await rf(join(__dirname, "..", "CHANGELOG.md"), "utf-8");
+                const firstEntry = changelog.match(/## \[[\d.]+\][^\n]*\n([\s\S]*?)(?=\n## \[|$)/);
+                if (firstEntry) {
+                    console.log(`\n  \x1b[36mWhat's New in v${version}:\x1b[0m`);
+                    const lines = firstEntry[1].trim().split("\n").slice(0, 8);
+                    for (const l of lines)
+                        console.log(`  ${l}`);
+                }
+            }
+            catch { /* no CHANGELOG */ }
+        }
+    }
+    catch {
+        isFirstRun = true;
+        await wf(welcomePath, version, "utf-8");
+    }
+    if (isFirstRun) {
+        console.log(`
+  \x1b[36m\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\x1b[0m
+  Welcome to \x1b[1mloophaus\x1b[0m v${version}
+
+  Control plane for coding agents.
+  Iterative dev loops with quality verification.
+
+  Quick start:
+    /loop-plan <describe your task>
+
+  Commands:
+    /loop-plan   Interview → PRD → implement → verify
+    /loop        Start loop with existing PRD
+    /loop-pulse  Check progress
+    /loop-stop   Cancel loop
+
+  CLI:
+    loophaus benchmark    Project quality score
+    loophaus config list  View settings
+    loophaus upgrade      Update to latest
+  \x1b[36m\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\x1b[0m`);
+    }
 }
 async function runUninstall() {
     if (host === "claude-code" || args.includes("--claude")) {
@@ -683,6 +743,140 @@ Options:
         console.log("  Nothing to clean.");
     }
 }
+async function runUpdateCheck() {
+    const { getPackageVersion } = await import("../lib/paths.js");
+    const { checkForUpdate } = await import("../core/update-checker.js");
+    const current = getPackageVersion();
+    const result = await checkForUpdate(current);
+    console.log("Update Check");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  Current:  v${result.current}`);
+    console.log(`  Latest:   v${result.latest}`);
+    console.log(`  Status:   ${result.status}`);
+    if (result.message)
+        console.log(`  Note:     ${result.message}`);
+    if (result.status === "upgrade_available") {
+        console.log(`\n  \x1b[33mUpdate available: v${result.current} → v${result.latest}\x1b[0m`);
+        console.log(`  Run: loophaus upgrade`);
+    }
+}
+async function runUpgrade() {
+    const { getPackageVersion } = await import("../lib/paths.js");
+    const { checkForUpdate } = await import("../core/update-checker.js");
+    const { execFile: ef } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execFileAsync = promisify(ef);
+    const current = getPackageVersion();
+    const result = await checkForUpdate(current);
+    if (result.status === "up_to_date") {
+        console.log(`Already on latest version: v${current}`);
+        return;
+    }
+    if (result.status !== "upgrade_available" && result.status !== "snoozed") {
+        console.log(`No update available (status: ${result.status})`);
+        return;
+    }
+    console.log(`Upgrading loophaus: v${result.current} → v${result.latest}`);
+    const s = spinner("Installing...");
+    try {
+        await execFileAsync("npm", ["install", "-g", `@graypark/loophaus@${result.latest}`], { timeout: 120_000 });
+        s.stop();
+        console.log(`\u2714 Installed v${result.latest}`);
+        const s2 = spinner("Reinstalling plugins...");
+        try {
+            await execFileAsync("loophaus", ["install", "--force"], { timeout: 60_000 });
+            s2.stop();
+            console.log("\u2714 Plugins reinstalled");
+        }
+        catch {
+            s2.stop();
+            console.log("  Note: Run 'loophaus install --force' to update plugins.");
+        }
+        console.log(`\n  Upgrade complete: v${result.current} → v${result.latest}`);
+    }
+    catch (err) {
+        s.stop();
+        console.error(`\u2718 Upgrade failed: ${err.message}`);
+        console.error("  Try manually: npm install -g @graypark/loophaus@latest");
+    }
+}
+async function runConfigCmd() {
+    const { readConfig, writeConfig } = await import("../core/cleanup.js");
+    const sub = args[1];
+    const KNOWN_KEYS = {
+        "cleanup.onNewPlan": "Policy when /loop-plan starts: archive | delete | keep",
+        "cleanup.traceRetentionDays": "Days to keep trace data",
+        "cleanup.sessionRetentionDays": "Days to keep session checkpoints",
+        "updateCheck": "Check for updates on skill execution: true | false",
+        "autoUpgrade": "Auto-upgrade without prompting: true | false",
+    };
+    if (!sub || sub === "list") {
+        const config = await readConfig();
+        console.log("Configuration (.loophaus/config.json)");
+        console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+        for (const [key, desc] of Object.entries(KNOWN_KEYS)) {
+            const val = getNestedValue(config, key);
+            console.log(`  ${key.padEnd(30)} ${String(val ?? "(default)").padEnd(12)} ${desc}`);
+        }
+        console.log(`\nUsage: loophaus config set <key> <value>`);
+        return;
+    }
+    if (sub === "get") {
+        const key = args[2];
+        if (!key) {
+            console.log("Usage: loophaus config get <key>");
+            return;
+        }
+        const config = await readConfig();
+        const val = getNestedValue(config, key);
+        console.log(val !== undefined ? String(val) : "(not set)");
+        return;
+    }
+    if (sub === "set") {
+        const key = args[3] ? args[2] : args[2];
+        const value = args[3] || args[3];
+        if (!key || value === undefined) {
+            console.log("Usage: loophaus config set <key> <value>");
+            return;
+        }
+        const rawValue = args[3];
+        if (!key || rawValue === undefined) {
+            console.log("Usage: loophaus config set <key> <value>");
+            return;
+        }
+        if (!KNOWN_KEYS[key]) {
+            console.log(`Warning: '${key}' is not a known config key.`);
+        }
+        const config = await readConfig();
+        const parsed = rawValue === "true" ? true : rawValue === "false" ? false : isNaN(Number(rawValue)) ? rawValue : Number(rawValue);
+        setNestedValue(config, key, parsed);
+        await writeConfig(config);
+        console.log(`Set ${key} = ${String(parsed)}`);
+        return;
+    }
+    console.log("Usage: loophaus config [list|get|set] [key] [value]");
+}
+function getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== "object")
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    const parts = path.split(".");
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (!(parts[i] in current) || typeof current[parts[i]] !== "object") {
+            current[parts[i]] = {};
+        }
+        current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = value;
+}
 try {
     switch (command) {
         case "install":
@@ -724,6 +918,15 @@ try {
         case "clean":
             await runCleanCmd();
             break;
+        case "config":
+            await runConfigCmd();
+            break;
+        case "update-check":
+            await runUpdateCheck();
+            break;
+        case "upgrade":
+            await runUpgrade();
+            break;
         case "sessions":
             await runSessions();
             break;
@@ -761,4 +964,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,53 @@ The user runs `/loop-plan` once and gets a single merged branch with all work do
 
 ---
 
+## Pre-flight: Update Check
+
+Run this silently before starting:
+
+```bash
+_UPDATE=$(loophaus update-check 2>/dev/null | grep "UPGRADE_AVAILABLE" || true)
+```
+
+If `_UPDATE` contains `UPGRADE_AVAILABLE`:
+1. Show: `loophaus update available: v{current} → v{latest}`
+2. Ask user:
+   - **A) Upgrade now** → run `loophaus upgrade`, then continue
+   - **B) Always auto-upgrade** → run `loophaus config set autoUpgrade true && loophaus upgrade`, then continue
+   - **C) Not now** → run `loophaus config set updateCheck snoozed` silently, then continue
+   - **D) Never ask again** → run `loophaus config set updateCheck false`, then continue
+
+If auto-upgrade is enabled (`loophaus config get autoUpgrade` returns `true`):
+- Skip prompt, run `loophaus upgrade` silently, continue.
+
+If no update or check fails: continue silently (never block the user).
+
+## Pre-flight: Skill Routing Check
+
+Check if the project has a CLAUDE.md with loophaus skill routing:
+
+```bash
+CLAUDE_MD="$(pwd)/CLAUDE.md"
+ROUTING_MARKER=".loophaus/routing-offered.json"
+```
+
+If CLAUDE.md exists but has no `## loophaus skill routing` section, AND routing hasn't been offered before:
+1. Suggest adding this section to CLAUDE.md:
+   ```markdown
+   ## loophaus skill routing
+   
+   | User intent | Route to |
+   |-------------|----------|
+   | Feature implementation, refactoring, multi-step task | `/loophaus:loop-plan` |
+   | "start the loop", "continue implementing" | `/loophaus:loop` |
+   | "stop the loop", "cancel" | `/loophaus:loop-stop` |
+   | "what's the status", "how far along" | `/loophaus:loop-pulse` |
+   ```
+2. If user agrees, add the section to CLAUDE.md
+3. Write `{ "offeredAt": "<ISO date>" }` to `.loophaus/routing-offered.json` so we don't ask again
+
+If CLAUDE.md doesn't exist or routing already offered: skip silently.
+
 ## Phase 0: Cleanup Previous Data
 
 Before starting a new plan, apply the cleanup policy from `.loophaus/config.json`:

package/dist/commands/loop.md

@@ -6,6 +6,17 @@ allowed-tools: ["Bash(${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh:*)"]
 
 # /loop — Start Iterative Dev Loop
 
+## Pre-flight
+
+```bash
+_UPDATE=$(loophaus update-check 2>/dev/null | grep "UPGRADE_AVAILABLE" || true)
+```
+If update available and autoUpgrade enabled: run `loophaus upgrade` silently.
+If update available and not auto: show one-line notice `loophaus v{new} available. Run: loophaus upgrade`.
+Otherwise: continue silently.
+
+---
+
 Execute the setup script to initialize the loop:
 
 ```!

package/dist/core/benchmark.d.ts

@@ -36,4 +36,3 @@ export declare function scoreBenchmark(metrics: BenchmarkMetrics): BenchmarkResu
 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[]>;
-//# sourceMappingURL=benchmark.d.ts.map

package/dist/core/benchmark.js

@@ -205,4 +205,3 @@ export async function readBenchmarkHistory(cwd) {
         return [];
     }
 }
-//# sourceMappingURL=benchmark.js.map

package/dist/core/cleanup.d.ts

@@ -21,4 +21,3 @@ export declare function cleanSessions(options?: {
 export declare function cleanAll(cwd?: string): Promise<CleanResult>;
 export declare function archiveCurrentData(cwd?: string): Promise<CleanResult>;
 export declare function applyOnNewPlanPolicy(cwd?: string): Promise<CleanResult>;
-//# sourceMappingURL=cleanup.d.ts.map

package/dist/core/cleanup.js

@@ -142,4 +142,3 @@ export async function applyOnNewPlanPolicy(cwd) {
             return { removed: [], archived: [], skipped: ["policy: keep (no cleanup)"] };
     }
 }
-//# sourceMappingURL=cleanup.js.map

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

package/dist/core/event-logger.js

@@ -45,4 +45,3 @@ export async function readTrace(cwd) {
         return [];
     }
 }
-//# sourceMappingURL=event-logger.js.map

package/dist/core/events.d.ts

@@ -31,4 +31,3 @@ export interface EventSummary {
     lastTs: string | undefined;
 }
 export declare function summarizeEvents(events: LoopEvent[]): EventSummary;
-//# sourceMappingURL=events.d.ts.map

package/dist/core/events.js

@@ -41,4 +41,3 @@ export function summarizeEvents(events) {
     const durationMs = first && last ? new Date(last.ts).getTime() - new Date(first.ts).getTime() : 0;
     return { counts, total: events.length, durationMs, firstTs: first?.ts, lastTs: last?.ts };
 }
-//# sourceMappingURL=events.js.map

package/dist/core/io-helpers.d.ts

@@ -1,3 +1,2 @@
 export declare function getLastAssistantText(transcriptPath?: string): Promise<string>;
 export declare function hasPendingStories(cwd?: string): Promise<boolean>;
-//# sourceMappingURL=io-helpers.d.ts.map

package/dist/core/io-helpers.js

@@ -62,4 +62,3 @@ export async function hasPendingStories(cwd) {
         throw new Error(`Failed to read prd.json at ${prdPath}: ${err.message}`);
     }
 }
-//# sourceMappingURL=io-helpers.js.map

package/dist/core/loop-registry.d.ts

@@ -7,4 +7,3 @@ interface LoopEntry {
 export declare function listLoops(cwd?: string): Promise<LoopEntry[]>;
 export declare function getLoop(name: string, cwd?: string): Promise<LoopEntry | null>;
 export {};
-//# sourceMappingURL=loop-registry.d.ts.map

package/dist/core/loop-registry.js

@@ -34,4 +34,3 @@ export async function getLoop(name, cwd) {
     const loops = await listLoops(cwd);
     return loops.find(l => l.name === name) || null;
 }
-//# sourceMappingURL=loop-registry.js.map

package/dist/core/merge-strategy.d.ts

@@ -4,4 +4,3 @@ export declare function mergeSequential(branches: string[], targetBranch?: strin
 export declare function mergeSquash(branches: string[]): Promise<MergeResult[]>;
 export declare function mergeCherryPick(branches: string[]): Promise<MergeResult[]>;
 export declare function merge(strategy: string, branches: string[], targetBranch?: string): Promise<MergeResult[]>;
-//# sourceMappingURL=merge-strategy.d.ts.map

package/dist/core/merge-strategy.js

@@ -79,4 +79,3 @@ export async function merge(strategy, branches, targetBranch) {
         default: throw new Error(`Unknown merge strategy: ${strategy}`);
     }
 }
-//# sourceMappingURL=merge-strategy.js.map

package/dist/core/parallel-runner.d.ts

@@ -29,4 +29,3 @@ export declare function runParallel({ prdPath, count, baseBranch, cwd }: {
 }): Promise<ParallelResult>;
 export declare function cleanupParallel(): Promise<CleanupResult[]>;
 export {};
-//# sourceMappingURL=parallel-runner.d.ts.map

package/dist/core/parallel-runner.js

@@ -85,4 +85,3 @@ export async function cleanupParallel() {
     }
     return results;
 }
-//# sourceMappingURL=parallel-runner.js.map

package/dist/core/policy.d.ts

@@ -19,4 +19,3 @@ declare const DEFAULT_POLICY: Policy;
 export declare function loadPolicy(cwd?: string): Promise<Policy>;
 export declare function evaluatePolicy(policy: Policy, state: PolicyState, context?: PolicyContext): PolicyResult;
 export { DEFAULT_POLICY };
-//# sourceMappingURL=policy.d.ts.map

package/dist/core/policy.js

@@ -51,4 +51,3 @@ export function evaluatePolicy(policy, state, context = {}) {
     };
 }
 export { DEFAULT_POLICY };
-//# sourceMappingURL=policy.js.map

package/dist/core/quality-scorer.d.ts

@@ -37,4 +37,3 @@ interface ResultEntry {
 }
 export declare function readResults(cwd?: string): Promise<ResultEntry[]>;
 export {};
-//# sourceMappingURL=quality-scorer.d.ts.map

package/dist/core/quality-scorer.js

@@ -125,4 +125,3 @@ export async function readResults(cwd) {
         return [];
     }
 }
-//# sourceMappingURL=quality-scorer.js.map

package/dist/core/refine-loop.d.ts

@@ -13,4 +13,3 @@ export declare function shouldKeep(newScore: number, baselineScore: number): boo
 export declare function generateFeedback(evaluation: Evaluation, previousAttempts?: PreviousAttempt[]): string;
 export declare function identifyRefinementTargets(evaluations: Evaluation[], threshold?: number): Evaluation[];
 export {};
-//# sourceMappingURL=refine-loop.d.ts.map

package/dist/core/refine-loop.js

@@ -23,4 +23,3 @@ export function identifyRefinementTargets(evaluations, threshold = 80) {
         .filter(e => e.score < threshold)
         .sort((a, b) => a.score - b.score);
 }
-//# sourceMappingURL=refine-loop.js.map

package/dist/core/session.d.ts

@@ -24,4 +24,3 @@ interface ResumedState {
 }
 export declare function resumeSession(sessionId: string, cwd?: string): Promise<ResumedState | null>;
 export {};
-//# sourceMappingURL=session.d.ts.map

package/dist/core/session.js

@@ -64,4 +64,3 @@ export async function resumeSession(sessionId, cwd) {
     await write(state, cwd, checkpoint.name);
     return state;
 }
-//# sourceMappingURL=session.js.map

package/dist/core/trace-analyzer.d.ts

@@ -25,4 +25,3 @@ export interface ReplayEvent extends LoopEvent {
 export declare function analyzeTrace(events: LoopEvent[]): TraceAnalysis;
 export declare function compareTraces(trace1: LoopEvent[], trace2: LoopEvent[]): TraceComparison;
 export declare function replayTrace(events: LoopEvent[], speed?: number): ReplayEvent[];
-//# sourceMappingURL=trace-analyzer.d.ts.map

package/dist/core/trace-analyzer.js

@@ -43,4 +43,3 @@ export function replayTrace(events, speed = 1) {
         relativeMs: Math.round((new Date(e.ts).getTime() - firstTs) / speed),
     }));
 }
-//# sourceMappingURL=trace-analyzer.js.map

package/dist/core/types.d.ts

@@ -96,4 +96,3 @@ export interface CostEstimate {
     totalCost: number;
     model: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map