ralph-lisa-loop 0.3.0

package/dist/test/policy.test.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const policy_js_1 = require("../policy.js");
+(0, node_test_1.describe)("checkRalph", () => {
+    (0, node_test_1.it)("warns when CODE missing Test Results and file:line", () => {
+        const violations = (0, policy_js_1.checkRalph)("CODE", "[CODE] Done\n\nImplemented it.");
+        assert.strictEqual(violations.length, 2);
+        assert.ok(violations.some((v) => v.rule === "test-results"));
+        assert.ok(violations.some((v) => v.rule === "file-line-ref"));
+    });
+    (0, node_test_1.it)("passes when CODE includes Test Results and file:line", () => {
+        const violations = (0, policy_js_1.checkRalph)("CODE", "[CODE] Done\n\nchanges in commands.ts:42\n\nTest Results\n- Passed");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("warns when CODE has Test Results but no file:line", () => {
+        const violations = (0, policy_js_1.checkRalph)("CODE", "[CODE] Done\n\nTest Results\n- Passed");
+        assert.strictEqual(violations.length, 1);
+        assert.strictEqual(violations[0].rule, "file-line-ref");
+    });
+    (0, node_test_1.it)("warns when CODE has file:line but no Test Results", () => {
+        const violations = (0, policy_js_1.checkRalph)("CODE", "[CODE] Done\n\nChanged commands.ts:42");
+        assert.strictEqual(violations.length, 1);
+        assert.strictEqual(violations[0].rule, "test-results");
+    });
+    (0, node_test_1.it)("warns when FIX missing Test Results", () => {
+        const violations = (0, policy_js_1.checkRalph)("FIX", "[FIX] Fixed\n\nChanged code.");
+        assert.ok(violations.some((v) => v.rule === "test-results"));
+    });
+    (0, node_test_1.it)("no warnings for PLAN", () => {
+        const violations = (0, policy_js_1.checkRalph)("PLAN", "[PLAN] Plan\n\nDetails");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("warns when RESEARCH has no substance", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] Done");
+        assert.strictEqual(violations.length, 1);
+        assert.strictEqual(violations[0].rule, "research-content");
+    });
+    (0, node_test_1.it)("passes RESEARCH with 2+ English fields", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] Done\n\nReference implementation: file.ts\nKey types: MyType\nVerification: tested");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("passes RESEARCH with exactly 2 fields", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] Done\n\nReference: file.ts\nVerification: curl tested");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("passes RESEARCH with data format + verification fields", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] Done\n\nData structure: { id: string }\nVerified: works");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("warns RESEARCH with only 1 field", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] Done\n\nReference: file.ts");
+        assert.strictEqual(violations.length, 1);
+    });
+    (0, node_test_1.it)("passes RESEARCH with substantial content (>3 lines) even without fields", () => {
+        const violations = (0, policy_js_1.checkRalph)("RESEARCH", "[RESEARCH] API analysis\n\nLine 1\nLine 2\nLine 3\nLine 4");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("file:line not required for PLAN or RESEARCH", () => {
+        const planV = (0, policy_js_1.checkRalph)("PLAN", "[PLAN] Plan\n\nNo file refs here");
+        assert.strictEqual(planV.length, 0);
+    });
+});
+(0, node_test_1.describe)("checkLisa", () => {
+    (0, node_test_1.it)("warns when PASS has no reason and no file:line", () => {
+        const violations = (0, policy_js_1.checkLisa)("PASS", "[PASS] Looks good");
+        assert.strictEqual(violations.length, 2);
+        assert.ok(violations.some((v) => v.rule === "reason-required"));
+        assert.ok(violations.some((v) => v.rule === "file-line-ref"));
+    });
+    (0, node_test_1.it)("passes when PASS has reason and file:line", () => {
+        const violations = (0, policy_js_1.checkLisa)("PASS", "[PASS] Looks good\n\n- Clean code at commands.ts:42\n- Tests pass");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("warns when PASS has reason but no file:line", () => {
+        const violations = (0, policy_js_1.checkLisa)("PASS", "[PASS] Looks good\n\n- Clean code\n- Tests pass");
+        assert.strictEqual(violations.length, 1);
+        assert.strictEqual(violations[0].rule, "file-line-ref");
+    });
+    (0, node_test_1.it)("warns when NEEDS_WORK has no reason", () => {
+        const violations = (0, policy_js_1.checkLisa)("NEEDS_WORK", "[NEEDS_WORK] Fix it");
+        assert.ok(violations.some((v) => v.rule === "reason-required"));
+    });
+    (0, node_test_1.it)("passes NEEDS_WORK with reason and file:line", () => {
+        const violations = (0, policy_js_1.checkLisa)("NEEDS_WORK", "[NEEDS_WORK] Fix it\n\n- Bug at policy.ts:30");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("no warnings for DISCUSS", () => {
+        const violations = (0, policy_js_1.checkLisa)("DISCUSS", "[DISCUSS] About this");
+        assert.strictEqual(violations.length, 0);
+    });
+    (0, node_test_1.it)("no file:line required for CONSENSUS", () => {
+        const violations = (0, policy_js_1.checkLisa)("CONSENSUS", "[CONSENSUS] Agreed");
+        assert.strictEqual(violations.length, 0);
+    });
+});

package/dist/test/state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/state.test.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const state_js_1 = require("../state.js");
+(0, node_test_1.describe)("extractTag", () => {
+    (0, node_test_1.it)("extracts known tags", () => {
+        assert.strictEqual((0, state_js_1.extractTag)("[PLAN] My plan"), "PLAN");
+        assert.strictEqual((0, state_js_1.extractTag)("[CODE] Implementation done"), "CODE");
+        assert.strictEqual((0, state_js_1.extractTag)("[RESEARCH] Results"), "RESEARCH");
+        assert.strictEqual((0, state_js_1.extractTag)("[CHALLENGE] I disagree"), "CHALLENGE");
+        assert.strictEqual((0, state_js_1.extractTag)("[PASS] Looks good"), "PASS");
+        assert.strictEqual((0, state_js_1.extractTag)("[NEEDS_WORK] Fix this"), "NEEDS_WORK");
+        assert.strictEqual((0, state_js_1.extractTag)("[DISCUSS] Let's talk"), "DISCUSS");
+        assert.strictEqual((0, state_js_1.extractTag)("[QUESTION] What about?"), "QUESTION");
+        assert.strictEqual((0, state_js_1.extractTag)("[CONSENSUS] Agreed"), "CONSENSUS");
+        assert.strictEqual((0, state_js_1.extractTag)("[FIX] Fixed the bug"), "FIX");
+    });
+    (0, node_test_1.it)("returns empty for invalid tags", () => {
+        assert.strictEqual((0, state_js_1.extractTag)("No tag here"), "");
+        assert.strictEqual((0, state_js_1.extractTag)("[INVALID] Nope"), "");
+        assert.strictEqual((0, state_js_1.extractTag)(""), "");
+    });
+});
+(0, node_test_1.describe)("extractSummary", () => {
+    (0, node_test_1.it)("extracts summary after tag", () => {
+        assert.strictEqual((0, state_js_1.extractSummary)("[PLAN] My plan"), "My plan");
+        assert.strictEqual((0, state_js_1.extractSummary)("[CODE] Implementation done"), "Implementation done");
+    });
+    (0, node_test_1.it)("returns full line if no tag", () => {
+        assert.strictEqual((0, state_js_1.extractSummary)("No tag here"), "No tag here");
+    });
+});
+(0, node_test_1.describe)("VALID_TAGS", () => {
+    (0, node_test_1.it)("contains all expected tags", () => {
+        const tags = state_js_1.VALID_TAGS.split("|");
+        assert.ok(tags.includes("PLAN"));
+        assert.ok(tags.includes("RESEARCH"));
+        assert.ok(tags.includes("CODE"));
+        assert.ok(tags.includes("FIX"));
+        assert.ok(tags.includes("PASS"));
+        assert.ok(tags.includes("NEEDS_WORK"));
+        assert.ok(tags.includes("CHALLENGE"));
+        assert.ok(tags.includes("DISCUSS"));
+        assert.ok(tags.includes("QUESTION"));
+        assert.ok(tags.includes("CONSENSUS"));
+        assert.strictEqual(tags.length, 10);
+    });
+});

package/dist/test/watcher.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Watcher state machine tests.
+ *
+ * The watcher is a bash script generated at runtime, so we can't unit-test it
+ * directly. Instead we test the state machine logic by simulating the key
+ * decision points in TypeScript:
+ *
+ * 1. LAST_TURN only updates on successful trigger (ack semantics)
+ * 2. Failure backoff: 10 → degraded (30s), 30 → ALERT
+ * 3. Interactive prompt pause/resume with dual-condition gate
+ */
+export {};

package/dist/test/watcher.test.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Watcher state machine tests.
+ *
+ * The watcher is a bash script generated at runtime, so we can't unit-test it
+ * directly. Instead we test the state machine logic by simulating the key
+ * decision points in TypeScript:
+ *
+ * 1. LAST_TURN only updates on successful trigger (ack semantics)
+ * 2. Failure backoff: 10 → degraded (30s), 30 → ALERT
+ * 3. Interactive prompt pause/resume with dual-condition gate
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+function newState() {
+    return {
+        seenTurn: "",
+        ackedTurn: "",
+        failCount: 0,
+        panePromptHits: 0,
+        panePaused: false,
+        panePauseSize: 0,
+    };
+}
+/**
+ * Simulate check_and_trigger logic (matches bash watcher v2).
+ * Two-variable approach: seenTurn (observed) vs ackedTurn (delivered).
+ * triggerResult: true = trigger succeeded, false = failed.
+ * Returns the action taken.
+ */
+function checkAndTrigger(state, currentTurn, triggerResult) {
+    // Detect new turn change
+    if (currentTurn && currentTurn !== state.seenTurn) {
+        state.seenTurn = currentTurn;
+        state.failCount = 0;
+    }
+    // Need to deliver? (seen but not acked)
+    if (state.seenTurn && state.seenTurn !== state.ackedTurn) {
+        let mode = "retry";
+        if (state.failCount >= 30) {
+            mode = "alert";
+        }
+        else if (state.failCount >= 10) {
+            mode = "degraded";
+        }
+        if (triggerResult) {
+            state.ackedTurn = state.seenTurn;
+            state.failCount = 0;
+            return "ack";
+        }
+        else {
+            state.failCount++;
+            return mode;
+        }
+    }
+    return "noop";
+}
+/**
+ * Simulate interactive prompt pause/resume logic.
+ * Returns whether send_go should proceed.
+ */
+function handleInteractivePrompt(state, promptDetected, outputChanged, currentLogSize) {
+    if (state.panePaused) {
+        // Resume requires BOTH: output changed AND prompt gone
+        if (outputChanged && currentLogSize !== state.panePauseSize && !promptDetected) {
+            state.panePaused = false;
+            state.panePromptHits = 0;
+            return true; // resumed, proceed
+        }
+        return false; // still paused
+    }
+    if (promptDetected) {
+        state.panePromptHits++;
+        if (state.panePromptHits >= 3) {
+            state.panePaused = true;
+            state.panePauseSize = currentLogSize;
+        }
+        return false; // don't send
+    }
+    state.panePromptHits = 0;
+    return true; // proceed
+}
+// ─── Tests ───────────────────────────────────────
+(0, node_test_1.describe)("Watcher: ack semantics (seenTurn vs ackedTurn)", () => {
+    (0, node_test_1.it)("updates ackedTurn only on successful trigger", () => {
+        const s = newState();
+        const action = checkAndTrigger(s, "ralph", true);
+        assert.strictEqual(action, "ack");
+        assert.strictEqual(s.ackedTurn, "ralph");
+        assert.strictEqual(s.seenTurn, "ralph");
+    });
+    (0, node_test_1.it)("does NOT update ackedTurn on failed trigger", () => {
+        const s = newState();
+        const action = checkAndTrigger(s, "ralph", false);
+        assert.strictEqual(action, "retry");
+        assert.strictEqual(s.seenTurn, "ralph"); // seen
+        assert.strictEqual(s.ackedTurn, ""); // NOT acked
+        assert.strictEqual(s.failCount, 1);
+    });
+    (0, node_test_1.it)("retries on next cycle after failure (same turn)", () => {
+        const s = newState();
+        checkAndTrigger(s, "ralph", false); // fail
+        assert.strictEqual(s.ackedTurn, "");
+        assert.strictEqual(s.failCount, 1);
+        // Same turn, seen != acked, so it retries
+        const action = checkAndTrigger(s, "ralph", true);
+        assert.strictEqual(action, "ack");
+        assert.strictEqual(s.ackedTurn, "ralph");
+        assert.strictEqual(s.failCount, 0);
+    });
+    (0, node_test_1.it)("resets failCount on new turn change", () => {
+        const s = newState();
+        s.seenTurn = "ralph";
+        s.ackedTurn = "ralph";
+        s.failCount = 5;
+        const action = checkAndTrigger(s, "lisa", true);
+        assert.strictEqual(action, "ack");
+        assert.strictEqual(s.failCount, 0);
+        assert.strictEqual(s.ackedTurn, "lisa");
+    });
+    (0, node_test_1.it)("noop when turn unchanged and already acked", () => {
+        const s = newState();
+        s.seenTurn = "ralph";
+        s.ackedTurn = "ralph";
+        const action = checkAndTrigger(s, "ralph", true);
+        assert.strictEqual(action, "noop");
+    });
+});
+(0, node_test_1.describe)("Watcher: failure backoff", () => {
+    (0, node_test_1.it)("enters degraded mode after 10 failures", () => {
+        const s = newState();
+        // 10 consecutive failures
+        for (let i = 0; i < 10; i++) {
+            checkAndTrigger(s, "ralph", false);
+        }
+        assert.strictEqual(s.failCount, 10);
+        // Next failure should be degraded
+        const action = checkAndTrigger(s, "ralph", false);
+        assert.strictEqual(action, "degraded");
+        assert.strictEqual(s.failCount, 11);
+    });
+    (0, node_test_1.it)("enters alert mode after 30 failures", () => {
+        const s = newState();
+        for (let i = 0; i < 30; i++) {
+            checkAndTrigger(s, "ralph", false);
+        }
+        assert.strictEqual(s.failCount, 30);
+        const action = checkAndTrigger(s, "ralph", false);
+        assert.strictEqual(action, "alert");
+        assert.strictEqual(s.failCount, 31);
+    });
+    (0, node_test_1.it)("recovers from degraded on success", () => {
+        const s = newState();
+        for (let i = 0; i < 15; i++) {
+            checkAndTrigger(s, "ralph", false);
+        }
+        assert.ok(s.failCount >= 10);
+        const action = checkAndTrigger(s, "ralph", true);
+        assert.strictEqual(action, "ack");
+        assert.strictEqual(s.failCount, 0);
+        assert.strictEqual(s.ackedTurn, "ralph");
+    });
+});
+(0, node_test_1.describe)("Watcher: interactive prompt pause/resume", () => {
+    (0, node_test_1.it)("pauses after 3 consecutive prompt detections", () => {
+        const s = newState();
+        handleInteractivePrompt(s, true, false, 100);
+        assert.strictEqual(s.panePromptHits, 1);
+        assert.strictEqual(s.panePaused, false);
+        handleInteractivePrompt(s, true, false, 100);
+        assert.strictEqual(s.panePromptHits, 2);
+        handleInteractivePrompt(s, true, false, 100);
+        assert.strictEqual(s.panePromptHits, 3);
+        assert.strictEqual(s.panePaused, true);
+        assert.strictEqual(s.panePauseSize, 100);
+    });
+    (0, node_test_1.it)("does not resume with only output change (prompt still present)", () => {
+        const s = newState();
+        s.panePaused = true;
+        s.panePauseSize = 100;
+        // Output changed but prompt still there
+        const proceed = handleInteractivePrompt(s, true, true, 200);
+        assert.strictEqual(proceed, false);
+        assert.strictEqual(s.panePaused, true);
+    });
+    (0, node_test_1.it)("does not resume with only prompt gone (no output change)", () => {
+        const s = newState();
+        s.panePaused = true;
+        s.panePauseSize = 100;
+        // Prompt gone but output unchanged
+        const proceed = handleInteractivePrompt(s, false, false, 100);
+        assert.strictEqual(proceed, false);
+        assert.strictEqual(s.panePaused, true);
+    });
+    (0, node_test_1.it)("resumes when BOTH output changed AND prompt gone", () => {
+        const s = newState();
+        s.panePaused = true;
+        s.panePauseSize = 100;
+        const proceed = handleInteractivePrompt(s, false, true, 200);
+        assert.strictEqual(proceed, true);
+        assert.strictEqual(s.panePaused, false);
+        assert.strictEqual(s.panePromptHits, 0);
+    });
+    (0, node_test_1.it)("resets prompt hits when no prompt detected", () => {
+        const s = newState();
+        handleInteractivePrompt(s, true, false, 100);
+        handleInteractivePrompt(s, true, false, 100);
+        assert.strictEqual(s.panePromptHits, 2);
+        // No prompt this time
+        handleInteractivePrompt(s, false, false, 100);
+        assert.strictEqual(s.panePromptHits, 0);
+    });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ralph-lisa-loop",
+  "version": "0.3.0",
+  "description": "Turn-based dual-agent collaboration: Ralph codes, Lisa reviews, consensus required.",
+  "bin": {
+    "ralph-lisa": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test dist/test/*.js",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "dist/",
+    "templates/"
+  ],
+  "keywords": [
+    "dual-agent",
+    "collaboration",
+    "code-review",
+    "claude",
+    "codex",
+    "ai-agents"
+  ],
+  "author": "YW1975",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YW1975/Ralph-Lisa-Loop.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/YW1975/Ralph-Lisa-Loop#readme",
+  "bugs": {
+    "url": "https://github.com/YW1975/Ralph-Lisa-Loop/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/templates/claude-commands/check-turn.md

@@ -0,0 +1,18 @@
+---
+description: Check whose turn it is in Ralph-Lisa collaboration
+---
+
+# Check Turn
+
+Check whose turn it is before taking any action.
+
+```!
+ralph-lisa whose-turn
+```
+
+## Rules
+
+- If output is `ralph`: You can proceed with your work
+- If output is `lisa`: STOP immediately and wait for Lisa's response
+
+**NEVER skip this check before working.**

package/templates/claude-commands/next-step.md

@@ -0,0 +1,23 @@
+---
+description: Move to next implementation step
+argument-hint: "step name"
+---
+
+# Next Step
+
+Enter a new implementation step after consensus is reached.
+
+```!
+ralph-lisa step "$ARGUMENTS"
+```
+
+## Usage
+
+Only use this after:
+1. Lisa gave PASS
+2. Both parties confirmed consensus
+
+Example:
+```
+/next-step implement login form
+```

package/templates/claude-commands/read-review.md

@@ -0,0 +1,11 @@
+---
+description: Read Lisa's latest review
+---
+
+# Read Lisa's Review
+
+View Lisa's latest feedback.
+
+```!
+ralph-lisa read review.md
+```

package/templates/claude-commands/submit-work.md

@@ -0,0 +1,39 @@
+---
+description: Submit your work to Lisa for review (Ralph only)
+argument-hint: "[TAG] summary and content"
+---
+
+# Submit Work to Lisa
+
+Submit your work and pass the turn to Lisa.
+
+```!
+ralph-lisa submit-ralph "$ARGUMENTS"
+```
+
+## Required Format
+
+Your content MUST start with a tag and one-line summary:
+
+```
+[TAG] One line summary
+
+Detailed content here...
+```
+
+## Valid Tags for Ralph
+
+| Tag | When to Use |
+|-----|-------------|
+| `[PLAN]` | Submitting a plan |
+| `[RESEARCH]` | Submitting research results (before coding, when involving reference implementations/protocols/APIs) |
+| `[CODE]` | Submitting code implementation (must include Test Results) |
+| `[FIX]` | Submitting fixes based on feedback (must include Test Results) |
+| `[CHALLENGE]` | Disagreeing with Lisa's suggestion, providing counter-argument |
+| `[DISCUSS]` | General discussion or clarification |
+| `[QUESTION]` | Asking for clarification |
+| `[CONSENSUS]` | Confirming agreement |
+
+## After Submission
+
+The turn automatically passes to Lisa. You must STOP and wait.

package/templates/claude-commands/view-status.md

@@ -0,0 +1,18 @@
+---
+description: View current collaboration status
+---
+
+# View Status
+
+See current task, turn, round, and last action.
+
+```!
+ralph-lisa status
+```
+
+## Output Shows
+
+- Current task
+- Whose turn it is
+- Current round and step
+- Last action summary

package/templates/codex-skills/check-turn.md

@@ -0,0 +1,16 @@
+# Check Turn
+
+Check whose turn it is before taking any action.
+
+## Command
+
+```bash
+./mini-skill/io.sh whose-turn
+```
+
+## Rules
+
+- If output is `lisa`: You can proceed with your review
+- If output is `ralph`: STOP immediately and wait for Ralph's submission
+
+**NEVER skip this check before working.**

package/templates/codex-skills/read-work.md

@@ -0,0 +1,9 @@
+# Read Ralph's Work
+
+View Ralph's latest submission.
+
+## Command
+
+```bash
+./mini-skill/io.sh read work.md
+```