oh-my-claude-sisyphus 2.5.0 → 2.6.1

package/scripts/persistent-mode.mjs

@@ -7,8 +7,22 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+// Dynamic import for notepad with fallback
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let pruneOldEntries = null;
+
+try {
+  const notepadModule = await import(join(__dirname, '../dist/hooks/notepad/index.js'));
+  pruneOldEntries = notepadModule.pruneOldEntries;
+} catch (err) {
+  // Notepad module not available - pruning will be skipped
+  // This can happen in older versions or if build failed
+}
 
 // Read all stdin
 async function readStdin() {
@@ -39,6 +53,77 @@ function writeJsonFile(path, data) {
   }
 }
 
+// Read PRD and get status
+function getPrdStatus(projectDir) {
+  // Check both root and .sisyphus for prd.json
+  const paths = [
+    join(projectDir, 'prd.json'),
+    join(projectDir, '.sisyphus', 'prd.json')
+  ];
+
+  for (const prdPath of paths) {
+    const prd = readJsonFile(prdPath);
+    if (prd && Array.isArray(prd.userStories)) {
+      const stories = prd.userStories;
+      const completed = stories.filter(s => s.passes === true);
+      const pending = stories.filter(s => s.passes !== true);
+      const sortedPending = [...pending].sort((a, b) => (a.priority || 999) - (b.priority || 999));
+
+      return {
+        hasPrd: true,
+        total: stories.length,
+        completed: completed.length,
+        pending: pending.length,
+        allComplete: pending.length === 0,
+        nextStory: sortedPending[0] || null,
+        incompleteIds: pending.map(s => s.id)
+      };
+    }
+  }
+
+  return { hasPrd: false, allComplete: false, nextStory: null };
+}
+
+// Read progress.txt patterns for context
+function getProgressPatterns(projectDir) {
+  const paths = [
+    join(projectDir, 'progress.txt'),
+    join(projectDir, '.sisyphus', 'progress.txt')
+  ];
+
+  for (const progressPath of paths) {
+    if (existsSync(progressPath)) {
+      try {
+        const content = readFileSync(progressPath, 'utf-8');
+        const patterns = [];
+        let inPatterns = false;
+
+        for (const line of content.split('\n')) {
+          const trimmed = line.trim();
+          if (trimmed === '## Codebase Patterns') {
+            inPatterns = true;
+            continue;
+          }
+          if (trimmed === '---') {
+            inPatterns = false;
+            continue;
+          }
+          if (inPatterns && trimmed.startsWith('-')) {
+            const pattern = trimmed.slice(1).trim();
+            if (pattern && !pattern.includes('No patterns')) {
+              patterns.push(pattern);
+            }
+          }
+        }
+
+        return patterns;
+      } catch {}
+    }
+  }
+
+  return [];
+}
+
 // Count incomplete todos
 function countIncompleteTodos(todosDir, projectDir) {
   let count = 0;
@@ -93,10 +178,35 @@ async function main() {
     // Count incomplete todos
     const incompleteCount = countIncompleteTodos(todosDir, directory);
 
-    // Priority 1: Ralph Loop with Oracle Verification
+    // Check PRD status
+    const prdStatus = getPrdStatus(directory);
+    const progressPatterns = getProgressPatterns(directory);
+
+    // Priority 1: Ralph Loop with PRD and Oracle Verification
     if (ralphState?.active) {
       const iteration = ralphState.iteration || 1;
-      const maxIter = ralphState.max_iterations || 10;
+      const maxIter = ralphState.max_iterations || 100; // Increased for PRD mode
+
+      // If PRD exists and all stories are complete, allow completion
+      if (prdStatus.hasPrd && prdStatus.allComplete) {
+        // Prune old notepad entries on clean session stop
+        try {
+          if (pruneOldEntries) {
+            const pruneResult = pruneOldEntries(directory, 7);
+            if (pruneResult.pruned > 0) {
+              // Optionally log: console.error(`Pruned ${pruneResult.pruned} old notepad entries`);
+            }
+          }
+        } catch (err) {
+          // Silently ignore prune errors
+        }
+
+        console.log(JSON.stringify({
+          continue: true,
+          reason: `[RALPH LOOP COMPLETE - PRD] All ${prdStatus.total} stories are complete! Great work!`
+        }));
+        return;
+      }
 
       // Check if oracle verification is pending
       if (verificationState?.pending) {
@@ -148,6 +258,42 @@ ${verificationState.oracle_feedback}
         ralphState.iteration = newIter;
         writeJsonFile(join(directory, '.sisyphus', 'ralph-state.json'), ralphState);
 
+        // Build continuation message with PRD context if available
+        let prdContext = '';
+        if (prdStatus.hasPrd) {
+          prdContext = `
+## PRD STATUS
+${prdStatus.completed}/${prdStatus.total} stories complete. Remaining: ${prdStatus.incompleteIds.join(', ')}
+`;
+          if (prdStatus.nextStory) {
+            prdContext += `
+## CURRENT STORY: ${prdStatus.nextStory.id} - ${prdStatus.nextStory.title}
+
+${prdStatus.nextStory.description || ''}
+
+**Acceptance Criteria:**
+${(prdStatus.nextStory.acceptanceCriteria || []).map((c, i) => `${i + 1}. ${c}`).join('\n')}
+
+**Instructions:**
+1. Implement this story completely
+2. Verify ALL acceptance criteria are met
+3. Run quality checks (tests, typecheck, lint)
+4. Update prd.json to set passes: true for ${prdStatus.nextStory.id}
+5. Append progress to progress.txt
+6. Move to next story or output completion promise
+`;
+          }
+        }
+
+        // Add patterns from progress.txt
+        let patternsContext = '';
+        if (progressPatterns.length > 0) {
+          patternsContext = `
+## CODEBASE PATTERNS (from previous iterations)
+${progressPatterns.map(p => `- ${p}`).join('\n')}
+`;
+        }
+
         console.log(JSON.stringify({
           continue: false,
           reason: `<ralph-loop-continuation>
@@ -155,12 +301,12 @@ ${verificationState.oracle_feedback}
 [RALPH LOOP - ITERATION ${newIter}/${maxIter}]
 
 Your previous attempt did not output the completion promise. The work is NOT done yet.
-
+${prdContext}${patternsContext}
 CRITICAL INSTRUCTIONS:
 1. Review your progress and the original task
-2. Check your todo list - are ALL items marked complete?
+2. ${prdStatus.hasPrd ? 'Check prd.json - are ALL stories marked passes: true?' : 'Check your todo list - are ALL items marked complete?'}
 3. Continue from where you left off
-4. When FULLY complete, output: <promise>${ralphState.completion_promise || 'TASK_COMPLETE'}</promise>
+4. When FULLY complete, output: <promise>${ralphState.completion_promise || 'DONE'}</promise>
 5. Do NOT stop until the task is truly done
 
 ${ralphState.prompt ? `Original task: ${ralphState.prompt}` : ''}
@@ -181,6 +327,18 @@ ${ralphState.prompt ? `Original task: ${ralphState.prompt}` : ''}
 
       // Escape mechanism: after max reinforcements, allow stopping
       if (newCount > maxReinforcements) {
+        // Prune old notepad entries on clean session stop
+        try {
+          if (pruneOldEntries) {
+            const pruneResult = pruneOldEntries(directory, 7);
+            if (pruneResult.pruned > 0) {
+              // Optionally log: console.error(`Pruned ${pruneResult.pruned} old notepad entries`);
+            }
+          }
+        } catch (err) {
+          // Silently ignore prune errors
+        }
+
         console.log(JSON.stringify({
           continue: true,
           reason: `[ULTRAWORK ESCAPE] Maximum reinforcements (${maxReinforcements}) reached. Allowing stop despite ${incompleteCount} incomplete todos. If tasks are genuinely stuck, consider cancelling them or asking the user for help.`
@@ -233,6 +391,18 @@ ${ultraworkState.original_prompt ? `Original task: ${ultraworkState.original_pro
 
       // Escape mechanism: after max continuations, allow stopping
       if (contState.count > maxContinuations) {
+        // Prune old notepad entries on clean session stop
+        try {
+          if (pruneOldEntries) {
+            const pruneResult = pruneOldEntries(directory, 7);
+            if (pruneResult.pruned > 0) {
+              // Optionally log: console.error(`Pruned ${pruneResult.pruned} old notepad entries`);
+            }
+          }
+        } catch (err) {
+          // Silently ignore prune errors
+        }
+
         console.log(JSON.stringify({
           continue: true,
           reason: `[TODO ESCAPE] Maximum continuation attempts (${maxContinuations}) reached. Allowing stop despite ${incompleteCount} incomplete todos. Tasks may be stuck - consider reviewing and clearing them.`
@@ -260,7 +430,17 @@ Incomplete tasks remain in your todo list (${incompleteCount} remaining). Contin
       return;
     }
 
-    // No blocking needed
+    // No blocking needed - clean session stop
+    // Prune old notepad entries on clean session stop
+    try {
+      const pruneResult = pruneOldEntries(directory, 7);
+      if (pruneResult.pruned > 0) {
+        // Optionally log: console.error(`Pruned ${pruneResult.pruned} old notepad entries`);
+      }
+    } catch (err) {
+      // Silently ignore prune errors
+    }
+
     console.log(JSON.stringify({ continue: true }));
   } catch (error) {
     console.log(JSON.stringify({ continue: true }));

package/scripts/post-tool-verifier.mjs

@@ -7,8 +7,25 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+// Get the directory of this script to resolve the dist module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distDir = join(__dirname, '..', 'dist', 'hooks', 'notepad');
+
+// Try to import notepad functions (may fail if not built)
+let setPriorityContext = null;
+let addWorkingMemoryEntry = null;
+try {
+  const notepadModule = await import(join(distDir, 'index.js'));
+  setPriorityContext = notepadModule.setPriorityContext;
+  addWorkingMemoryEntry = notepadModule.addWorkingMemoryEntry;
+} catch {
+  // Notepad module not available - remember tags will be silently ignored
+}
 
 // State file for session tracking
 const STATE_FILE = join(homedir(), '.claude', '.session-stats.json');
@@ -102,6 +119,44 @@ function detectBackgroundOperation(output) {
   return bgPatterns.some(pattern => pattern.test(output));
 }
 
+/**
+ * Process <remember> tags from agent output
+ * <remember>content</remember> -> Working Memory
+ * <remember priority>content</remember> -> Priority Context
+ */
+function processRememberTags(output, directory) {
+  if (!setPriorityContext || !addWorkingMemoryEntry) {
+    return; // Notepad module not available
+  }
+
+  if (!output || !directory) {
+    return;
+  }
+
+  // Process priority remember tags first
+  const priorityRegex = /<remember\s+priority>([\s\S]*?)<\/remember>/gi;
+  let match;
+  while ((match = priorityRegex.exec(output)) !== null) {
+    const content = match[1].trim();
+    if (content) {
+      try {
+        setPriorityContext(directory, content);
+      } catch {}
+    }
+  }
+
+  // Process regular remember tags
+  const regularRegex = /<remember>([\s\S]*?)<\/remember>/gi;
+  while ((match = regularRegex.exec(output)) !== null) {
+    const content = match[1].trim();
+    if (content) {
+      try {
+        addWorkingMemoryEntry(directory, content);
+      } catch {}
+    }
+  }
+}
+
 // Detect write failure
 function detectWriteFailure(output) {
   const errorPatterns = [
@@ -194,10 +249,16 @@ async function main() {
     const toolName = data.toolName || '';
     const toolOutput = data.toolOutput || '';
     const sessionId = data.sessionId || 'unknown';
+    const directory = data.directory || process.cwd();
 
     // Update session statistics
     const toolCount = updateStats(toolName, sessionId);
 
+    // Process <remember> tags from Task agent output
+    if (toolName === 'Task' || toolName === 'task') {
+      processRememberTags(toolOutput, directory);
+    }
+
     // Generate contextual message
     const message = generateMessage(toolName, toolOutput, sessionId, toolCount);
 

package/scripts/session-start.mjs

@@ -113,6 +113,28 @@ Please continue working on these tasks.
 `);
     }
 
+    // Check for notepad Priority Context
+    const notepadPath = join(directory, '.sisyphus', 'notepad.md');
+    if (existsSync(notepadPath)) {
+      try {
+        const notepadContent = readFileSync(notepadPath, 'utf-8');
+        const priorityMatch = notepadContent.match(/## Priority Context\n([\s\S]*?)(?=## |$)/);
+        if (priorityMatch && priorityMatch[1].trim()) {
+          const priorityContext = priorityMatch[1].trim();
+          // Only inject if there's actual content (not just the placeholder comment)
+          const cleanContent = priorityContext.replace(/<!--[\s\S]*?-->/g, '').trim();
+          if (cleanContent) {
+            messages.push(`<notepad-context>
+[NOTEPAD - Priority Context]
+${cleanContent}
+</notepad-context>`);
+          }
+        }
+      } catch (err) {
+        // Silently ignore notepad read errors
+      }
+    }
+
     if (messages.length > 0) {
       console.log(JSON.stringify({ continue: true, message: messages.join('\n') }));
     } else {

package/scripts/test-max-attempts.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env tsx
+/**
+ * Test script for max-attempts counter in todo-continuation
+ *
+ * Tests the resetTodoContinuationAttempts functionality to verify
+ * that the counter tracking mechanism works correctly.
+ */
+
+import { resetTodoContinuationAttempts, checkPersistentModes } from '../src/hooks/persistent-mode/index.js';
+
+async function runTests() {
+  console.log('Testing max-attempts counter...\n');
+
+  let testsPassed = 0;
+  let testsFailed = 0;
+
+  // Test 1: Basic reset functionality
+  try {
+    console.log('Test 1: Basic reset (should not throw)');
+    resetTodoContinuationAttempts('test-session-1');
+    console.log('✓ PASS: resetTodoContinuationAttempts executed without error\n');
+    testsPassed++;
+  } catch (error) {
+    console.error('✗ FAIL: resetTodoContinuationAttempts threw error:', error);
+    testsFailed++;
+  }
+
+  // Test 2: Multiple resets on same session
+  try {
+    console.log('Test 2: Multiple resets on same session');
+    resetTodoContinuationAttempts('test-session-2');
+    resetTodoContinuationAttempts('test-session-2');
+    resetTodoContinuationAttempts('test-session-2');
+    console.log('✓ PASS: Multiple resets work correctly\n');
+    testsPassed++;
+  } catch (error) {
+    console.error('✗ FAIL: Multiple resets failed:', error);
+    testsFailed++;
+  }
+
+  // Test 3: Reset different sessions
+  try {
+    console.log('Test 3: Reset different sessions');
+    resetTodoContinuationAttempts('session-a');
+    resetTodoContinuationAttempts('session-b');
+    resetTodoContinuationAttempts('session-c');
+    console.log('✓ PASS: Can reset different sessions independently\n');
+    testsPassed++;
+  } catch (error) {
+    console.error('✗ FAIL: Different session resets failed:', error);
+    testsFailed++;
+  }
+
+  // Test 4: Indirect test via checkPersistentModes (no todos should not throw)
+  try {
+    console.log('Test 4: Indirect test via checkPersistentModes');
+    const result = await checkPersistentModes('test-session-indirect');
+    console.log(`✓ PASS: checkPersistentModes executed (shouldBlock=${result.shouldBlock}, mode=${result.mode})\n`);
+    testsPassed++;
+  } catch (error) {
+    console.error('✗ FAIL: checkPersistentModes threw error:', error);
+    testsFailed++;
+  }
+
+  // Test 5: Reset with empty string session ID
+  try {
+    console.log('Test 5: Reset with empty string session ID');
+    resetTodoContinuationAttempts('');
+    console.log('✓ PASS: Empty session ID handled correctly\n');
+    testsPassed++;
+  } catch (error) {
+    console.error('✗ FAIL: Empty session ID failed:', error);
+    testsFailed++;
+  }
+
+  // Summary
+  console.log('═══════════════════════════════════════');
+  console.log('SUMMARY');
+  console.log('═══════════════════════════════════════');
+  console.log(`Total tests: ${testsPassed + testsFailed}`);
+  console.log(`Passed: ${testsPassed}`);
+  console.log(`Failed: ${testsFailed}`);
+  console.log('═══════════════════════════════════════\n');
+
+  if (testsFailed === 0) {
+    console.log('✓ ALL TESTS PASSED');
+    process.exit(0);
+  } else {
+    console.log('✗ SOME TESTS FAILED');
+    process.exit(1);
+  }
+}
+
+runTests();

package/scripts/test-mutual-exclusion.ts

@@ -0,0 +1,152 @@
+#!/usr/bin/env tsx
+
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirSync } from 'fs';
+
+// Import the hooks
+import { startUltraQA, clearUltraQAState, isRalphLoopActive } from '../src/hooks/ultraqa-loop/index.js';
+import { createRalphLoopHook, clearRalphState, isUltraQAActive } from '../src/hooks/ralph-loop/index.js';
+
+// Test utilities
+function printTest(testName: string, passed: boolean) {
+  const status = passed ? '\x1b[32m✓ PASS\x1b[0m' : '\x1b[31m✗ FAIL\x1b[0m';
+  console.log(`${status} - ${testName}`);
+}
+
+async function runTests() {
+  console.log('\n=== Testing Mutual Exclusion Between UltraQA and Ralph Loop ===\n');
+
+  // Create temp directory with .sisyphus subfolder
+  const tempDir = mkdtempSync(join(tmpdir(), 'sisyphus-test-'));
+  const sisyphusDir = join(tempDir, '.sisyphus');
+  mkdirSync(sisyphusDir, { recursive: true });
+
+  console.log(`Using temp directory: ${tempDir}\n`);
+
+  let allTestsPassed = true;
+
+  try {
+    // Test 1: Start Ralph Loop, try to start UltraQA - should fail
+    console.log('Test 1: Ralph Loop blocks UltraQA');
+    console.log('  - Starting Ralph Loop...');
+
+    const ralphHook = createRalphLoopHook(tempDir);
+    const ralphStarted = ralphHook.startLoop(
+      'test-session-1',
+      'test task',
+      { maxIterations: 5, completionPromise: 'TASK_COMPLETE' }
+    );
+
+    if (!ralphStarted) {
+      console.log('    Failed to start Ralph Loop');
+      allTestsPassed = false;
+    }
+
+    console.log('  - Attempting to start UltraQA (should fail)...');
+    const ultraQAResult1 = startUltraQA(
+      tempDir,
+      'all-tests-pass',
+      'test-session-2'
+    );
+
+    if (ultraQAResult1.success) {
+      printTest('Test 1: UltraQA should be blocked by Ralph Loop', false);
+      allTestsPassed = false;
+    } else if (ultraQAResult1.error?.includes('Ralph Loop is active')) {
+      printTest('Test 1: UltraQA correctly blocked by Ralph Loop', true);
+    } else {
+      printTest('Test 1: UltraQA correctly blocked by Ralph Loop', false);
+      console.log(`    Unexpected error: ${ultraQAResult1.error}`);
+      allTestsPassed = false;
+    }
+
+    // Clear Ralph state
+    console.log('  - Clearing Ralph state...\n');
+    clearRalphState(tempDir);
+
+    // Test 2: Start UltraQA, try to start Ralph Loop - should fail
+    console.log('Test 2: UltraQA blocks Ralph Loop');
+    console.log('  - Starting UltraQA...');
+
+    const ultraQAResult2 = startUltraQA(
+      tempDir,
+      'all-tests-pass',
+      'test-session-3'
+    );
+
+    if (!ultraQAResult2.success) {
+      console.log(`    Failed to start UltraQA: ${ultraQAResult2.error}`);
+      allTestsPassed = false;
+    }
+
+    console.log('  - Attempting to start Ralph Loop (should fail)...');
+    const ralphHook2 = createRalphLoopHook(tempDir);
+    const ralphStarted2 = ralphHook2.startLoop(
+      'test-session-4',
+      'test task',
+      { maxIterations: 5, completionPromise: 'TASK_COMPLETE' }
+    );
+
+    if (ralphStarted2) {
+      printTest('Test 2: Ralph Loop should be blocked by UltraQA', false);
+      allTestsPassed = false;
+    } else {
+      // Check if it was blocked due to UltraQA
+      if (isUltraQAActive(tempDir)) {
+        printTest('Test 2: Ralph Loop correctly blocked by UltraQA', true);
+      } else {
+        printTest('Test 2: Ralph Loop correctly blocked by UltraQA', false);
+        console.log(`    Ralph Loop failed but UltraQA is not active`);
+        allTestsPassed = false;
+      }
+    }
+
+    // Clear UltraQA state
+    console.log('  - Clearing UltraQA state...\n');
+    clearUltraQAState(tempDir);
+
+    // Test 3: Start UltraQA without any blockers - should succeed
+    console.log('Test 3: UltraQA starts without blockers');
+    console.log('  - Attempting to start UltraQA (should succeed)...');
+    const ultraQAResult3 = startUltraQA(
+      tempDir,
+      'all-tests-pass',
+      'test-session-5'
+    );
+
+    if (ultraQAResult3.success) {
+      printTest('Test 3: UltraQA starts successfully without blockers', true);
+    } else {
+      printTest('Test 3: UltraQA should start without blockers', false);
+      console.log(`    Unexpected error: ${ultraQAResult3.error}`);
+      allTestsPassed = false;
+    }
+
+    // Final cleanup
+    console.log('  - Clearing UltraQA state...\n');
+    clearUltraQAState(tempDir);
+
+  } finally {
+    // Clean up temp directory
+    console.log(`Cleaning up temp directory: ${tempDir}`);
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+
+  // Summary
+  console.log('\n=== Test Summary ===');
+  if (allTestsPassed) {
+    console.log('\x1b[32m✓ All tests passed!\x1b[0m\n');
+    process.exit(0);
+  } else {
+    console.log('\x1b[31m✗ Some tests failed\x1b[0m\n');
+    process.exit(1);
+  }
+}
+
+// Run tests
+runTests().catch(error => {
+  console.error('\x1b[31mTest execution failed:\x1b[0m', error);
+  process.exit(1);
+});