@graypark/loophaus 3.6.1 → 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/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;

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/update-checker.d.ts

@@ -0,0 +1,30 @@
+export type UpdateStatus = "up_to_date" | "upgrade_available" | "snoozed" | "disabled" | "error";
+export interface UpdateCheckResult {
+    status: UpdateStatus;
+    current: string;
+    latest: string;
+    message?: string;
+}
+export interface UpdateCache {
+    checkedAt: string;
+    status: "up_to_date" | "upgrade_available";
+    current: string;
+    latest: string;
+}
+export interface SnoozeState {
+    version: string;
+    level: number;
+    snoozedAt: string;
+}
+export interface UpdateConfig {
+    updateCheck?: boolean;
+    autoUpgrade?: boolean;
+}
+export declare function compareVersions(current: string, latest: string): -1 | 0 | 1;
+export declare function isCacheFresh(cache: UpdateCache, nowMs: number): boolean;
+export declare function isSnoozed(snooze: SnoozeState, version: string, nowMs: number): boolean;
+export declare function getSnoozeHours(level: number): number;
+export declare function readConfig(cwd?: string): Promise<UpdateConfig>;
+export declare function checkForUpdate(currentVersion: string, homeCwd?: string): Promise<UpdateCheckResult>;
+export declare function snoozeUpdate(version: string, homeCwd?: string): Promise<SnoozeState>;
+export declare function getUpdateStatus(currentVersion: string, homeCwd?: string): Promise<string>;

package/dist/core/update-checker.js

@@ -0,0 +1,172 @@
+// core/update-checker.ts
+// npm registry version check with cache + snooze (gstack-style)
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { get } from "node:https";
+const REGISTRY_URL = "https://registry.npmjs.org/@graypark/loophaus/latest";
+const FETCH_TIMEOUT_MS = 5_000;
+// Cache TTL in minutes
+const TTL_UP_TO_DATE = 60;
+const TTL_UPGRADE_AVAILABLE = 720;
+// Snooze durations in hours
+const SNOOZE_HOURS = [24, 48, 168]; // level 1, 2, 3+
+function getLoophausDir(cwd) {
+    return join(cwd || process.env.HOME || "~", ".loophaus");
+}
+function getCachePath(cwd) {
+    return join(getLoophausDir(cwd), "update-cache.json");
+}
+function getSnoozePath(cwd) {
+    return join(getLoophausDir(cwd), "update-snoozed.json");
+}
+// --- Pure functions ---
+export function compareVersions(current, latest) {
+    const a = current.split(".").map(Number);
+    const b = latest.split(".").map(Number);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const av = a[i] || 0;
+        const bv = b[i] || 0;
+        if (av < bv)
+            return -1;
+        if (av > bv)
+            return 1;
+    }
+    return 0;
+}
+export function isCacheFresh(cache, nowMs) {
+    const age = (nowMs - new Date(cache.checkedAt).getTime()) / 60_000;
+    const ttl = cache.status === "up_to_date" ? TTL_UP_TO_DATE : TTL_UPGRADE_AVAILABLE;
+    return age < ttl;
+}
+export function isSnoozed(snooze, version, nowMs) {
+    if (snooze.version !== version)
+        return false; // new version resets snooze
+    const level = Math.min(snooze.level, SNOOZE_HOURS.length) - 1;
+    const durationMs = (SNOOZE_HOURS[level] ?? SNOOZE_HOURS[SNOOZE_HOURS.length - 1]) * 3600_000;
+    const elapsed = nowMs - new Date(snooze.snoozedAt).getTime();
+    return elapsed < durationMs;
+}
+export function getSnoozeHours(level) {
+    const idx = Math.min(level, SNOOZE_HOURS.length) - 1;
+    return SNOOZE_HOURS[idx] ?? SNOOZE_HOURS[SNOOZE_HOURS.length - 1];
+}
+// --- I/O functions ---
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeJson(path, data) {
+    await mkdir(join(path, ".."), { recursive: true });
+    await writeFile(path, JSON.stringify(data, null, 2), "utf-8");
+}
+async function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), FETCH_TIMEOUT_MS);
+        try {
+            const req = get(REGISTRY_URL, { timeout: FETCH_TIMEOUT_MS }, (res) => {
+                let data = "";
+                res.on("data", (chunk) => { data += chunk.toString(); });
+                res.on("end", () => {
+                    clearTimeout(timer);
+                    try {
+                        const pkg = JSON.parse(data);
+                        resolve(pkg.version || null);
+                    }
+                    catch {
+                        resolve(null);
+                    }
+                });
+            });
+            req.on("error", () => { clearTimeout(timer); resolve(null); });
+        }
+        catch {
+            clearTimeout(timer);
+            resolve(null);
+        }
+    });
+}
+export async function readConfig(cwd) {
+    const configPath = join(cwd || process.cwd(), ".loophaus", "config.json");
+    try {
+        const raw = await readFile(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export async function checkForUpdate(currentVersion, homeCwd) {
+    const dir = getLoophausDir(homeCwd);
+    const cachePath = getCachePath(homeCwd);
+    const snoozePath = getSnoozePath(homeCwd);
+    const now = Date.now();
+    // Check config
+    const config = await readConfig(homeCwd);
+    if (config.updateCheck === false) {
+        return { status: "disabled", current: currentVersion, latest: currentVersion };
+    }
+    // Check cache
+    const cache = await readJson(cachePath);
+    if (cache && isCacheFresh(cache, now)) {
+        if (cache.status === "up_to_date") {
+            return { status: "up_to_date", current: currentVersion, latest: cache.latest };
+        }
+        // Cache says upgrade available — check snooze
+        const snooze = await readJson(snoozePath);
+        if (snooze && isSnoozed(snooze, cache.latest, now)) {
+            const hours = getSnoozeHours(snooze.level);
+            return { status: "snoozed", current: currentVersion, latest: cache.latest, message: `Snoozed for ${hours}h (level ${snooze.level})` };
+        }
+        return { status: "upgrade_available", current: currentVersion, latest: cache.latest };
+    }
+    // Fetch from registry
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        return { status: "error", current: currentVersion, latest: currentVersion, message: "Could not reach npm registry" };
+    }
+    const cmp = compareVersions(currentVersion, latest);
+    const status = cmp < 0 ? "upgrade_available" : "up_to_date";
+    // Write cache
+    await mkdir(dir, { recursive: true });
+    const newCache = { checkedAt: new Date().toISOString(), status, current: currentVersion, latest };
+    await writeJson(cachePath, newCache);
+    if (status === "upgrade_available") {
+        // Check snooze for the new version
+        const snooze = await readJson(snoozePath);
+        if (snooze && isSnoozed(snooze, latest, now)) {
+            const hours = getSnoozeHours(snooze.level);
+            return { status: "snoozed", current: currentVersion, latest, message: `Snoozed for ${hours}h (level ${snooze.level})` };
+        }
+    }
+    return { status, current: currentVersion, latest };
+}
+export async function snoozeUpdate(version, homeCwd) {
+    const snoozePath = getSnoozePath(homeCwd);
+    const existing = await readJson(snoozePath);
+    let level = 1;
+    if (existing && existing.version === version) {
+        level = existing.level + 1;
+    }
+    const snooze = {
+        version,
+        level,
+        snoozedAt: new Date().toISOString(),
+    };
+    await writeJson(snoozePath, snooze);
+    return snooze;
+}
+export async function getUpdateStatus(currentVersion, homeCwd) {
+    const result = await checkForUpdate(currentVersion, homeCwd);
+    switch (result.status) {
+        case "up_to_date": return "";
+        case "upgrade_available": return `UPGRADE_AVAILABLE ${result.current} ${result.latest}`;
+        case "snoozed": return "";
+        case "disabled": return "";
+        case "error": return "";
+        default: return "";
+    }
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graypark/loophaus",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "type": "module",
   "description": "loophaus — Control plane for coding agents. Iterative dev loops with multi-agent orchestration.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graypark/loophaus",
-  "version": "3.6.1",
+  "version": "3.7.0",
   "type": "module",
   "description": "loophaus — Control plane for coding agents. Iterative dev loops with multi-agent orchestration.",
   "license": "MIT",