@graypark/loophaus 2.1.1 → 3.0.0

package/bin/loophaus.mjs

@@ -26,14 +26,21 @@ function getHost() {
 
 const host = getHost();
 
+function getFlag(flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("-")) return args[idx + 1];
+  return undefined;
+}
+
 if (showHelp || command === "help") {
   console.log(`loophaus — Control plane for coding agents
 
 Usage:
   npx @graypark/loophaus install [--host <name>] [--force] [--dry-run]
   npx @graypark/loophaus uninstall [--host <name>]
-  npx @graypark/loophaus status
-  npx @graypark/loophaus stats
+  npx @graypark/loophaus status [--name <loop>]
+  npx @graypark/loophaus stats [--name <loop>]
+  npx @graypark/loophaus loops
   npx @graypark/loophaus --version
 
 Hosts:
@@ -47,6 +54,7 @@ Options:
   --host <name>  Target a specific host
   --claude       Shorthand for --host claude-code
   --kiro         Shorthand for --host kiro-cli
+  --name <loop>  Target a named loop (multi-loop)
   --local        Install to project-local .codex/ (Codex only)
   --force        Overwrite existing installation
   --dry-run      Preview changes without modifying files
@@ -117,10 +125,11 @@ async function runUninstall() {
 }
 
 async function runStatus() {
+  const name = getFlag("--name");
   const { read } = await import("../store/state-store.mjs");
-  const state = await read();
+  const state = await read(undefined, name);
   if (!state.active) {
-    console.log("No active loop.");
+    console.log(name ? `No active loop: ${name}` : "No active loop.");
     return;
   }
   const iterInfo = state.maxIterations > 0
@@ -128,6 +137,7 @@ async function runStatus() {
     : `${state.currentIteration}`;
   console.log(`Loop Status`);
   console.log(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  if (name) console.log(`Name:       ${name}`);
   console.log(`Active:     yes`);
   console.log(`Iteration:  ${iterInfo}`);
   console.log(`Promise:    ${state.completionPromise || "(none)"}`);
@@ -150,8 +160,22 @@ async function runStatus() {
   } catch { /* no prd.json */ }
 }
 
+async function runLoops() {
+  const { listLoops } = await import("../core/loop-registry.mjs");
+  const loops = await listLoops();
+  if (loops.length === 0) { console.log("No active loops."); return; }
+  console.log("Active Loops");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const l of loops) {
+    const status = l.active ? "active" : "done";
+    const iter = l.maxIterations > 0 ? `${l.currentIteration}/${l.maxIterations}` : `${l.currentIteration}`;
+    console.log(`  ${l.name}  [${status}]  iter ${iter}`);
+  }
+}
+
 async function runStats() {
   const { readTrace } = await import("../core/event-logger.mjs");
+  const { formatCost } = await import("../core/cost-tracker.mjs");
   const events = await readTrace();
   if (events.length === 0) {
     console.log("No trace data found. Run a loop first.");
@@ -168,6 +192,13 @@ async function runStats() {
     console.log(`Last stop reason: ${lastStop.reason || "unknown"}`);
     console.log(`Last stop at:     ${lastStop.ts || "unknown"}`);
   }
+
+  const costEvents = events.filter(e => e.event === "cost" || e.totalCost);
+  if (costEvents.length > 0) {
+    const totalCost = costEvents.reduce((s, e) => s + (e.totalCost || 0), 0);
+    console.log(`Estimated cost:   ${formatCost(totalCost)}`);
+  }
+
   console.log(`Trace file:       .loophaus/trace.jsonl (${events.length} events)`);
 }
 
@@ -177,6 +208,7 @@ try {
     case "uninstall": await runUninstall(); break;
     case "status": await runStatus(); break;
     case "stats": await runStats(); break;
+    case "loops": await runLoops(); break;
     default:
       if (command.startsWith("-")) {
         await runInstall();

package/bin/uninstall.mjs

@@ -14,7 +14,7 @@ import {
   getClaudeInstalledPluginsPath,
   getAgentsSkillsDir,
 } from "../lib/paths.mjs";
-import { getStatePath } from "../lib/state.mjs";
+import { getStatePath } from "../store/state-store.mjs";
 
 const RALPH_HOOK_MARKER = "loophaus";
 

package/codex/commands/cancel-ralph.md

@@ -17,7 +17,7 @@ To cancel the Ralph loop:
 
    ```bash
    node -e "
-   import { readState, writeState } from '${RALPH_CODEX_ROOT}/lib/state.mjs';
+   import { readState, writeState } from '${RALPH_CODEX_ROOT}/store/state-store.mjs';
    const state = await readState();
    const iter = state.currentIteration;
    state.active = false;

package/codex/commands/ralph-loop.md

@@ -20,7 +20,7 @@ Run this command to initialize the Ralph loop state file:
 
 ```bash
 node -e "
-import { writeState } from '${RALPH_CODEX_ROOT}/lib/state.mjs';
+import { writeState } from '${RALPH_CODEX_ROOT}/store/state-store.mjs';
 await writeState({
   active: true,
   prompt: PROMPT_HERE,

package/core/cost-tracker.mjs

@@ -0,0 +1,44 @@
+// core/cost-tracker.mjs — Token cost estimation. Prices in USD per 1M tokens.
+
+const MODEL_PRICES = {
+  "claude-opus-4": { input: 15, output: 75 },
+  "claude-sonnet-4": { input: 3, output: 15 },
+  "claude-haiku-4": { input: 0.8, output: 4 },
+  "gpt-4.1": { input: 2, output: 8 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  "default": { input: 3, output: 15 },
+};
+
+export function estimateCost(model, inputTokens, outputTokens) {
+  const prices = MODEL_PRICES[model] || MODEL_PRICES["default"];
+  const inputCost = (inputTokens / 1_000_000) * prices.input;
+  const outputCost = (outputTokens / 1_000_000) * prices.output;
+  return { inputCost, outputCost, totalCost: inputCost + outputCost };
+}
+
+export function formatCost(cost) {
+  if (cost < 0.01) return `$${(cost * 100).toFixed(2)}¢`;
+  return `$${cost.toFixed(4)}`;
+}
+
+export function createTracker() {
+  const records = [];
+  return {
+    record(label, model, inputTokens, outputTokens) {
+      const cost = estimateCost(model, inputTokens, outputTokens);
+      records.push({ label, model, inputTokens, outputTokens, ...cost, ts: new Date().toISOString() });
+      return cost;
+    },
+    summary() {
+      const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
+      const totalOutput = records.reduce((s, r) => s + r.outputTokens, 0);
+      const totalCost = records.reduce((s, r) => s + r.totalCost, 0);
+      return { totalInput, totalOutput, totalCost, records: records.length };
+    },
+    getRecords() { return [...records]; },
+  };
+}
+
+export { MODEL_PRICES };

package/core/engine.mjs

@@ -41,6 +41,22 @@ export function evaluateStopHook(input, state) {
     }
   }
 
+  // Check verify script result (pre-computed by caller)
+  if (nextState.verifyScript && input.verify_result) {
+    if (input.verify_result.passed) {
+      nextState.active = false;
+      events.push({ event: "stop", reason: "verify_script", script: nextState.verifyScript });
+      return {
+        decision: "allow",
+        nextState,
+        events,
+        output: null,
+        message: `Loop: verify script passed.`,
+      };
+    }
+    events.push({ event: "verify_failed", script: nextState.verifyScript, output: input.verify_result.output || "" });
+  }
+
   if (input.stop_hook_active === true) {
     if (!input.has_pending_stories) {
       nextState.active = false;

package/core/io-helpers.mjs

@@ -0,0 +1,33 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function getLastAssistantText(transcriptPath) {
+  if (!transcriptPath) return "";
+  try {
+    const raw = await readFile(transcriptPath, "utf-8");
+    const lines = raw.trim().split("\n");
+    const recent = lines.filter((line) => {
+      try { return JSON.parse(line).role === "assistant"; } catch { return false; }
+    }).slice(-100);
+    for (let i = recent.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(recent[i]);
+        const contents = obj.message?.content || obj.content;
+        if (Array.isArray(contents)) {
+          for (let j = contents.length - 1; j >= 0; j--) {
+            if (contents[j].type === "text" && contents[j].text) return contents[j].text;
+          }
+        } else if (typeof contents === "string") return contents;
+      } catch { /* skip */ }
+    }
+  } catch { /* not found */ }
+  return "";
+}
+
+export async function hasPendingStories(cwd) {
+  try {
+    const raw = await readFile(join(cwd || process.cwd(), "prd.json"), "utf-8");
+    const prd = JSON.parse(raw);
+    return Array.isArray(prd.userStories) && prd.userStories.some((s) => s.passes === false);
+  } catch { return false; }
+}

package/core/loop-registry.mjs

@@ -0,0 +1,37 @@
+// core/loop-registry.mjs — Multi-loop registry for named loop instances
+
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function listLoops(cwd) {
+  const loopsDir = join(cwd || process.cwd(), ".loophaus", "loops");
+  const loops = [];
+  try {
+    const entries = await readdir(loopsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const statePath = join(loopsDir, entry.name, "state.json");
+      try {
+        const raw = await readFile(statePath, "utf-8");
+        const state = JSON.parse(raw);
+        loops.push({ name: entry.name, ...state });
+      } catch {
+        loops.push({ name: entry.name, active: false, error: "unreadable" });
+      }
+    }
+  } catch { /* no loops dir */ }
+
+  const defaultPath = join(cwd || process.cwd(), ".loophaus", "state.json");
+  try {
+    const raw = await readFile(defaultPath, "utf-8");
+    const state = JSON.parse(raw);
+    loops.unshift({ name: "(default)", ...state });
+  } catch { /* no default */ }
+
+  return loops;
+}
+
+export async function getLoop(name, cwd) {
+  const loops = await listLoops(cwd);
+  return loops.find(l => l.name === name) || null;
+}

package/core/state.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Loophaus State",
+  "type": "object",
+  "required": ["active", "prompt", "maxIterations", "currentIteration"],
+  "properties": {
+    "active": { "type": "boolean" },
+    "prompt": { "type": "string" },
+    "completionPromise": { "type": "string" },
+    "maxIterations": { "type": "integer", "minimum": 0 },
+    "currentIteration": { "type": "integer", "minimum": 0 },
+    "sessionId": { "type": "string" },
+    "name": { "type": "string", "description": "Loop name for multi-loop support" },
+    "verifyScript": { "type": "string", "description": "Path to verification script" },
+    "startedAt": { "type": "string", "format": "date-time" },
+    "cost": {
+      "type": "object",
+      "properties": {
+        "totalTokens": { "type": "integer" },
+        "estimatedCost": { "type": "number" }
+      }
+    }
+  }
+}

package/core/validate.mjs

@@ -0,0 +1,51 @@
+// core/validate.mjs — Zero-dep runtime schema validation
+
+const STATE_REQUIRED = {
+  active: "boolean",
+  prompt: "string",
+  maxIterations: "number",
+  currentIteration: "number",
+};
+
+const STATE_OPTIONAL = {
+  completionPromise: "string",
+  sessionId: "string",
+  name: "string",
+  verifyScript: "string",
+  startedAt: "string",
+  cost: "object",
+};
+
+export function validateState(obj) {
+  const errors = [];
+  if (typeof obj !== "object" || obj === null) {
+    return { valid: false, errors: ["State must be an object"] };
+  }
+  for (const [key, type] of Object.entries(STATE_REQUIRED)) {
+    if (!(key in obj)) errors.push(`Missing required field: ${key}`);
+    else if (typeof obj[key] !== type) errors.push(`${key} must be ${type}, got ${typeof obj[key]}`);
+  }
+  for (const [key, type] of Object.entries(STATE_OPTIONAL)) {
+    if (key in obj && obj[key] !== undefined && obj[key] !== null && typeof obj[key] !== type) {
+      errors.push(`${key} must be ${type}, got ${typeof obj[key]}`);
+    }
+  }
+  if (typeof obj.maxIterations === "number" && obj.maxIterations < 0) {
+    errors.push("maxIterations must be >= 0");
+  }
+  if (typeof obj.currentIteration === "number" && obj.currentIteration < 0) {
+    errors.push("currentIteration must be >= 0");
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+export function validateLoopConfig(obj) {
+  const errors = [];
+  if (typeof obj !== "object" || obj === null) {
+    return { valid: false, errors: ["Config must be an object"] };
+  }
+  if (obj.protocol_version && obj.protocol_version !== "1.0") {
+    errors.push(`Unsupported protocol version: ${obj.protocol_version}`);
+  }
+  return { valid: errors.length === 0, errors };
+}

package/hooks/stop-hook.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
 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";
 
@@ -12,37 +11,6 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf-8");
 }
 
-async function getLastAssistantText(transcriptPath) {
-  if (!transcriptPath) return "";
-  try {
-    const raw = await readFile(transcriptPath, "utf-8");
-    const lines = raw.trim().split("\n");
-    const recent = lines.filter((line) => {
-      try { return JSON.parse(line).role === "assistant"; } catch { return false; }
-    }).slice(-100);
-    for (let i = recent.length - 1; i >= 0; i--) {
-      try {
-        const obj = JSON.parse(recent[i]);
-        const contents = obj.message?.content || obj.content;
-        if (Array.isArray(contents)) {
-          for (let j = contents.length - 1; j >= 0; j--) {
-            if (contents[j].type === "text" && contents[j].text) return contents[j].text;
-          }
-        } else if (typeof contents === "string") return contents;
-      } catch { /* skip */ }
-    }
-  } catch { /* not found */ }
-  return "";
-}
-
-async function hasPendingStories(cwd) {
-  try {
-    const raw = await readFile(join(cwd || process.cwd(), "prd.json"), "utf-8");
-    const prd = JSON.parse(raw);
-    return Array.isArray(prd.userStories) && prd.userStories.some((s) => s.passes === false);
-  } catch { return false; }
-}
-
 async function main() {
   let hookInput = {};
   try {
@@ -57,10 +25,25 @@ async function main() {
     await getLastAssistantText(hookInput.transcript_path || null);
   const pending = await hasPendingStories(cwd);
 
+  // Run verify script if configured
+  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 });
+      verifyResult = { passed: true, output: vOut.trim() };
+    } catch (err) {
+      verifyResult = { passed: false, output: err.stderr || err.message };
+    }
+  }
+
   const input = {
     ...hookInput,
     last_assistant_text: lastText,
     has_pending_stories: pending,
+    verify_result: verifyResult,
   };
 
   const result = evaluateStopHook(input, state);

package/lib/stop-hook-core.mjs

@@ -1,162 +1,42 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { evaluateStopHook, extractPromise } from "../core/engine.mjs";
+import { getLastAssistantText, hasPendingStories } from "../core/io-helpers.mjs";
 
-export function extractPromise(text, promisePhrase) {
-  const regex = new RegExp(
-    `<promise>\\s*${escapeRegex(promisePhrase)}\\s*</promise>`,
-    "s",
-  );
-  return regex.test(text);
-}
-
-export function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export async function getLastAssistantText(transcriptPath) {
-  if (!transcriptPath) return "";
-  try {
-    const raw = await readFile(transcriptPath, "utf-8");
-    const lines = raw.trim().split("\n");
-    const assistantLines = lines.filter((line) => {
-      try {
-        const obj = JSON.parse(line);
-        return obj.role === "assistant";
-      } catch {
-        return false;
-      }
-    });
-    const recent = assistantLines.slice(-100);
-    for (let i = recent.length - 1; i >= 0; i--) {
-      try {
-        const obj = JSON.parse(recent[i]);
-        const contents = obj.message?.content || obj.content;
-        if (Array.isArray(contents)) {
-          for (let j = contents.length - 1; j >= 0; j--) {
-            if (contents[j].type === "text" && contents[j].text) {
-              return contents[j].text;
-            }
-          }
-        } else if (typeof contents === "string") {
-          return contents;
-        }
-      } catch {
-        // skip malformed lines
-      }
-    }
-  } catch {
-    // transcript not found or unreadable
-  }
-  return "";
-}
-
-export async function hasPendingStories(cwd) {
-  const prdPath = join(cwd || process.cwd(), "prd.json");
-  try {
-    const raw = await readFile(prdPath, "utf-8");
-    const prd = JSON.parse(raw);
-    if (!Array.isArray(prd.userStories)) return false;
-    return prd.userStories.some((s) => s.passes === false);
-  } catch {
-    return false;
-  }
-}
+export { extractPromise, getLastAssistantText, hasPendingStories };
 
 export async function processStopHook(hookInput, readStateFn, writeStateFn) {
-  const stderr = [];
   const state = await readStateFn();
 
-  // Not active — allow exit
   if (!state.active) {
     return { exitCode: 0, stdout: "", stderr: "" };
   }
 
-  // Session isolation
-  if (
-    state.sessionId &&
-    hookInput.session_id &&
-    state.sessionId !== hookInput.session_id
-  ) {
+  if (state.sessionId && hookInput.session_id && state.sessionId !== hookInput.session_id) {
     return { exitCode: 0, stdout: "", stderr: "" };
   }
 
-  // Increment iteration
-  state.currentIteration += 1;
-
-  // Check max iterations
-  if (state.maxIterations > 0 && state.currentIteration > state.maxIterations) {
-    stderr.push(
-      `Loop: max iterations (${state.maxIterations}) reached.\n`,
-    );
-    state.active = false;
-    await writeStateFn(state);
-    return { exitCode: 0, stdout: "", stderr: stderr.join("") };
-  }
+  const lastText = hookInput.last_assistant_message ||
+    await getLastAssistantText(hookInput.transcript_path || null);
+  const pending = await hasPendingStories(hookInput.cwd || process.cwd());
 
-  // Check completion promise
-  if (state.completionPromise) {
-    const lastText =
-      hookInput.last_assistant_message ||
-      (await getLastAssistantText(hookInput.transcript_path || null));
+  const input = {
+    ...hookInput,
+    last_assistant_text: lastText,
+    has_pending_stories: pending,
+  };
 
-    if (lastText && extractPromise(lastText, state.completionPromise)) {
-      stderr.push(
-        `Loop: completion promise "${state.completionPromise}" detected.\n`,
-      );
-      state.active = false;
-      await writeStateFn(state);
-      return { exitCode: 0, stdout: "", stderr: stderr.join("") };
-    }
-  }
+  const result = evaluateStopHook(input, state);
 
-  // Hybrid stop_hook_active handling:
-  // When true, the agent already continued from a previous block.
-  // Check prd.json for pending stories — only block if work remains.
-  if (hookInput.stop_hook_active === true) {
-    const cwd = hookInput.cwd || process.cwd();
-    const pending = await hasPendingStories(cwd);
+  await writeStateFn(result.nextState);
 
-    if (!pending) {
-      stderr.push(
-        "Loop: stop_hook_active=true, no pending stories. Allowing exit.\n",
-      );
-      state.active = false;
-      await writeStateFn(state);
-      return { exitCode: 0, stdout: "", stderr: stderr.join("") };
+  const stderrParts = [];
+  if (result.message) stderrParts.push(result.message);
+  for (const ev of result.events || []) {
+    if (ev.event === "continue" && ev.reason === "pending_stories") {
+      stderrParts.push("Loop: stop_hook_active=true, pending stories found. Continuing.");
     }
-
-    stderr.push(
-      "Loop: stop_hook_active=true, pending stories found. Continuing.\n",
-    );
   }
+  const stderr = stderrParts.length ? stderrParts.join("\n") + "\n" : "";
+  const stdout = result.output ? JSON.stringify(result.output) : "";
 
-  // Save updated iteration
-  await writeStateFn(state);
-
-  // Build continuation prompt
-  const iterInfo =
-    state.maxIterations > 0
-      ? `${state.currentIteration}/${state.maxIterations}`
-      : `${state.currentIteration}`;
-
-  const reason = [
-    state.prompt,
-    "",
-    "---",
-    `Loop iteration ${iterInfo}. Continue working on the task above.`,
-  ].join("\n");
-
-  const output = { decision: "block", reason };
-
-  if (state.completionPromise) {
-    output.systemMessage = `Loop iteration ${iterInfo} | To stop: output <promise>${state.completionPromise}</promise> (ONLY when TRUE)`;
-  } else {
-    output.systemMessage = `Loop iteration ${iterInfo} | No completion promise — loop runs until max iterations`;
-  }
-
-  return {
-    exitCode: 0,
-    stdout: JSON.stringify(output),
-    stderr: stderr.join(""),
-  };
+  return { exitCode: 0, stdout, stderr };
 }

package/package.json

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

package/platforms/codex-cli/installer.mjs

@@ -145,14 +145,15 @@ export async function install({ dryRun = false, force = false, local = false } =
     }
   }
 
-  const totalSteps = local ? 4 : 5;
+  const totalSteps = 4;
 
-  // Step 1: Clean up legacy ralph-* skills
+  // Step 1: Clean up legacy skills from ~/.codex/skills/
   console.log(`[1/${totalSteps}] Cleaning up legacy skills...`);
-  for (const name of LEGACY_SKILLS) {
+  const CLEANUP_FROM_CODEX = [...LEGACY_SKILLS, "loop", "loop-stop", "loop-plan", "loop-pulse"];
+  for (const name of CLEANUP_FROM_CODEX) {
     const legacyDir = join(skillsDir, name);
     if (await fileExists(legacyDir)) {
-      console.log(`  > Remove legacy skill: ${name}`);
+      console.log(`  > Remove from ~/.codex/skills/: ${name}`);
       if (!dryRun) {
         await rm(legacyDir, { recursive: true, force: true });
       }
@@ -192,10 +193,13 @@ export async function install({ dryRun = false, force = false, local = false } =
     await writeFile(hooksJsonPath, JSON.stringify(existing, null, 2), "utf-8");
   }
 
-  // Step 4: Install skills to ~/.codex/skills/
-  console.log(`[4/${totalSteps}] Installing skills to ~/.codex/skills/...`);
+  // Step 4: Install skills to standard path
+  // Global: ~/.agents/skills/ (new Codex CLI standard — avoids duplicates with ~/.codex/skills/)
+  // Local: .codex/skills/ (project-scoped)
+  const targetSkillsDir = local ? skillsDir : getAgentsSkillsDir();
+  console.log(`[4/${totalSteps}] Installing skills to ${local ? ".codex/skills/" : "~/.agents/skills/"}...`);
   for (const [name, skill] of Object.entries(CODEX_SKILLS)) {
-    const skillDir = join(skillsDir, name);
+    const skillDir = join(targetSkillsDir, name);
     console.log(`  > Install skill: ${name}`);
     if (!dryRun) {
       await mkdir(skillDir, { recursive: true });
@@ -207,24 +211,6 @@ export async function install({ dryRun = false, force = false, local = false } =
     }
   }
 
-  // Step 5: Mirror skills to ~/.agents/skills/ (new Codex CLI standard path)
-  if (!local) {
-    const agentsSkillsDir = getAgentsSkillsDir();
-    console.log(`[5/${totalSteps}] Installing skills to ~/.agents/skills/...`);
-    for (const [name, skill] of Object.entries(CODEX_SKILLS)) {
-      const skillDir = join(agentsSkillsDir, name);
-      console.log(`  > Install skill: ${name}`);
-      if (!dryRun) {
-        await mkdir(skillDir, { recursive: true });
-        await writeFile(
-          join(skillDir, "SKILL.md"),
-          skill.content.replaceAll("${RALPH_CODEX_ROOT}", pluginDir).replaceAll("${LOOPHAUS_ROOT}", pluginDir),
-          "utf-8",
-        );
-      }
-    }
-  }
-
   console.log("");
   if (dryRun) {
     console.log("  \u2714 Dry run complete. No files were modified.");

package/store/state-store.mjs

@@ -1,5 +1,6 @@
 import { readFile, writeFile, mkdir, rename } from "node:fs/promises";
 import { join, dirname } from "node:path";
+import { validateState } from "../core/validate.mjs";
 
 const DEFAULT_STATE = {
   active: false,
@@ -10,10 +11,12 @@ const DEFAULT_STATE = {
   sessionId: "",
 };
 
-export function getStatePath(cwd) {
+export function getStatePath(cwd, name) {
   if (process.env.LOOPHAUS_STATE_FILE) return process.env.LOOPHAUS_STATE_FILE;
   if (process.env.RALPH_STATE_FILE) return process.env.RALPH_STATE_FILE;
-  return join(cwd || process.cwd(), ".loophaus", "state.json");
+  const base = cwd || process.cwd();
+  if (name) return join(base, ".loophaus", "loops", name, "state.json");
+  return join(base, ".loophaus", "state.json");
 }
 
 const LEGACY_PATHS = [
@@ -21,12 +24,17 @@ const LEGACY_PATHS = [
   (cwd) => join(cwd, ".claude", "ralph-loop.local.md"),
 ];
 
-export async function read(cwd) {
-  const primary = getStatePath(cwd);
+export async function read(cwd, name) {
+  const primary = getStatePath(cwd, name);
 
   try {
     const raw = await readFile(primary, "utf-8");
-    return { ...DEFAULT_STATE, ...JSON.parse(raw) };
+    const state = { ...DEFAULT_STATE, ...JSON.parse(raw) };
+    const result = validateState(state);
+    if (!result.valid) {
+      process.stderr.write(`loophaus: state validation warning: ${result.errors.join(", ")}\n`);
+    }
+    return state;
   } catch {
     // Primary not found, try legacy paths
   }
@@ -48,8 +56,12 @@ export async function read(cwd) {
   return { ...DEFAULT_STATE };
 }
 
-export async function write(state, cwd) {
-  const statePath = getStatePath(cwd);
+export async function write(state, cwd, name) {
+  const result = validateState(state);
+  if (!result.valid) {
+    process.stderr.write(`loophaus: writing invalid state: ${result.errors.join(", ")}\n`);
+  }
+  const statePath = getStatePath(cwd, name);
   await mkdir(dirname(statePath), { recursive: true });
   const tmp = statePath + ".tmp";
   await writeFile(tmp, JSON.stringify(state, null, 2), "utf-8");
@@ -77,4 +89,15 @@ function migrateMdFormat(raw) {
   return state;
 }
 
+// Backward-compatible exports (matching lib/state.mjs interface)
+export async function readState(cwd) { return read(cwd); }
+export async function writeState(state, cwd) { return write(state, cwd); }
+export async function resetState(cwd) { return reset(cwd); }
+export async function incrementIteration(cwd) {
+  const state = await read(cwd);
+  state.currentIteration += 1;
+  await write(state, cwd);
+  return state;
+}
+
 export { DEFAULT_STATE };

package/lib/state.mjs

@@ -1,46 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
-
-const DEFAULT_STATE = {
-  active: false,
-  prompt: "",
-  completionPromise: "TADA",
-  maxIterations: 20,
-  currentIteration: 0,
-  sessionId: "",
-};
-
-export function getStatePath() {
-  return (
-    process.env.LOOPHAUS_STATE_FILE ||
-    process.env.RALPH_STATE_FILE ||
-    join(process.cwd(), ".loophaus", "state.json")
-  );
-}
-
-export async function readState() {
-  const statePath = getStatePath();
-  try {
-    const raw = await readFile(statePath, "utf-8");
-    return { ...DEFAULT_STATE, ...JSON.parse(raw) };
-  } catch {
-    return { ...DEFAULT_STATE };
-  }
-}
-
-export async function writeState(state) {
-  const statePath = getStatePath();
-  await mkdir(dirname(statePath), { recursive: true });
-  await writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
-}
-
-export async function resetState() {
-  await writeState({ ...DEFAULT_STATE });
-}
-
-export async function incrementIteration() {
-  const state = await readState();
-  state.currentIteration += 1;
-  await writeState(state);
-  return state;
-}