oh-my-claude-sisyphus 3.6.3 → 3.7.0

package/templates/hooks/persistent-mode.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+// OMC Persistent Mode Hook (Node.js)
+// Unified handler for ultrawork, ralph-loop, and todo continuation
+// Cross-platform: Windows, macOS, Linux
+
+import { existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(path, data) {
+  try {
+    writeFileSync(path, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function countIncompleteTodos(todosDir, projectDir) {
+  let count = 0;
+
+  // Check global todos
+  if (existsSync(todosDir)) {
+    try {
+      const files = readdirSync(todosDir).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        const todos = readJsonFile(join(todosDir, file));
+        if (Array.isArray(todos)) {
+          count += todos.filter(t => t.status !== 'completed' && t.status !== 'cancelled').length;
+        }
+      }
+    } catch {}
+  }
+
+  // Check project todos
+  for (const path of [
+    join(projectDir, '.omc', 'todos.json'),
+    join(projectDir, '.claude', 'todos.json')
+  ]) {
+    const todos = readJsonFile(path);
+    if (Array.isArray(todos)) {
+      count += todos.filter(t => t.status !== 'completed' && t.status !== 'cancelled').length;
+    }
+  }
+
+  return count;
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    let data = {};
+    try { data = JSON.parse(input); } catch {}
+
+    const stopReason = data.stop_reason || data.stopReason || '';
+    const userRequested = data.user_requested || data.userRequested || false;
+
+    // Check for user abort - skip all continuation enforcement
+    // NOTE: Abort patterns are assumed - verify against actual Claude Code API values
+    if (userRequested || /abort|cancel|interrupt|ctrl_c|manual_stop/i.test(stopReason)) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const directory = data.directory || process.cwd();
+    const todosDir = join(homedir(), '.claude', 'todos');
+
+    // Check for ultrawork state
+    let ultraworkState = readJsonFile(join(directory, '.omc', 'ultrawork-state.json'))
+      || readJsonFile(join(homedir(), '.claude', 'ultrawork-state.json'));
+
+    // Check for ralph loop state
+    const ralphState = readJsonFile(join(directory, '.omc', 'ralph-state.json'));
+
+    // Check for verification state (oracle verification)
+    const verificationState = readJsonFile(join(directory, '.omc', 'ralph-verification.json'));
+
+    // Count incomplete todos
+    const incompleteCount = countIncompleteTodos(todosDir, directory);
+
+    // Priority 1: Ralph Loop with Oracle Verification
+    if (ralphState?.active) {
+      const iteration = ralphState.iteration || 1;
+      const maxIter = ralphState.max_iterations || 10;
+
+      // Check if oracle verification is pending
+      if (verificationState?.pending) {
+        const attempt = (verificationState.verification_attempts || 0) + 1;
+        const maxAttempts = verificationState.max_verification_attempts || 3;
+
+        console.log(JSON.stringify({
+          continue: false,
+          reason: `<ralph-verification>
+
+[ORACLE VERIFICATION REQUIRED - Attempt ${attempt}/${maxAttempts}]
+
+The agent claims the task is complete. Before accepting, YOU MUST verify with Oracle.
+
+**Original Task:**
+${verificationState.original_task || ralphState.prompt || 'No task specified'}
+
+**Completion Claim:**
+${verificationState.completion_claim || 'Task marked complete'}
+
+${verificationState.oracle_feedback ? `**Previous Oracle Feedback (rejected):**
+${verificationState.oracle_feedback}
+` : ''}
+
+## MANDATORY VERIFICATION STEPS
+
+1. **Spawn Oracle Agent** for verification:
+   \`\`\`
+   Task(subagent_type="oracle", prompt="Verify this task completion claim...")
+   \`\`\`
+
+2. **Oracle must check:**
+   - Are ALL requirements from the original task met?
+   - Is the implementation complete, not partial?
+   - Are there any obvious bugs or issues?
+   - Does the code compile/run without errors?
+   - Are tests passing (if applicable)?
+
+3. **Based on Oracle's response:**
+   - If APPROVED: Output \`<oracle-approved>VERIFIED_COMPLETE</oracle-approved>\`
+   - If REJECTED: Continue working on the identified issues
+
+DO NOT output the completion promise again until Oracle approves.
+
+</ralph-verification>
+
+---
+`
+        }));
+        return;
+      }
+
+      if (iteration < maxIter) {
+        const newIter = iteration + 1;
+        ralphState.iteration = newIter;
+        writeJsonFile(join(directory, '.omc', 'ralph-state.json'), ralphState);
+
+        console.log(JSON.stringify({
+          continue: false,
+          reason: `<ralph-loop-continuation>
+
+[RALPH LOOP - ITERATION ${newIter}/${maxIter}]
+
+Your previous attempt did not output the completion promise. The work is NOT done yet.
+
+CRITICAL INSTRUCTIONS:
+1. Review your progress and the original task
+2. 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>
+5. Do NOT stop until the task is truly done
+
+${ralphState.prompt ? `Original task: ${ralphState.prompt}` : ''}
+
+</ralph-loop-continuation>
+
+---
+`
+        }));
+        return;
+      }
+    }
+
+    // Priority 2: Ultrawork with incomplete todos
+    if (ultraworkState?.active && incompleteCount > 0) {
+      const newCount = (ultraworkState.reinforcement_count || 0) + 1;
+      ultraworkState.reinforcement_count = newCount;
+      ultraworkState.last_checked_at = new Date().toISOString();
+
+      writeJsonFile(join(directory, '.omc', 'ultrawork-state.json'), ultraworkState);
+
+      console.log(JSON.stringify({
+        continue: false,
+        reason: `<ultrawork-persistence>
+
+[ULTRAWORK MODE STILL ACTIVE - Reinforcement #${newCount}]
+
+Your ultrawork session is NOT complete. ${incompleteCount} incomplete todos remain.
+
+REMEMBER THE ULTRAWORK RULES:
+- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially
+- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent)
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each
+- **VERIFY**: Check ALL requirements met before done
+- **NO Premature Stopping**: ALL TODOs must be complete
+
+Continue working on the next pending task. DO NOT STOP until all tasks are marked complete.
+
+${ultraworkState.original_prompt ? `Original task: ${ultraworkState.original_prompt}` : ''}
+
+</ultrawork-persistence>
+
+---
+`
+      }));
+      return;
+    }
+
+    // Priority 3: Todo Continuation
+    if (incompleteCount > 0) {
+      console.log(JSON.stringify({
+        continue: false,
+        reason: `<todo-continuation>
+
+[SYSTEM REMINDER - TODO CONTINUATION]
+
+Incomplete tasks remain in your todo list (${incompleteCount} remaining). Continue working on the next pending task.
+
+- Proceed without asking for permission
+- Mark each task complete when finished
+- Do not stop until all tasks are done
+
+</todo-continuation>
+
+---
+`
+      }));
+      return;
+    }
+
+    // No blocking needed
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/templates/hooks/persistent-mode.sh

@@ -0,0 +1,187 @@
+#!/bin/bash
+# OMC Persistent Mode Hook
+# Unified handler for ultrawork, ralph-loop, and todo continuation
+# Prevents stopping when work remains incomplete
+
+# Read stdin
+INPUT=$(cat)
+
+# Get session ID and directory
+SESSION_ID=""
+DIRECTORY=""
+if command -v jq &> /dev/null; then
+  SESSION_ID=$(echo "$INPUT" | jq -r '.sessionId // .session_id // ""' 2>/dev/null)
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+fi
+
+# Default to current directory
+if [ -z "$DIRECTORY" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+# Extract stop reason for abort detection
+STOP_REASON=""
+USER_REQUESTED=""
+if command -v jq &> /dev/null; then
+  STOP_REASON=$(echo "$INPUT" | jq -r '.stop_reason // .stopReason // ""' 2>/dev/null)
+  USER_REQUESTED=$(echo "$INPUT" | jq -r '.user_requested // .userRequested // "false"' 2>/dev/null)
+fi
+
+# Check for user abort before continuation checks
+# NOTE: Abort patterns are assumed - verify against actual Claude Code API values
+if [ "$USER_REQUESTED" = "true" ] || echo "$STOP_REASON" | grep -qiE "(abort|cancel|interrupt|ctrl_c|manual_stop)"; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Check for active ultrawork state
+ULTRAWORK_STATE=""
+if [ -f "$DIRECTORY/.omc/ultrawork-state.json" ]; then
+  ULTRAWORK_STATE=$(cat "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null)
+elif [ -f "$HOME/.claude/ultrawork-state.json" ]; then
+  ULTRAWORK_STATE=$(cat "$HOME/.claude/ultrawork-state.json" 2>/dev/null)
+fi
+
+# Check for active ralph loop
+RALPH_STATE=""
+if [ -f "$DIRECTORY/.omc/ralph-state.json" ]; then
+  RALPH_STATE=$(cat "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null)
+fi
+
+# Check for verification state (oracle verification)
+VERIFICATION_STATE=""
+if [ -f "$DIRECTORY/.omc/ralph-verification.json" ]; then
+  VERIFICATION_STATE=$(cat "$DIRECTORY/.omc/ralph-verification.json" 2>/dev/null)
+fi
+
+# Check for incomplete todos
+INCOMPLETE_COUNT=0
+TODOS_DIR="$HOME/.claude/todos"
+if [ -d "$TODOS_DIR" ]; then
+  for todo_file in "$TODOS_DIR"/*.json; do
+    if [ -f "$todo_file" ]; then
+      if command -v jq &> /dev/null; then
+        COUNT=$(jq '[.[] | select(.status != "completed" and .status != "cancelled")] | length' "$todo_file" 2>/dev/null || echo "0")
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      else
+        # Fallback: count "pending" or "in_progress" occurrences
+        COUNT=$(grep -c '"status"[[:space:]]*:[[:space:]]*"pending\|in_progress"' "$todo_file" 2>/dev/null) || COUNT=0
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      fi
+    fi
+  done
+fi
+
+# Check project todos as well
+for todo_path in "$DIRECTORY/.omc/todos.json" "$DIRECTORY/.claude/todos.json"; do
+  if [ -f "$todo_path" ]; then
+    if command -v jq &> /dev/null; then
+      COUNT=$(jq 'if type == "array" then [.[] | select(.status != "completed" and .status != "cancelled")] | length else 0 end' "$todo_path" 2>/dev/null || echo "0")
+      INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+    else
+      # Fallback: count "pending" or "in_progress" occurrences
+      COUNT=$(grep -c '"status"[[:space:]]*:[[:space:]]*"pending\|in_progress"' "$todo_path" 2>/dev/null) || COUNT=0
+      INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+    fi
+  fi
+done
+
+# Priority 1: Ralph Loop with Oracle Verification
+if [ -n "$RALPH_STATE" ]; then
+  IS_ACTIVE=$(echo "$RALPH_STATE" | jq -r '.active // false' 2>/dev/null)
+  if [ "$IS_ACTIVE" = "true" ]; then
+    ITERATION=$(echo "$RALPH_STATE" | jq -r '.iteration // 1' 2>/dev/null)
+    MAX_ITER=$(echo "$RALPH_STATE" | jq -r '.max_iterations // 10' 2>/dev/null)
+    PROMISE=$(echo "$RALPH_STATE" | jq -r '.completion_promise // "TASK_COMPLETE"' 2>/dev/null)
+    PROMPT=$(echo "$RALPH_STATE" | jq -r '.prompt // ""' 2>/dev/null)
+
+    # Check if oracle verification is pending
+    if [ -n "$VERIFICATION_STATE" ]; then
+      IS_PENDING=$(echo "$VERIFICATION_STATE" | jq -r '.pending // false' 2>/dev/null)
+      if [ "$IS_PENDING" = "true" ]; then
+        ATTEMPT=$(echo "$VERIFICATION_STATE" | jq -r '.verification_attempts // 0' 2>/dev/null)
+        MAX_ATTEMPTS=$(echo "$VERIFICATION_STATE" | jq -r '.max_verification_attempts // 3' 2>/dev/null)
+        ORIGINAL_TASK=$(echo "$VERIFICATION_STATE" | jq -r '.original_task // ""' 2>/dev/null)
+        COMPLETION_CLAIM=$(echo "$VERIFICATION_STATE" | jq -r '.completion_claim // ""' 2>/dev/null)
+        ORACLE_FEEDBACK=$(echo "$VERIFICATION_STATE" | jq -r '.oracle_feedback // ""' 2>/dev/null)
+        NEXT_ATTEMPT=$((ATTEMPT + 1))
+
+        FEEDBACK_SECTION=""
+        if [ -n "$ORACLE_FEEDBACK" ] && [ "$ORACLE_FEEDBACK" != "null" ]; then
+          FEEDBACK_SECTION="\\n**Previous Oracle Feedback (rejected):**\\n$ORACLE_FEEDBACK\\n"
+        fi
+
+        cat << EOF
+{"continue": false, "reason": "<ralph-verification>\\n\\n[ORACLE VERIFICATION REQUIRED - Attempt $NEXT_ATTEMPT/$MAX_ATTEMPTS]\\n\\nThe agent claims the task is complete. Before accepting, YOU MUST verify with Oracle.\\n\\n**Original Task:**\\n$ORIGINAL_TASK\\n\\n**Completion Claim:**\\n$COMPLETION_CLAIM\\n$FEEDBACK_SECTION\\n## MANDATORY VERIFICATION STEPS\\n\\n1. **Spawn Oracle Agent** for verification:\\n   \`\`\`\\n   Task(subagent_type=\"oracle\", prompt=\"Verify this task completion claim...\")\\n   \`\`\`\\n\\n2. **Oracle must check:**\\n   - Are ALL requirements from the original task met?\\n   - Is the implementation complete, not partial?\\n   - Are there any obvious bugs or issues?\\n   - Does the code compile/run without errors?\\n   - Are tests passing (if applicable)?\\n\\n3. **Based on Oracle's response:**\\n   - If APPROVED: Output \`<oracle-approved>VERIFIED_COMPLETE</oracle-approved>\`\\n   - If REJECTED: Continue working on the identified issues\\n\\nDO NOT output the completion promise again until Oracle approves.\\n\\n</ralph-verification>\\n\\n---\\n"}
+EOF
+        exit 0
+      fi
+    fi
+
+    if [ "$ITERATION" -lt "$MAX_ITER" ]; then
+      # Increment iteration
+      NEW_ITER=$((ITERATION + 1))
+      echo "$RALPH_STATE" | jq ".iteration = $NEW_ITER" > "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null
+
+      cat << EOF
+{"continue": false, "reason": "<ralph-loop-continuation>\\n\\n[RALPH LOOP - ITERATION $NEW_ITER/$MAX_ITER]\\n\\nYour previous attempt did not output the completion promise. The work is NOT done yet.\\n\\nCRITICAL INSTRUCTIONS:\\n1. Review your progress and the original task\\n2. Check your todo list - are ALL items marked complete?\\n3. Continue from where you left off\\n4. When FULLY complete, output: <promise>$PROMISE</promise>\\n5. Do NOT stop until the task is truly done\\n\\nOriginal task: $PROMPT\\n\\n</ralph-loop-continuation>\\n\\n---\\n"}
+EOF
+      exit 0
+    fi
+  fi
+fi
+
+# Priority 2: Ultrawork Mode with incomplete todos
+if [ -n "$ULTRAWORK_STATE" ] && [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+  # Check if active (with jq fallback)
+  IS_ACTIVE=""
+  if command -v jq &> /dev/null; then
+    IS_ACTIVE=$(echo "$ULTRAWORK_STATE" | jq -r '.active // false' 2>/dev/null)
+  else
+    # Fallback: grep for "active": true
+    if echo "$ULTRAWORK_STATE" | grep -q '"active"[[:space:]]*:[[:space:]]*true'; then
+      IS_ACTIVE="true"
+    fi
+  fi
+
+  if [ "$IS_ACTIVE" = "true" ]; then
+    # Get reinforcement count (with fallback)
+    REINFORCE_COUNT=0
+    if command -v jq &> /dev/null; then
+      REINFORCE_COUNT=$(echo "$ULTRAWORK_STATE" | jq -r '.reinforcement_count // 0' 2>/dev/null)
+    else
+      REINFORCE_COUNT=$(echo "$ULTRAWORK_STATE" | grep -oP '"reinforcement_count"[[:space:]]*:[[:space:]]*\K[0-9]+' 2>/dev/null) || REINFORCE_COUNT=0
+    fi
+    NEW_COUNT=$((REINFORCE_COUNT + 1))
+
+    # Get original prompt (with fallback)
+    ORIGINAL_PROMPT=""
+    if command -v jq &> /dev/null; then
+      ORIGINAL_PROMPT=$(echo "$ULTRAWORK_STATE" | jq -r '.original_prompt // ""' 2>/dev/null)
+    else
+      ORIGINAL_PROMPT=$(echo "$ULTRAWORK_STATE" | grep -oP '"original_prompt"[[:space:]]*:[[:space:]]*"\K[^"]+' 2>/dev/null) || ORIGINAL_PROMPT=""
+    fi
+
+    # Update state file (best effort)
+    if command -v jq &> /dev/null; then
+      echo "$ULTRAWORK_STATE" | jq ".reinforcement_count = $NEW_COUNT | .last_checked_at = \"$(date -Iseconds)\"" > "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null
+    fi
+
+    cat << EOF
+{"continue": false, "reason": "<ultrawork-persistence>\\n\\n[ULTRAWORK MODE STILL ACTIVE - Reinforcement #$NEW_COUNT]\\n\\nYour ultrawork session is NOT complete. $INCOMPLETE_COUNT incomplete todos remain.\\n\\nREMEMBER THE ULTRAWORK RULES:\\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially\\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent)\\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each\\n- **VERIFY**: Check ALL requirements met before done\\n- **NO Premature Stopping**: ALL TODOs must be complete\\n\\nContinue working on the next pending task. DO NOT STOP until all tasks are marked complete.\\n\\nOriginal task: $ORIGINAL_PROMPT\\n\\n</ultrawork-persistence>\\n\\n---\\n"}
+EOF
+    exit 0
+  fi
+fi
+
+# Priority 3: Todo Continuation (baseline)
+if [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+  cat << EOF
+{"continue": false, "reason": "<todo-continuation>\\n\\n[SYSTEM REMINDER - TODO CONTINUATION]\\n\\nIncomplete tasks remain in your todo list ($INCOMPLETE_COUNT remaining). Continue working on the next pending task.\\n\\n- Proceed without asking for permission\\n- Mark each task complete when finished\\n- Do not stop until all tasks are done\\n\\n</todo-continuation>\\n\\n---\\n"}
+EOF
+  exit 0
+fi
+
+# No blocking needed
+echo '{"continue": true}'
+exit 0

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

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// OMC Post-Tool-Use Hook (Node.js)
+// Processes <remember> tags from Task agent output
+// Saves to .omc/notepad.md for compaction-resilient memory
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+// Constants
+const NOTEPAD_TEMPLATE = '# Notepad\n' +
+  '<!-- Auto-managed by OMC. Manual edits preserved in MANUAL section. -->\n\n' +
+  '## Priority Context\n' +
+  '<!-- ALWAYS loaded. Keep under 500 chars. Critical discoveries only. -->\n\n' +
+  '## Working Memory\n' +
+  '<!-- Session notes. Auto-pruned after 7 days. -->\n\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');
+  const notepadPath = join(sisyphusDir, 'notepad.md');
+
+  if (!existsSync(sisyphusDir)) {
+    try { mkdirSync(sisyphusDir, { recursive: true }); } catch {}
+  }
+
+  if (!existsSync(notepadPath)) {
+    try { writeFileSync(notepadPath, NOTEPAD_TEMPLATE); } catch {}
+  }
+
+  return notepadPath;
+}
+
+// Set priority context
+function setPriorityContext(notepadPath, content) {
+  try {
+    let notepad = readFileSync(notepadPath, 'utf-8');
+
+    // Find and replace Priority Context section
+    const priorityMatch = notepad.match(/## Priority Context[\s\S]*?(?=## Working Memory)/);
+    if (priorityMatch) {
+      const newPriority = '## Priority Context\n' +
+        '<!-- ALWAYS loaded. Keep under 500 chars. Critical discoveries only. -->\n' +
+        content.trim() + '\n\n';
+      notepad = notepad.replace(priorityMatch[0], newPriority);
+      writeFileSync(notepadPath, notepad);
+    }
+  } catch {}
+}
+
+// Add working memory entry
+function addWorkingMemoryEntry(notepadPath, content) {
+  try {
+    let notepad = readFileSync(notepadPath, 'utf-8');
+
+    const timestamp = new Date().toISOString().slice(0, 16).replace('T', ' ');
+    const entry = '### ' + timestamp + '\n' + content.trim() + '\n\n';
+
+    // Insert before MANUAL section
+    const manualIndex = notepad.indexOf('## MANUAL');
+    if (manualIndex !== -1) {
+      notepad = notepad.slice(0, manualIndex) + entry + notepad.slice(manualIndex);
+      writeFileSync(notepadPath, notepad);
+    }
+  } catch {}
+}
+
+// Process remember tags
+function processRememberTags(output, notepadPath) {
+  if (!output) return;
+
+  // Process priority remember tags
+  const priorityRegex = /<remember\s+priority>([\s\S]*?)<\/remember>/gi;
+  let match;
+  while ((match = priorityRegex.exec(output)) !== null) {
+    const content = match[1].trim();
+    if (content) {
+      setPriorityContext(notepadPath, content);
+    }
+  }
+
+  // Process regular remember tags
+  const regularRegex = /<remember>([\s\S]*?)<\/remember>/gi;
+  while ((match = regularRegex.exec(output)) !== null) {
+    const content = match[1].trim();
+    if (content) {
+      addWorkingMemoryEntry(notepadPath, content);
+    }
+  }
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+
+    const toolName = data.toolName || '';
+    const toolOutput = data.toolOutput || '';
+    const directory = data.directory || process.cwd();
+
+    // Only process Task tool output
+    if (toolName !== 'Task' && toolName !== 'task') {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    // Check for remember tags
+    if (!toolOutput.includes('<remember')) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    // Initialize notepad and process tags
+    const notepadPath = initNotepad(directory);
+    processRememberTags(toolOutput, notepadPath);
+
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

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

@@ -0,0 +1,90 @@
+#!/bin/bash
+# OMC Post-Tool-Use Hook
+# Processes <remember> tags from Task agent output
+# Saves to .omc/notepad.md for compaction-resilient memory
+
+# Read stdin
+INPUT=$(cat)
+
+# Get directory and tool info
+DIRECTORY=""
+TOOL_NAME=""
+TOOL_OUTPUT=""
+if command -v jq &> /dev/null; then
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+  TOOL_NAME=$(echo "$INPUT" | jq -r '.toolName // ""' 2>/dev/null)
+  TOOL_OUTPUT=$(echo "$INPUT" | jq -r '.toolOutput // ""' 2>/dev/null)
+else
+  # Fallback: use grep/sed for extraction
+  DIRECTORY=$(echo "$INPUT" | grep -oP '"directory"\s*:\s*"\K[^"]+' | head -1)
+  TOOL_NAME=$(echo "$INPUT" | grep -oP '"toolName"\s*:\s*"\K[^"]+' | head -1)
+  TOOL_OUTPUT=$(echo "$INPUT" | grep -oP '"toolOutput"\s*:\s*"\K[^"]+' | head -1)
+fi
+
+if [ -z "$DIRECTORY" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+# Only process Task tool output
+if [ "$TOOL_NAME" != "Task" ] && [ "$TOOL_NAME" != "task" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Check for <remember> tags
+if ! echo "$TOOL_OUTPUT" | grep -q '<remember'; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Create .omc directory if needed
+OMC_DIR="$DIRECTORY/.omc"
+NOTEPAD_FILE="$OMC_DIR/notepad.md"
+mkdir -p "$OMC_DIR" 2>/dev/null
+
+# Initialize notepad.md if it doesn't exist
+if [ ! -f "$NOTEPAD_FILE" ]; then
+  cat > "$NOTEPAD_FILE" << 'NOTEPAD_INIT'
+# Notepad
+<!-- Auto-managed by OMC. Manual edits preserved in MANUAL section. -->
+
+## Priority Context
+<!-- ALWAYS loaded. Keep under 500 chars. Critical discoveries only. -->
+
+## Working Memory
+<!-- Session notes. Auto-pruned after 7 days. -->
+
+## MANUAL
+<!-- User content. Never auto-pruned. -->
+NOTEPAD_INIT
+fi
+
+# Process priority remember tags
+PRIORITY_CONTENT=$(echo "$TOOL_OUTPUT" | grep -oP '<remember\s+priority>\K[\s\S]*?(?=</remember>)' | head -1)
+if [ -n "$PRIORITY_CONTENT" ]; then
+  # Read current notepad
+  NOTEPAD_CONTENT=$(cat "$NOTEPAD_FILE")
+  # Replace Priority Context section
+  NEW_NOTEPAD=$(echo "$NOTEPAD_CONTENT" | sed '/## Priority Context/,/## Working Memory/{
+    /## Priority Context/!{/## Working Memory/!d}
+  }' | sed "/## Priority Context/a\\<!-- ALWAYS loaded. Keep under 500 chars. Critical discoveries only. -->\\n$PRIORITY_CONTENT")
+  echo "$NEW_NOTEPAD" > "$NOTEPAD_FILE"
+fi
+
+# Process regular remember tags
+while IFS= read -r CONTENT; do
+  if [ -n "$CONTENT" ]; then
+    TIMESTAMP=$(date '+%Y-%m-%d %H:%M')
+    # Append to Working Memory section (before MANUAL)
+    sed -i "/## MANUAL/i\\### $TIMESTAMP\\n$CONTENT\\n" "$NOTEPAD_FILE" 2>/dev/null || {
+      # macOS sed fallback
+      sed -i '' "/## MANUAL/i\\
+### $TIMESTAMP\\
+$CONTENT\\
+" "$NOTEPAD_FILE"
+    }
+  fi
+done < <(echo "$TOOL_OUTPUT" | grep -oP '<remember>\K[\s\S]*?(?=</remember>)')
+
+echo '{"continue": true}'
+exit 0