@graypark/loophaus 3.6.1 → 3.8.0

package/dist/commands/loop-stop.md

@@ -1,29 +1,21 @@
 ---
 description: "Stop active loop"
-allowed-tools:
-  [
-    "Bash(test -f .loophaus/state.json:*)",
-    "Bash(rm .loophaus/state.json)",
-    "Read(.loophaus/state.json)",
-    "Bash(test -f .claude/ralph-loop.local.md:*)",
-    "Bash(rm .claude/ralph-loop.local.md)",
-    "Read(.claude/ralph-loop.local.md)",
-  ]
+allowed-tools: ["Bash", "Read"]
 ---
 
 # /loop-stop — Stop Active Loop
 
-1. Check if `.loophaus/state.json` exists: `test -f .loophaus/state.json && echo "EXISTS" || echo "NOT_FOUND"`
-   - If not found, also check legacy path: `test -f .claude/ralph-loop.local.md && echo "LEGACY" || echo "NOT_FOUND"`
+1. Check if `.loophaus/state.json` exists using a cross-platform Node command.
+   - If not found, also check legacy path `.claude/ralph-loop.local.md`.
 
 2. **If NOT_FOUND** on both: Say "No active loop found."
 
 3. **If EXISTS** (.loophaus/state.json):
    - Read the file to get `currentIteration`
-   - Remove it: `rm .loophaus/state.json`
+   - Remove it with a cross-platform Node file command
    - Report: "Stopped loop at iteration N."
 
 4. **If LEGACY** (.claude/ralph-loop.local.md):
    - Read it to get the iteration field
-   - Remove it: `rm .claude/ralph-loop.local.md`
+   - Remove it with a cross-platform Node file command
    - Report: "Stopped loop at iteration N. (migrated from legacy path)"

package/dist/commands/loop.md

@@ -1,15 +1,24 @@
 ---
 description: "Start iterative dev loop"
 argument-hint: "PROMPT [--max-iterations N] [--completion-promise TEXT]"
-allowed-tools: ["Bash(${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh:*)"]
+allowed-tools: ["Bash"]
 ---
 
 # /loop — Start Iterative Dev Loop
 
+## Pre-flight
+
+Run `loophaus update-check` quietly before starting.
+If it reports an available update and auto-upgrade is enabled, run `loophaus upgrade` and continue.
+If it reports an available update and auto-upgrade is disabled, show one-line notice: `loophaus update available. Run: loophaus upgrade`.
+If the check fails or no update is available, continue silently.
+
+---
+
 Execute the setup script to initialize the loop:
 
 ```!
-"${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh" $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/setup-loop.mjs" $ARGUMENTS
 ```
 
 Work on the task. When you try to exit, the stop hook feeds the SAME PROMPT back for the next iteration. Your previous work persists in files and git history.

package/dist/commands/ralph-loop.md

@@ -1,7 +1,7 @@
 ---
 description: "Start Ralph Loop in current session"
 argument-hint: "PROMPT [--max-iterations N] [--completion-promise TEXT]"
-allowed-tools: ["Bash(${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh:*)"]
+allowed-tools: ["Bash"]
 hide-from-slash-command-tool: "true"
 ---
 
@@ -10,7 +10,7 @@ hide-from-slash-command-tool: "true"
 Execute the setup script to initialize the Ralph loop:
 
 ```!
-"${CLAUDE_PLUGIN_ROOT}/scripts/setup-ralph-loop.sh" $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/setup-loop.mjs" $ARGUMENTS
 ```
 
 Please work on the task. When you try to exit, the Ralph loop will feed the SAME PROMPT back to you for the next iteration. You'll see your previous work in files and git history, allowing you to iterate and improve.

package/dist/core/benchmark.js

@@ -1,10 +1,23 @@
 // 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 { readFile, appendFile, mkdir, readdir, stat } from "node:fs/promises";
 import { join, dirname } from "node:path";
-const execFileAsync = promisify(execFile);
+import { runCommand } from "../lib/runtime.js";
+async function getDirectorySizeBytes(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    let total = 0;
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySizeBytes(fullPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            total += (await stat(fullPath)).size;
+        }
+    }
+    return total;
+}
 export function scoreBenchmark(metrics) {
     const breakdown = {};
     // Tests: 0-10 based on pass rate
@@ -51,7 +64,7 @@ export async function runBenchmark(cwd) {
     // 1. Tests
     const testStart = Date.now();
     try {
-        const { stdout } = await execFileAsync("npx", ["vitest", "run", "--reporter=json"], { cwd: dir, timeout: 120_000 });
+        const { stdout } = await runCommand("npx", ["vitest", "run", "--reporter=json"], { cwd: dir, timeout: 120_000 });
         metrics.testTimeMs = Date.now() - testStart;
         try {
             const json = JSON.parse(stdout);
@@ -72,7 +85,7 @@ export async function runBenchmark(cwd) {
     }
     catch (err) {
         metrics.testTimeMs = Date.now() - testStart;
-        const output = err.stdout || "";
+        const output = err.stdout || err.stderr || "";
         const passMatch = output.match(/(\d+) passed/);
         if (passMatch)
             metrics.testsPassed = parseInt(passMatch[1]);
@@ -83,7 +96,7 @@ export async function runBenchmark(cwd) {
     }
     // 2. Typecheck
     try {
-        await execFileAsync("npx", ["tsc", "--noEmit"], { cwd: dir, timeout: 60_000 });
+        await runCommand("npx", ["tsc", "--noEmit"], { cwd: dir, timeout: 60_000 });
         metrics.typecheckErrors = 0;
     }
     catch (err) {
@@ -93,7 +106,7 @@ export async function runBenchmark(cwd) {
     }
     // 3. Build
     try {
-        await execFileAsync("npm", ["run", "build"], { cwd: dir, timeout: 60_000 });
+        await runCommand("npm", ["run", "build"], { cwd: dir, timeout: 60_000 });
         metrics.buildSuccess = true;
     }
     catch {
@@ -109,7 +122,7 @@ export async function runBenchmark(cwd) {
     catch {
         // Run coverage if summary doesn't exist
         try {
-            await execFileAsync("npx", ["vitest", "run", "--coverage"], { cwd: dir, timeout: 120_000 });
+            await runCommand("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);
@@ -124,9 +137,7 @@ export async function runBenchmark(cwd) {
         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;
+            metrics.pkgSizeKb = Math.ceil((await getDirectorySizeBytes(distDir)) / 1024);
         }
     }
     catch {
@@ -143,7 +154,7 @@ export async function logBenchmark(result, cwd) {
     await mkdir(dirname(benchPath), { recursive: true });
     let commitHash = "unknown";
     try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { timeout: 5_000 });
+        const { stdout } = await runCommand("git", ["rev-parse", "--short", "HEAD"], { timeout: 5_000 });
         commitHash = stdout.trim();
     }
     catch { /* not in git */ }
@@ -182,7 +193,7 @@ 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
+        const lines = raw.trim().split(/\r?\n/).slice(1); // skip header
         return lines.map(line => {
             const cols = line.split("\t");
             return {

package/dist/core/quality-scorer.js

@@ -1,10 +1,8 @@
 // core/quality-scorer.ts
 // Quality scoring for story implementations (autoresearch pattern: val_bpb -> quality score)
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-const execFileAsync = promisify(execFile);
+import { runCommand, runShellCommand } from "../lib/runtime.js";
 const CRITERIA = {
     tests: { weight: 3, max: 10 },
     typecheck: { weight: 2, max: 10 },
@@ -33,9 +31,10 @@ export function scoreStory(results) {
 }
 export async function evaluateStory(storyId, cwd, config = {}) {
     const results = {};
+    const splitLines = (value) => value.split(/\r?\n/);
     if (config.testCommand) {
         try {
-            await execFileAsync("sh", ["-c", config.testCommand], { cwd, timeout: 120_000 });
+            await runShellCommand(config.testCommand, { cwd, timeout: 120_000 });
             results.tests = 10;
         }
         catch {
@@ -44,27 +43,29 @@ export async function evaluateStory(storyId, cwd, config = {}) {
     }
     if (config.typecheckCommand) {
         try {
-            await execFileAsync("sh", ["-c", config.typecheckCommand], { cwd, timeout: 60_000 });
+            await runShellCommand(config.typecheckCommand, { cwd, timeout: 60_000 });
             results.typecheck = 10;
         }
         catch (err) {
-            const errorCount = (err.stdout || "").split("\n").filter(l => l.includes("error")).length;
+            const output = err.stdout || err.stderr || "";
+            const errorCount = splitLines(output).filter(line => line.includes("error")).length;
             results.typecheck = Math.max(0, 10 - errorCount);
         }
     }
     if (config.lintCommand) {
         try {
-            await execFileAsync("sh", ["-c", config.lintCommand], { cwd, timeout: 60_000 });
+            await runShellCommand(config.lintCommand, { cwd, timeout: 60_000 });
             results.lint = 10;
         }
         catch (err) {
-            const warnings = (err.stdout || "").split("\n").filter(l => l.includes("warning") || l.includes("error")).length;
+            const output = err.stdout || err.stderr || "";
+            const warnings = splitLines(output).filter(line => line.includes("warning") || line.includes("error")).length;
             results.lint = Math.max(0, 10 - warnings);
         }
     }
     if (config.verifyScript) {
         try {
-            await execFileAsync("sh", ["-c", config.verifyScript], { cwd, timeout: 60_000 });
+            await runShellCommand(config.verifyScript, { cwd, timeout: 60_000 });
             results.verify = 10;
         }
         catch {
@@ -72,8 +73,8 @@ export async function evaluateStory(storyId, cwd, config = {}) {
         }
     }
     try {
-        const { stdout } = await execFileAsync("git", ["diff", "--stat", "HEAD~1"], { cwd, timeout: 10_000 });
-        const lines = stdout.trim().split("\n");
+        const { stdout } = await runCommand("git", ["diff", "--stat", "HEAD~1"], { cwd, timeout: 10_000 });
+        const lines = stdout.trim().split(/\r?\n/);
         const lastLine = lines[lines.length - 1] || "";
         const match = lastLine.match(/(\d+) insertion.+?(\d+) deletion/);
         if (match) {
@@ -115,7 +116,7 @@ export async function readResults(cwd) {
     const tsvPath = join(cwd || process.cwd(), ".loophaus", "results.tsv");
     try {
         const raw = await readFile(tsvPath, "utf-8");
-        const lines = raw.trim().split("\n").slice(1);
+        const lines = raw.trim().split(/\r?\n/).slice(1);
         return lines.map(line => {
             const [storyId, attempt, score, status, description, commit] = line.split("\t");
             return { storyId, attempt: parseInt(attempt), score: parseInt(score), status, description, commit };

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,173 @@
+// core/update-checker.ts
+// npm registry version check with cache + snooze (gstack-style)
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { get } from "node:https";
+import { getLoophausHome } from "../lib/paths.js";
+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 getLoophausHome(cwd);
+}
+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(dirname(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/core/worktree.js

@@ -3,7 +3,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { mkdir, access } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 const execFileAsync = promisify(execFile);
 async function fileExists(p) {
     try {
@@ -72,7 +72,7 @@ export async function listWorktrees() {
         const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"]);
         const entries = [];
         let current = {};
-        for (const line of stdout.split("\n")) {
+        for (const line of stdout.split(/\r?\n/)) {
             if (line.startsWith("worktree ")) {
                 if (current.path)
                     entries.push(current);
@@ -95,7 +95,7 @@ export async function listWorktrees() {
         }
         const loophausDir = join(root, ".loophaus", "worktrees");
         return entries.filter(e => e.path && e.path.startsWith(loophausDir)).map(e => ({
-            name: e.path.split("/").pop(),
+            name: basename(e.path),
             path: e.path,
             branch: e.branch || "",
             head: e.head || "",

package/dist/hooks/stop-hook.mjs

@@ -5,12 +5,10 @@ import { getLastAssistantText, hasPendingStories } from "../core/io-helpers.js";
 import { read as readState, write as writeState } from "../store/state-store.js";
 import { logEvents } from "../core/event-logger.js";
 import { join } from "node:path";
+import { runShellCommand } from "../lib/runtime.js";
 
 async function runStoryTests(cwd) {
   const { readFile } = await import("node:fs/promises");
-  const { execFile } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execFileAsync = promisify(execFile);
   const prdPath = join(cwd, "prd.json");
 
   try {
@@ -21,10 +19,10 @@ async function runStoryTests(cwd) {
     for (const story of prd.userStories) {
       if (!story.testCommand || story.passes) continue;
       try {
-        await execFileAsync("sh", ["-c", story.testCommand], { cwd, timeout: 60_000 });
+        await runShellCommand(story.testCommand, { cwd, timeout: 60_000 });
         results.push({ storyId: story.id, passed: true });
       } catch (err) {
-        results.push({ storyId: story.id, passed: false, error: err.message });
+        results.push({ storyId: story.id, passed: false, error: err.stderr || err.message });
       }
     }
     return results;
@@ -55,10 +53,7 @@ async function main() {
   let verifyResult = null;
   if (state.verifyScript) {
     try {
-      const { execFile } = await import("node:child_process");
-      const { promisify } = await import("node:util");
-      const execFileAsync = promisify(execFile);
-      const { stdout: vOut } = await execFileAsync(state.verifyScript, [], { cwd, timeout: 30_000 });
+      const { stdout: vOut } = await runShellCommand(state.verifyScript, { cwd, timeout: 30_000 });
       verifyResult = { passed: true, output: vOut.trim() };
     } catch (err) {
       verifyResult = { passed: false, output: err.stderr || err.message };

package/dist/lib/paths.d.ts

@@ -1,5 +1,6 @@
 export declare function getPackageVersion(): string;
 export declare function isWindows(): boolean;
+export declare function getLoophausHome(homeDir?: string): string;
 export declare function getCodexHome(): string;
 export declare function getAgentsHome(): string;
 export declare function getAgentsSkillsDir(): string;

package/dist/lib/paths.js

@@ -20,6 +20,9 @@ export function getPackageVersion() {
 export function isWindows() {
     return process.platform === "win32";
 }
+export function getLoophausHome(homeDir) {
+    return join(homeDir || homedir(), ".loophaus");
+}
 // --- Codex CLI paths (legacy ~/.codex + new ~/.agents) ---
 export function getCodexHome() {
     if (process.env.CODEX_HOME) {

package/dist/lib/runtime.d.ts

@@ -0,0 +1,21 @@
+import type { ExecException } from "node:child_process";
+export interface CommandOptions {
+    cwd?: string;
+    timeout?: number;
+    env?: NodeJS.ProcessEnv;
+}
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+}
+export interface CommandError extends ExecException {
+    stdout?: string;
+    stderr?: string;
+}
+export declare function getDefaultShell(platform?: NodeJS.Platform): string;
+export declare function resolvePlatformCommand(command: string, platform?: NodeJS.Platform): string;
+export declare function requiresShellExecution(command: string, platform?: NodeJS.Platform): boolean;
+export declare function getGlobalBinDir(prefix: string, platform?: NodeJS.Platform): string;
+export declare function getGlobalBinaryPath(prefix: string, binaryName: string, platform?: NodeJS.Platform): string;
+export declare function runCommand(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>;
+export declare function runShellCommand(command: string, options?: CommandOptions): Promise<CommandResult>;

package/dist/lib/runtime.js

@@ -0,0 +1,77 @@
+import { exec, execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { isWindows } from "./paths.js";
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+const WINDOWS_BATCH_COMMANDS = new Set(["loophaus", "npm", "npx"]);
+export function getDefaultShell(platform = process.platform) {
+    if (platform === "win32") {
+        return process.env.ComSpec || "cmd.exe";
+    }
+    return process.env.SHELL || "/bin/sh";
+}
+export function resolvePlatformCommand(command, platform = process.platform) {
+    if (platform !== "win32")
+        return command;
+    if (/[/\\]/.test(command) || /\.[A-Za-z0-9]+$/.test(command))
+        return command;
+    if (WINDOWS_BATCH_COMMANDS.has(command))
+        return `${command}.cmd`;
+    return command;
+}
+export function requiresShellExecution(command, platform = process.platform) {
+    if (platform !== "win32")
+        return false;
+    return /\.(cmd|bat)$/i.test(command);
+}
+export function getGlobalBinDir(prefix, platform = process.platform) {
+    return platform === "win32" ? prefix : join(prefix, "bin");
+}
+export function getGlobalBinaryPath(prefix, binaryName, platform = process.platform) {
+    const suffix = platform === "win32" ? ".cmd" : "";
+    return join(getGlobalBinDir(prefix, platform), `${binaryName}${suffix}`);
+}
+function createBaseExecOptions(options) {
+    return {
+        cwd: options.cwd,
+        env: options.env,
+        timeout: options.timeout,
+        encoding: "utf8",
+        windowsHide: isWindows(),
+    };
+}
+function quoteWindowsArg(value) {
+    if (value.length === 0)
+        return "\"\"";
+    if (!/[\s"&|<>^()]/.test(value))
+        return value;
+    return `"${value.replace(/"/g, "\"\"")}"`;
+}
+function buildShellCommand(command, args) {
+    if (!isWindows()) {
+        return [command, ...args].map((part) => {
+            if (/^[A-Za-z0-9_./:=+-]+$/.test(part))
+                return part;
+            return `'${part.replace(/'/g, `'\\''`)}'`;
+        }).join(" ");
+    }
+    return [command, ...args].map(quoteWindowsArg).join(" ");
+}
+export async function runCommand(command, args = [], options = {}) {
+    const resolved = resolvePlatformCommand(command);
+    const execOptions = createBaseExecOptions(options);
+    if (requiresShellExecution(resolved)) {
+        return execAsync(buildShellCommand(resolved, args), {
+            ...execOptions,
+            shell: getDefaultShell(),
+        });
+    }
+    return execFileAsync(resolved, args, execOptions);
+}
+export async function runShellCommand(command, options = {}) {
+    return execAsync(command, {
+        ...createBaseExecOptions(options),
+        shell: getDefaultShell(),
+    });
+}

package/dist/package.json

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