@graypark/loophaus 3.2.0 → 3.3.0

package/bin/loophaus.mjs

@@ -46,6 +46,8 @@ Usage:
   npx @graypark/loophaus loops
   npx @graypark/loophaus worktree <create|remove|list>
   npx @graypark/loophaus parallel <prd.json> [--count N] [--base branch]
+  npx @graypark/loophaus sessions
+  npx @graypark/loophaus resume <session-id>
   npx @graypark/loophaus --version
 
 Hosts:
@@ -408,6 +410,28 @@ async function runWorktree() {
   }
 }
 
+async function runSessions() {
+  const { listSessions } = await import("../core/session.mjs");
+  const sessions = await listSessions();
+  if (sessions.length === 0) { console.log("No saved sessions."); return; }
+  console.log("Sessions");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const s of sessions) {
+    const age = Math.round((Date.now() - new Date(s.savedAt).getTime()) / 60000);
+    console.log(`  ${s.sessionId}  iter=${s.currentIteration || 0}  ${age}m ago`);
+  }
+}
+
+async function runResume() {
+  const id = args[1];
+  if (!id) { console.log("Usage: loophaus resume <session-id>"); return; }
+  const { resumeSession } = await import("../core/session.mjs");
+  const state = await resumeSession(id);
+  if (!state) { console.log(`Session not found: ${id}`); return; }
+  console.log(`Resumed session ${id} at iteration ${state.currentIteration}`);
+  console.log(`Loop is now active. The stop hook will continue from here.`);
+}
+
 async function runParallelCmd() {
   const prdPath = args[1] || "prd.json";
   const count = parseInt(getFlag("--count") || "2", 10);
@@ -436,6 +460,8 @@ try {
     case "compare": await runCompare(); break;
     case "worktree": await runWorktree(); break;
     case "parallel": await runParallelCmd(); break;
+    case "sessions": await runSessions(); break;
+    case "resume": await runResume(); break;
     default:
       if (command.startsWith("-")) {
         await runInstall();

package/core/engine.mjs

@@ -27,6 +27,19 @@ export function evaluateStopHook(input, state) {
     };
   }
 
+  if (input.policy_result && input.policy_result.shouldStop) {
+    nextState.active = false;
+    events.push({ event: "stop", reason: "policy_violation", violations: input.policy_result.violations });
+    const reasons = input.policy_result.violations.map(v => `${v.type}: ${v.current}/${v.limit}`).join(", ");
+    return {
+      decision: "allow",
+      nextState,
+      events,
+      output: null,
+      message: `Loop: policy violation (${reasons}).`,
+    };
+  }
+
   if (nextState.completionPromise && input.last_assistant_text) {
     if (extractPromise(input.last_assistant_text, nextState.completionPromise)) {
       nextState.active = false;
@@ -57,6 +70,16 @@ export function evaluateStopHook(input, state) {
     events.push({ event: "verify_failed", script: nextState.verifyScript, output: input.verify_result.output || "" });
   }
 
+  if (input.test_results && input.test_results.length > 0) {
+    const allPassed = input.test_results.every(r => r.passed);
+    if (allPassed) {
+      events.push({ event: "test_result", status: "all_passed", results: input.test_results });
+    } else {
+      const failed = input.test_results.filter(r => !r.passed);
+      events.push({ event: "test_result", status: "some_failed", failed: failed.map(f => f.storyId) });
+    }
+  }
+
   if (input.stop_hook_active === true) {
     if (!input.has_pending_stories) {
       nextState.active = false;

package/core/policy.mjs

@@ -0,0 +1,58 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const DEFAULT_POLICY = {
+  id: "default",
+  conditions: [
+    { type: "max_iterations", value: 20 },
+  ],
+};
+
+export async function loadPolicy(cwd) {
+  const policyPath = join(cwd || process.cwd(), ".loophaus", "policy.json");
+  try {
+    const raw = await readFile(policyPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return DEFAULT_POLICY;
+  }
+}
+
+export function evaluatePolicy(policy, state, context = {}) {
+  const violations = [];
+
+  for (const condition of policy.conditions || []) {
+    switch (condition.type) {
+      case "max_iterations":
+        if (state.currentIteration > condition.value) {
+          violations.push({ type: "max_iterations", limit: condition.value, current: state.currentIteration });
+        }
+        break;
+      case "max_cost":
+        if (context.totalCost && context.totalCost > condition.value) {
+          violations.push({ type: "max_cost", limit: condition.value, current: context.totalCost });
+        }
+        break;
+      case "max_time_minutes":
+        if (state.startedAt) {
+          const elapsed = (Date.now() - new Date(state.startedAt).getTime()) / 60000;
+          if (elapsed > condition.value) {
+            violations.push({ type: "max_time_minutes", limit: condition.value, current: Math.round(elapsed) });
+          }
+        }
+        break;
+      case "max_errors":
+        if (context.errorCount && context.errorCount > condition.value) {
+          violations.push({ type: "max_errors", limit: condition.value, current: context.errorCount });
+        }
+        break;
+    }
+  }
+
+  return {
+    shouldStop: violations.length > 0,
+    violations,
+  };
+}
+
+export { DEFAULT_POLICY };

package/core/session.mjs

@@ -0,0 +1,66 @@
+import { readFile, writeFile, readdir, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+function getSessionsDir(cwd) {
+  return join(cwd || process.cwd(), ".loophaus", "sessions");
+}
+
+export async function saveCheckpoint(sessionId, data, cwd) {
+  const dir = getSessionsDir(cwd);
+  await mkdir(dir, { recursive: true });
+  const checkpoint = {
+    sessionId,
+    savedAt: new Date().toISOString(),
+    ...data,
+  };
+  await writeFile(join(dir, `${sessionId}.json`), JSON.stringify(checkpoint, null, 2), "utf-8");
+  return checkpoint;
+}
+
+export async function loadCheckpoint(sessionId, cwd) {
+  const dir = getSessionsDir(cwd);
+  try {
+    const raw = await readFile(join(dir, `${sessionId}.json`), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function listSessions(cwd) {
+  const dir = getSessionsDir(cwd);
+  try {
+    const files = await readdir(dir);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await readFile(join(dir, file), "utf-8");
+        const data = JSON.parse(raw);
+        sessions.push(data);
+      } catch { /* skip malformed */ }
+    }
+    return sessions.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+  } catch {
+    return [];
+  }
+}
+
+export async function resumeSession(sessionId, cwd) {
+  const checkpoint = await loadCheckpoint(sessionId, cwd);
+  if (!checkpoint) return null;
+
+  const { write } = await import("../store/state-store.mjs");
+  const state = {
+    active: true,
+    prompt: checkpoint.prompt || "",
+    completionPromise: checkpoint.completionPromise || "TADA",
+    maxIterations: checkpoint.maxIterations || 20,
+    currentIteration: checkpoint.currentIteration || 0,
+    sessionId: checkpoint.sessionId,
+    name: checkpoint.name || "",
+    startedAt: checkpoint.startedAt || new Date().toISOString(),
+  };
+  await write(state, cwd, checkpoint.name);
+  return state;
+}

package/hooks/stop-hook.mjs

@@ -4,6 +4,32 @@ import { evaluateStopHook } from "../core/engine.mjs";
 import { getLastAssistantText, hasPendingStories } from "../core/io-helpers.mjs";
 import { read as readState, write as writeState } from "../store/state-store.mjs";
 import { logEvents } from "../core/event-logger.mjs";
+import { join } from "node:path";
+
+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 {
+    const prd = JSON.parse(await readFile(prdPath, "utf-8"));
+    if (!Array.isArray(prd.userStories)) return [];
+
+    const results = [];
+    for (const story of prd.userStories) {
+      if (!story.testCommand || story.passes) continue;
+      try {
+        await execFileAsync("sh", ["-c", 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 });
+      }
+    }
+    return results;
+  } catch { return []; }
+}
 
 async function readStdin() {
   const chunks = [];
@@ -39,11 +65,21 @@ async function main() {
     }
   }
 
+  // Run story tests if prd.json has testCommand fields
+  const testResults = await runStoryTests(cwd);
+
+  // Evaluate loop policy
+  const { loadPolicy, evaluatePolicy } = await import("../core/policy.mjs");
+  const policy = await loadPolicy(cwd);
+  const policyResult = evaluatePolicy(policy, state, { totalCost: 0, errorCount: 0 });
+
   const input = {
     ...hookInput,
     last_assistant_text: lastText,
     has_pending_stories: pending,
     verify_result: verifyResult,
+    test_results: testResults,
+    policy_result: policyResult,
   };
 
   const result = evaluateStopHook(input, state);
@@ -51,6 +87,19 @@ async function main() {
   await writeState(result.nextState, cwd);
   await logEvents(result.events, { adapter: "auto", loop_id: state.sessionId || "unknown" }, cwd);
 
+  // Save session checkpoint (best-effort)
+  try {
+    const { saveCheckpoint } = await import("../core/session.mjs");
+    await saveCheckpoint(result.nextState.sessionId || `auto-${Date.now()}`, {
+      prompt: result.nextState.prompt,
+      completionPromise: result.nextState.completionPromise,
+      maxIterations: result.nextState.maxIterations,
+      currentIteration: result.nextState.currentIteration,
+      name: result.nextState.name,
+      startedAt: result.nextState.startedAt,
+    }, cwd);
+  } catch { /* best-effort */ }
+
   if (result.message) process.stderr.write(result.message + "\n");
   if (result.output) process.stdout.write(JSON.stringify(result.output));
   process.exit(0);

package/package.json

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