oh-my-claude-sisyphus 3.8.16 → 3.9.1

package/skills/ultrawork/SKILL.md

@@ -1,105 +1,95 @@
 ---
 name: ultrawork
-description: Activate maximum performance mode with parallel agent orchestration for high-throughput task completion
+description: Parallel execution engine for high-throughput task completion
 ---
 
 # Ultrawork Skill
 
-Activates maximum performance mode with parallel agent orchestration.
+Parallel execution engine. This is a **COMPONENT**, not a standalone persistence mode.
 
-## When Activated
-
-This skill enhances Claude's capabilities by:
+## What Ultrawork Provides
 
 1. **Parallel Execution**: Running multiple agents simultaneously for independent tasks
-2. **Aggressive Delegation**: Routing tasks to specialist agents immediately
-3. **Background Operations**: Using `run_in_background: true` for long operations
-4. **Persistence Enforcement**: Never stopping until all tasks are verified complete
-5. **Smart Model Routing**: Using tiered agents to save tokens
-
-## Smart Model Routing (CRITICAL - SAVE TOKENS)
-
-**Choose tier based on task complexity: LOW (haiku) → MEDIUM (sonnet) → HIGH (opus)**
-
-### Available Agents by Tier
+2. **Background Operations**: Using `run_in_background: true` for long operations
+3. **Smart Model Routing**: Using tiered agents to save tokens
 
-| Domain | LOW (Haiku) | MEDIUM (Sonnet) | HIGH (Opus) |
-|--------|-------------|-----------------|-------------|
-| **Analysis** | `architect-low` | `architect-medium` | `architect` |
-| **Execution** | `executor-low` | `executor` | `executor-high` |
-| **Search** | `explore` | `explore-medium` | - |
-| **Research** | `researcher-low` | `researcher` | - |
-| **Frontend** | `designer-low` | `designer` | `designer-high` |
-| **Docs** | `writer` | - | - |
-| **Visual** | - | `vision` | - |
-| **Planning** | - | - | `planner`, `critic`, `analyst` |
-| **Testing** | - | `qa-tester` | - |
-| **Security** | `security-reviewer-low` | - | `security-reviewer` |
-| **Build** | `build-fixer-low` | `build-fixer` | - |
-| **TDD** | `tdd-guide-low` | `tdd-guide` | - |
-| **Code Review** | `code-reviewer-low` | - | `code-reviewer` |
+## What Ultrawork Does NOT Provide
 
-### Tier Selection Guide
+- **Persistence**: Use `ralph` for "don't stop until done" behavior
+- **Verification Loop**: Use `ralph` for mandatory architect verification
+- **State Management**: Use `ralph` or `autopilot` for session persistence
 
-| Task Complexity | Tier | Examples |
-|-----------------|------|----------|
-| Simple lookups | LOW | "What does this function return?", "Find where X is defined" |
-| Standard work | MEDIUM | "Add error handling", "Implement this feature" |
-| Complex analysis | HIGH | "Debug this race condition", "Refactor auth module across 5 files" |
+## Usage
 
-### Routing Examples
+Ultrawork is automatically activated by:
+- `ralph` (for persistent parallel work)
+- `autopilot` (for autonomous parallel work)
+- Direct invocation when you want parallel-only execution with manual oversight
 
-**CRITICAL: Always pass `model` parameter explicitly - Claude Code does NOT auto-apply models from agent definitions!**
+## Smart Model Routing
 
+**FIRST ACTION:** Before delegating any work, read the agent reference file:
 ```
-// Simple question → LOW tier (saves tokens!)
-Task(subagent_type="oh-my-claudecode:architect-low", model="haiku", prompt="What does this function return?")
-
-// Standard implementation → MEDIUM tier
-Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="Add error handling to login")
-
-// Complex refactoring → HIGH tier
-Task(subagent_type="oh-my-claudecode:executor-high", model="opus", prompt="Refactor auth module using JWT across 5 files")
+Read file: docs/shared/agent-tiers.md
+```
+This provides the complete agent tier matrix, MCP tool assignments, and selection guidance.
 
-// Quick file lookup → LOW tier
-Task(subagent_type="oh-my-claudecode:explore", model="haiku", prompt="Find where UserService is defined")
+**CRITICAL: Always pass `model` parameter explicitly!**
 
-// Thorough search → MEDIUM tier
-Task(subagent_type="oh-my-claudecode:explore-medium", model="sonnet", prompt="Find all authentication patterns in the codebase")
+```
+Task(subagent_type="oh-my-claudecode:architect-low", model="haiku", prompt="...")
+Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="...")
+Task(subagent_type="oh-my-claudecode:architect", model="opus", prompt="...")
 ```
 
 ## Background Execution Rules
 
 **Run in Background** (set `run_in_background: true`):
-- Package installation: npm install, pip install, cargo build
-- Build processes: npm run build, make, tsc
-- Test suites: npm test, pytest, cargo test
-- Docker operations: docker build, docker pull
+- Package installation (npm install, pip install, cargo build, etc.)
+- Build processes (project build command, make, etc.)
+- Test suites (project test command, etc.)
 
 **Run Blocking** (foreground):
 - Quick status checks: git status, ls, pwd
 - File reads, edits
 - Simple commands
 
-## Verification Checklist
+## Relationship to Other Modes
 
-Before stopping, verify:
-- [ ] TODO LIST: Zero pending/in_progress tasks
-- [ ] FUNCTIONALITY: All requested features work
-- [ ] TESTS: All tests pass (if applicable)
-- [ ] ERRORS: Zero unaddressed errors
+```
+ralph (persistence wrapper)
+└── includes: ultrawork (this skill)
+    └── provides: parallel execution only
+
+autopilot (autonomous execution)
+└── includes: ralph
+    └── includes: ultrawork (this skill)
 
-**If ANY checkbox is unchecked, CONTINUE WORKING.**
+ecomode (token efficiency)
+└── modifies: ultrawork's model selection
+```
 
-## STATE CLEANUP ON COMPLETION
+## When to Use Ultrawork Directly
 
-**IMPORTANT: Delete state files on completion - do NOT just set `active: false`**
+Use ultrawork directly when you want:
+- Parallel execution without persistence guarantees
+- Manual oversight over completion
+- Quick parallel tasks where you'll verify yourself
 
-When all verification passes and work is complete:
+Use `ralph` instead when you want:
+- Verified completion (architect check)
+- Automatic retry on failure
+- Session persistence for resume
 
-```bash
-# Delete ultrawork state files
-rm -f .omc/state/ultrawork-state.json
-```
+## Completion Verification (Direct Invocations)
+
+When ultrawork is invoked directly (not via ralph), apply lightweight verification before claiming completion:
+
+### Quick Verification Checklist
+- [ ] **BUILD:** Project type check/build command passes
+- [ ] **TESTS:** Run affected tests, all pass
+- [ ] **ERRORS:** No new errors introduced
+
+This is lighter than ralph's full verification but ensures basic quality for direct ultrawork usage.
 
-This ensures clean state for future sessions. Stale state files with `active: false` should not be left behind.
+For full persistence and comprehensive verification, use `ralph` mode instead.

package/templates/hooks/keyword-detector.mjs

@@ -24,8 +24,15 @@
  */
 
 import { writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Dynamic import for the shared stdin module
+const { readStdin } = await import(join(__dirname, 'lib', 'stdin.mjs'));
 
 const ULTRATHINK_MESSAGE = `<think-mode>
 
@@ -44,15 +51,6 @@ Use your extended thinking capabilities to provide the most thorough and well-re
 ---
 `;
 
-// Read all stdin
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
-
 // Extract prompt from various JSON structures
 function extractPrompt(input) {
   try {
@@ -73,10 +71,20 @@ function extractPrompt(input) {
   }
 }
 
-// Remove code blocks to prevent false positives
-function removeCodeBlocks(text) {
+// Sanitize text to prevent false positives from code blocks, XML tags, URLs, and file paths
+function sanitizeForKeywordDetection(text) {
   return text
+    // 1. Strip XML-style tag blocks: <tag-name ...>...</tag-name> (multi-line, greedy on tag name)
+    .replace(/<(\w[\w-]*)[\s>][\s\S]*?<\/\1>/g, '')
+    // 2. Strip self-closing XML tags: <tag-name />, <tag-name attr="val" />
+    .replace(/<\w[\w-]*(?:\s[^>]*)?\s*\/>/g, '')
+    // 3. Strip URLs: http://... or https://... up to whitespace
+    .replace(/https?:\/\/[^\s)>\]]+/g, '')
+    // 4. Strip file paths: /foo/bar/baz or foo/bar/baz (using lookbehind to avoid consuming leading char)
+    .replace(/(?<=^|[\s"'`(])(?:\/)?(?:[\w.-]+\/)+[\w.-]+/gm, '')
+    // 5. Strip markdown code blocks (existing)
     .replace(/```[\s\S]*?```/g, '')
+    // 6. Strip inline code (existing)
     .replace(/`[^`]+`/g, '');
 }
 
@@ -225,7 +233,7 @@ async function main() {
       return;
     }
 
-    const cleanPrompt = removeCodeBlocks(prompt).toLowerCase();
+    const cleanPrompt = sanitizeForKeywordDetection(prompt).toLowerCase();
 
     // Collect all matching keywords
     const matches = [];

package/templates/hooks/lib/stdin.mjs

@@ -0,0 +1,62 @@
+/**
+ * Shared stdin utilities for OMC hooks
+ * Provides timeout-protected stdin reading to prevent hangs on Linux
+ * See: https://github.com/Yeachan-Heo/oh-my-claudecode/issues/240
+ */
+
+/**
+ * Read all stdin with timeout to prevent indefinite hang on Linux.
+ *
+ * The blocking `for await (const chunk of process.stdin)` pattern waits
+ * indefinitely for EOF. On Linux, if the parent process doesn't properly
+ * close stdin, this hangs forever. This function uses event-based reading
+ * with a timeout as a safety net.
+ *
+ * @param {number} timeoutMs - Maximum time to wait for stdin (default: 5000ms)
+ * @returns {Promise<string>} - The stdin content, or empty string on error/timeout
+ */
+export async function readStdin(timeoutMs = 5000) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let settled = false;
+
+    const timeout = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        process.stdin.removeAllListeners();
+        process.stdin.destroy();
+        resolve(Buffer.concat(chunks).toString('utf-8'));
+      }
+    }, timeoutMs);
+
+    process.stdin.on('data', (chunk) => {
+      chunks.push(chunk);
+    });
+
+    process.stdin.on('end', () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        resolve(Buffer.concat(chunks).toString('utf-8'));
+      }
+    });
+
+    process.stdin.on('error', () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        resolve('');
+      }
+    });
+
+    // If stdin is already ended (e.g. empty pipe), 'end' fires immediately
+    // But if stdin is a TTY or never piped, we need the timeout as safety net
+    if (process.stdin.readableEnded) {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        resolve(Buffer.concat(chunks).toString('utf-8'));
+      }
+    }
+  });
+}

package/templates/hooks/persistent-mode.mjs

@@ -9,16 +9,15 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Dynamic import for the shared stdin module
+const { readStdin } = await import(join(__dirname, 'lib', 'stdin.mjs'));
 
 function readJsonFile(path) {
   try {

package/templates/hooks/post-tool-use.mjs

@@ -4,7 +4,14 @@
 // Saves to .omc/notepad.md for compaction-resilient memory
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Dynamic import for the shared stdin module
+const { readStdin } = await import(join(__dirname, 'lib', 'stdin.mjs'));
 
 // Constants
 const NOTEPAD_TEMPLATE = '# Notepad\n' +
@@ -16,15 +23,6 @@ const NOTEPAD_TEMPLATE = '# Notepad\n' +
   '## MANUAL\n' +
   '<!-- User content. Never auto-pruned. -->\n';
 
-// Read all stdin
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
-
 // Initialize notepad.md if needed
 function initNotepad(directory) {
   const sisyphusDir = join(directory, '.omc');

package/templates/hooks/pre-tool-use.mjs

@@ -5,6 +5,14 @@
  */
 
 import * as path from 'path';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Dynamic import for the shared stdin module
+const { readStdin } = await import(path.join(__dirname, 'lib', 'stdin.mjs'));
 
 // Allowed path patterns (no warning)
 const ALLOWED_PATH_PATTERNS = [
@@ -70,12 +78,7 @@ This is a soft warning. Operation will proceed.`;
 }
 
 async function main() {
-  let input = '';
-
-  // Read stdin
-  for await (const chunk of process.stdin) {
-    input += chunk;
-  }
+  const input = await readStdin();
 
   let data;
   try {

package/templates/hooks/session-start.mjs

@@ -4,16 +4,15 @@
 // Cross-platform: Windows, macOS, Linux
 
 import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString('utf-8');
-}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Dynamic import for the shared stdin module
+const { readStdin } = await import(join(__dirname, 'lib', 'stdin.mjs'));
 
 function readJsonFile(path) {
   try {