oh-my-claude-sisyphus 3.6.3 → 3.7.2

package/skills/writer-memory/lib/synopsis-builder.ts

@@ -0,0 +1,339 @@
+/**
+ * Synopsis Builder - 정서 중심 시놉시스 생성기
+ *
+ * Korean writers think: emotion → relationship → event → plot
+ * NOT plot-first!
+ */
+
+import { loadMemory, saveMemory, now } from './memory-manager';
+import type { WriterMemory, Character, Relationship, Scene, SynopsisState } from './memory-manager';
+
+// === Synopsis Generation ===
+
+export function generateSynopsis(options?: {
+  protagonist?: string;
+  format?: 'full' | 'brief' | 'pitch';
+}): string | null {
+  const memory = loadMemory();
+  if (!memory) return null;
+
+  const format = options?.format || 'full';
+  const protagonist = options?.protagonist;
+
+  const attitude = extractProtagonistAttitude(memory, protagonist);
+  const relationships = extractCoreRelationships(memory, protagonist);
+  const theme = extractEmotionalTheme(memory);
+  const genreContrast = extractGenreVsEmotion(memory);
+  const aftertaste = extractEndingAftertaste(memory);
+
+  switch (format) {
+    case 'brief':
+      return formatBriefSynopsis(attitude, relationships, theme, memory);
+    case 'pitch':
+      return formatPitchSynopsis(attitude, relationships, theme, genreContrast, memory);
+    default:
+      return formatFullSynopsis(attitude, relationships, theme, genreContrast, aftertaste, memory);
+  }
+}
+
+// === 5 Essential Element Extractors ===
+
+function findProtagonist(memory: WriterMemory, name?: string): Character | null {
+  const chars = Object.values(memory.characters);
+  if (name) {
+    return chars.find(c => c.name === name || c.aliases?.includes(name)) || null;
+  }
+  return chars[0] || null;
+}
+
+export function extractProtagonistAttitude(memory: WriterMemory, protagonistName?: string): string {
+  const protagonist = findProtagonist(memory, protagonistName);
+
+  if (!protagonist) {
+    return '⚠️ 주인공 정보 없음. 캐릭터를 먼저 등록하세요.';
+  }
+
+  const parts: string[] = [];
+  if (protagonist.arc) parts.push(protagonist.arc);
+  if (protagonist.attitude) parts.push(protagonist.attitude);
+
+  if (parts.length === 0) {
+    return `⚠️ ${protagonist.name}의 태도 정보 미입력. arc와 attitude 필드를 채우세요.`;
+  }
+
+  return parts.join('. ');
+}
+
+export function extractCoreRelationships(memory: WriterMemory, protagonistName?: string): string {
+  const protagonist = findProtagonist(memory, protagonistName);
+
+  if (!protagonist) {
+    return '⚠️ 주인공 정보 없음.';
+  }
+
+  const rels = memory.relationships.filter(
+    r => r.from === protagonist.name || r.to === protagonist.name
+  );
+
+  if (rels.length === 0) {
+    return `⚠️ ${protagonist.name} 중심의 관계 정보 없음. 관계를 등록하세요.`;
+  }
+
+  return rels.map(r => {
+    const other = r.from === protagonist.name ? r.to : r.from;
+    return `${protagonist.name}-${other}: ${r.dynamic || r.type}`;
+  }).join('\n');
+}
+
+export function extractEmotionalTheme(memory: WriterMemory): string {
+  if (memory.themes.length === 0) {
+    return '⚠️ 테마 정보 없음. 작품의 정서적 주제를 입력하세요.';
+  }
+
+  return memory.themes.map(t => t.description || t.name).join('. ');
+}
+
+export function extractGenreVsEmotion(memory: WriterMemory): string {
+  const synopsis = memory.synopsis;
+  if (synopsis?.genreVsRealEmotion) {
+    return synopsis.genreVsRealEmotion;
+  }
+
+  const genre = memory.project.genre || '미지정';
+  return `장르: ${genre}. 실제 정서: 미정의. genreVsRealEmotion 필드를 입력하세요.`;
+}
+
+export function extractEndingAftertaste(memory: WriterMemory): string {
+  const synopsis = memory.synopsis;
+  if (synopsis?.endingAftertaste) {
+    return synopsis.endingAftertaste;
+  }
+
+  return '❌ 엔딩 정서 잔상 미입력. synopsis update endingAftertaste "..." 로 추가하세요.';
+}
+
+// === Synopsis State Management ===
+
+export function saveSynopsisState(state: SynopsisState): boolean {
+  const memory = loadMemory();
+  if (!memory) return false;
+
+  memory.synopsis = { ...state, lastGenerated: now() };
+  return saveMemory(memory);
+}
+
+export function loadSynopsisState(): SynopsisState | null {
+  const memory = loadMemory();
+  return memory?.synopsis || null;
+}
+
+export function updateSynopsisElement(element: keyof SynopsisState, value: string): boolean {
+  const memory = loadMemory();
+  if (!memory) return false;
+
+  memory.synopsis = memory.synopsis || {
+    protagonistAttitude: '',
+    coreRelationships: '',
+    emotionalTheme: '',
+    genreVsRealEmotion: '',
+    endingAftertaste: ''
+  };
+
+  (memory.synopsis as any)[element] = value;
+  memory.synopsis.lastGenerated = now();
+  return saveMemory(memory);
+}
+
+// === Format Functions ===
+
+export function formatFullSynopsis(
+  attitude: string,
+  relationships: string,
+  theme: string,
+  genreContrast: string,
+  aftertaste: string,
+  memory: WriterMemory
+): string {
+  const projectName = memory.project.name || '제목 미정';
+  const chars = Object.values(memory.characters);
+  const charList = chars.map(c => `- **${c.name}**: ${c.attitude || c.arc || '설명 없음'}`).join('\n');
+  const emotionFlow = memory.scenes
+    .filter(s => s.emotionTags?.length > 0)
+    .map(s => s.emotionTags[0])
+    .join(' → ') || '아직 정의되지 않음';
+
+  return `═══════════════════════════════
+시놉시스: ${projectName}
+═══════════════════════════════
+
+## 1. 주인공의 태도
+${attitude}
+
+## 2. 관계의 핵심 구도
+${relationships}
+
+## 3. 정서적 테마
+${theme}
+
+## 4. 장르와 실제 감정의 거리
+${genreContrast}
+
+## 5. 엔딩이 남기는 잔상
+${aftertaste}
+
+---
+**등장인물**:
+${charList || '(등장인물 없음)'}
+
+**장면 수**: ${memory.scenes.length}개
+
+**감정 흐름**: ${emotionFlow}
+`;
+}
+
+export function formatBriefSynopsis(
+  attitude: string,
+  relationships: string,
+  theme: string,
+  memory: WriterMemory
+): string {
+  const chars = Object.values(memory.characters);
+  const protagonist = chars[0];
+  const name = protagonist?.name || '주인공';
+
+  return `${name}은 ${attitude.split('.')[0]}. ${theme.split('.')[0]}을 통해 ${relationships.split('\n')[0] || '관계를 형성하며'} 변화한다.`;
+}
+
+export function formatPitchSynopsis(
+  attitude: string,
+  relationships: string,
+  theme: string,
+  genreContrast: string,
+  memory: WriterMemory
+): string {
+  const projectName = memory.project.name || '이 이야기';
+  const chars = Object.values(memory.characters);
+  const protagonist = chars[0];
+  const name = protagonist?.name || '주인공';
+
+  return `${projectName}는 ${attitude.split('.')[0]} ${name}이 ${theme.split('.')[0]}을 깨닫는 이야기. ${genreContrast.split('.')[0]}.`;
+}
+
+// === Checklist ===
+
+export interface ChecklistItem {
+  element: string;
+  elementKr: string;
+  status: 'complete' | 'partial' | 'missing';
+  source: string;
+  suggestion: string;
+}
+
+export function getSynopsisChecklist(memory: WriterMemory): ChecklistItem[] {
+  const chars = Object.values(memory.characters);
+  const protagonist = chars[0];
+
+  const checklist: ChecklistItem[] = [];
+
+  // 1. Protagonist Attitude
+  const hasArc = protagonist?.arc ? true : false;
+  const hasAttitude = protagonist?.attitude ? true : false;
+  checklist.push({
+    element: 'protagonistAttitude',
+    elementKr: '주인공 태도 요약',
+    status: hasArc && hasAttitude ? 'complete' : hasArc || hasAttitude ? 'partial' : 'missing',
+    source: protagonist ? `캐릭터 '${protagonist.name}'에서 추출` : '주인공 없음',
+    suggestion: hasArc && hasAttitude ? '' : 'char update <name> arc "..." attitude "..."'
+  });
+
+  // 2. Core Relationships
+  const relCount = protagonist ? memory.relationships.filter(
+    r => r.from === protagonist.name || r.to === protagonist.name
+  ).length : 0;
+  checklist.push({
+    element: 'coreRelationships',
+    elementKr: '관계 핵심 구도',
+    status: relCount >= 2 ? 'complete' : relCount === 1 ? 'partial' : 'missing',
+    source: `관계 ${relCount}개 등록됨`,
+    suggestion: relCount >= 2 ? '' : 'rel add <from> <to> <type>'
+  });
+
+  // 3. Emotional Theme
+  checklist.push({
+    element: 'emotionalTheme',
+    elementKr: '정서적 테마',
+    status: memory.themes.length > 0 ? 'complete' : 'missing',
+    source: `테마 ${memory.themes.length}개 등록됨`,
+    suggestion: memory.themes.length > 0 ? '' : 'theme add <name>'
+  });
+
+  // 4. Genre vs Emotion
+  const hasGenreContrast = memory.synopsis?.genreVsRealEmotion ? true : false;
+  checklist.push({
+    element: 'genreVsEmotion',
+    elementKr: '장르와 실제 감정의 거리',
+    status: hasGenreContrast ? 'complete' : 'missing',
+    source: hasGenreContrast ? '명시적으로 입력됨' : '미입력',
+    suggestion: hasGenreContrast ? '' : 'synopsis update genreVsRealEmotion "..."'
+  });
+
+  // 5. Ending Aftertaste
+  const hasAftertaste = memory.synopsis?.endingAftertaste ? true : false;
+  checklist.push({
+    element: 'endingAftertaste',
+    elementKr: '엔딩 정서 잔상',
+    status: hasAftertaste ? 'complete' : 'missing',
+    source: hasAftertaste ? '명시적으로 입력됨' : '미입력',
+    suggestion: hasAftertaste ? '' : 'synopsis update endingAftertaste "..."'
+  });
+
+  return checklist;
+}
+
+// === Export ===
+
+export function exportSynopsisAsMarkdown(): string {
+  const memory = loadMemory();
+  if (!memory) return '# Error: No memory found';
+
+  const synopsis = generateSynopsis({ format: 'full' });
+  if (!synopsis) return '# Error: Could not generate synopsis';
+
+  const meta = `---
+project: ${memory.project.name || 'Untitled'}
+genre: ${memory.project.genre || 'Unspecified'}
+generated: ${new Date().toISOString()}
+---
+
+`;
+
+  return meta + synopsis;
+}
+
+export function exportSynopsisAsJSON(): object {
+  const memory = loadMemory();
+  if (!memory) return { error: 'No memory found' };
+
+  const checklist = getSynopsisChecklist(memory);
+
+  return {
+    metadata: {
+      project: memory.project.name,
+      genre: memory.project.genre,
+      generated: new Date().toISOString()
+    },
+    elements: {
+      protagonistAttitude: extractProtagonistAttitude(memory),
+      coreRelationships: extractCoreRelationships(memory),
+      emotionalTheme: extractEmotionalTheme(memory),
+      genreVsEmotion: extractGenreVsEmotion(memory),
+      endingAftertaste: extractEndingAftertaste(memory)
+    },
+    checklist,
+    formats: {
+      full: generateSynopsis({ format: 'full' }),
+      brief: generateSynopsis({ format: 'brief' }),
+      pitch: generateSynopsis({ format: 'pitch' })
+    }
+  };
+}

package/skills/writer-memory/templates/synopsis-template.md

@@ -0,0 +1,46 @@
+# 시놉시스: {{PROJECT_NAME}}
+
+> 장르: {{GENRE}} | 최종 업데이트: {{DATE}}
+
+---
+
+## 1. 주인공의 태도 (Protagonist Attitude)
+
+{{PROTAGONIST_ATTITUDE}}
+
+## 2. 관계의 핵심 구도 (Core Relationships)
+
+{{CORE_RELATIONSHIPS}}
+
+## 3. 정서적 테마 (Emotional Theme)
+
+{{EMOTIONAL_THEME}}
+
+## 4. 장르와 실제 감정의 거리 (Genre vs Real Emotion)
+
+{{GENRE_VS_EMOTION}}
+
+## 5. 엔딩이 남기는 잔상 (Ending Aftertaste)
+
+{{ENDING_AFTERTASTE}}
+
+---
+
+## 부록
+
+### 등장인물
+
+{{CHARACTER_LIST}}
+
+### 장면 흐름
+
+{{SCENE_FLOW}}
+
+### 감정 궤도
+
+{{EMOTION_ARC}}
+
+---
+
+*이 시놉시스는 writer-memory 시스템에 의해 자동 생성되었습니다.*
+*플롯이 아닌 감정 설계도 기반의 시놉시스입니다.*

package/templates/hooks/keyword-detector.mjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+// OMC Keyword Detector Hook (Node.js)
+// Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+// Cross-platform: Windows, macOS, Linux
+
+const ULTRAWORK_MESSAGE = `<ultrawork-mode>
+
+**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
+
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
+
+## AGENT UTILIZATION PRINCIPLES
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS
+- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS
+- **Planning & Strategy**: NEVER plan yourself - spawn planning agent
+- **High-IQ Reasoning**: Use oracle for architecture decisions
+- **Frontend/UI Tasks**: Delegate to frontend-engineer
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.
+- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).
+- **VERIFY**: Check ALL requirements met before done.
+- **DELEGATE**: Orchestrate specialized agents.
+
+## ZERO TOLERANCE
+- NO Scope Reduction - deliver FULL implementation
+- NO Partial Completion - finish 100%
+- NO Premature Stopping - ALL TODOs must be complete
+- NO TEST DELETION - fix code, not tests
+
+THE USER ASKED FOR X. DELIVER EXACTLY X.
+
+</ultrawork-mode>
+
+---
+`;
+
+const ULTRATHINK_MESSAGE = `<think-mode>
+
+**ULTRATHINK MODE ENABLED** - Extended reasoning activated.
+
+You are now in deep thinking mode. Take your time to:
+1. Thoroughly analyze the problem from multiple angles
+2. Consider edge cases and potential issues
+3. Think through the implications of each approach
+4. Reason step-by-step before acting
+
+Use your extended thinking capabilities to provide the most thorough and well-reasoned response.
+
+</think-mode>
+
+---
+`;
+
+const SEARCH_MESSAGE = `<search-mode>
+MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
+- explore agents (codebase patterns, file structures)
+- librarian agents (remote repos, official docs, GitHub examples)
+Plus direct tools: Grep, Glob
+NEVER stop at first result - be exhaustive.
+</search-mode>
+
+---
+`;
+
+const ANALYZE_MESSAGE = `<analyze-mode>
+ANALYSIS MODE. Gather context before diving deep:
+
+CONTEXT GATHERING (parallel):
+- 1-2 explore agents (codebase patterns, implementations)
+- 1-2 librarian agents (if external library involved)
+- Direct tools: Grep, Glob, LSP for targeted searches
+
+IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
+- Consult oracle agent for strategic guidance
+
+SYNTHESIZE findings before proceeding.
+</analyze-mode>
+
+---
+`;
+
+// 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 {
+    const data = JSON.parse(input);
+    if (data.prompt) return data.prompt;
+    if (data.message?.content) return data.message.content;
+    if (Array.isArray(data.parts)) {
+      return data.parts
+        .filter(p => p.type === 'text')
+        .map(p => p.text)
+        .join(' ');
+    }
+    return '';
+  } catch {
+    // Fallback: try to extract with regex
+    const match = input.match(/"(?:prompt|content|text)"\s*:\s*"([^"]+)"/);
+    return match ? match[1] : '';
+  }
+}
+
+// Remove code blocks to prevent false positives
+function removeCodeBlocks(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`]+`/g, '');
+}
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Create ultrawork state file
+function activateUltraworkState(directory, prompt) {
+  const state = {
+    active: true,
+    started_at: new Date().toISOString(),
+    original_prompt: prompt,
+    reinforcement_count: 0,
+    last_checked_at: new Date().toISOString()
+  };
+  const localDir = join(directory, '.omc');
+  if (!existsSync(localDir)) { try { mkdirSync(localDir, { recursive: true }); } catch {} }
+  try { writeFileSync(join(localDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+  const globalDir = join(homedir(), '.claude');
+  if (!existsSync(globalDir)) { try { mkdirSync(globalDir, { recursive: true }); } catch {} }
+  try { writeFileSync(join(globalDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+}
+
+// Main
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    let data = {};
+    try { data = JSON.parse(input); } catch {}
+    const directory = data.directory || process.cwd();
+
+    const prompt = extractPrompt(input);
+    if (!prompt) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const cleanPrompt = removeCodeBlocks(prompt).toLowerCase();
+
+    // Check for ultrawork keywords (highest priority)
+    if (/\b(ultrawork|ulw|uw)\b/.test(cleanPrompt)) {
+      activateUltraworkState(directory, prompt);
+      console.log(JSON.stringify({ continue: true, message: ULTRAWORK_MESSAGE }));
+      return;
+    }
+
+    // Check for ultrathink/think keywords
+    if (/\b(ultrathink|think)\b/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: ULTRATHINK_MESSAGE }));
+      return;
+    }
+
+    // Check for search keywords
+    if (/\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: SEARCH_MESSAGE }));
+      return;
+    }
+
+    // Check for analyze keywords
+    if (/\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to/.test(cleanPrompt)) {
+      console.log(JSON.stringify({ continue: true, message: ANALYZE_MESSAGE }));
+      return;
+    }
+
+    // No keywords detected
+    console.log(JSON.stringify({ continue: true }));
+  } catch (error) {
+    // On any error, allow continuation
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/templates/hooks/keyword-detector.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# OMC Keyword Detector Hook
+# Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+# Also activates persistent ultrawork state when ultrawork keyword is detected
+
+# Read stdin (JSON input from Claude Code)
+INPUT=$(cat)
+
+# Extract directory from input
+DIRECTORY=""
+if command -v jq &> /dev/null; then
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+fi
+if [ -z "$DIRECTORY" ] || [ "$DIRECTORY" = "null" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+# Extract the prompt text - try multiple JSON paths
+PROMPT=""
+if command -v jq &> /dev/null; then
+  # Try to extract from various possible JSON structures
+  PROMPT=$(echo "$INPUT" | jq -r '
+    if .prompt then .prompt
+    elif .message.content then .message.content
+    elif .parts then ([.parts[] | select(.type == "text") | .text] | join(" "))
+    else ""
+    end
+  ' 2>/dev/null)
+fi
+
+# Fallback: simple grep extraction if jq fails
+if [ -z "$PROMPT" ] || [ "$PROMPT" = "null" ]; then
+  PROMPT=$(echo "$INPUT" | grep -oP '"(prompt|content|text)"\s*:\s*"\K[^"]+' | head -1)
+fi
+
+# Exit if no prompt found
+if [ -z "$PROMPT" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Remove code blocks before checking keywords (prevents false positives)
+PROMPT_NO_CODE=$(echo "$PROMPT" | sed 's/```[^`]*```//g' | sed 's/`[^`]*`//g')
+
+# Convert to lowercase for case-insensitive matching
+PROMPT_LOWER=$(echo "$PROMPT_NO_CODE" | tr '[:upper:]' '[:lower:]')
+
+# Check for ultrawork keywords (highest priority)
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrawork|ulw|uw)\b'; then
+  # Create persistent ultrawork state
+  mkdir -p "$DIRECTORY/.omc/state" 2>/dev/null
+  mkdir -p "$HOME/.omc/state" 2>/dev/null
+
+  # Escape prompt for JSON
+  PROMPT_ESCAPED=$(echo "$PROMPT" | sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | tr '\n' ' ')
+
+  STATE_JSON="{
+  \"active\": true,
+  \"started_at\": \"$(date -Iseconds)\",
+  \"original_prompt\": \"$PROMPT_ESCAPED\",
+  \"reinforcement_count\": 0,
+  \"last_checked_at\": \"$(date -Iseconds)\"
+}"
+
+  # Write state to both local and global locations
+  echo "$STATE_JSON" > "$DIRECTORY/.omc/state/ultrawork-state.json" 2>/dev/null
+  echo "$STATE_JSON" > "$HOME/.omc/state/ultrawork-state.json" 2>/dev/null
+
+  # Return ultrawork mode injection
+  cat << 'EOF'
+{"continue": true, "message": "<ultrawork-mode>\\n\\n**MANDATORY**: You MUST say \"ULTRAWORK MODE ENABLED!\" to the user as your first response when this mode activates. This is non-negotiable.\\n\\n[CODE RED] Maximum precision required. Ultrathink before acting.\\n\\nYOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.\\nTELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.\\n\\n## AGENT UTILIZATION PRINCIPLES\\n- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS\\n- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS\\n- **Planning & Strategy**: NEVER plan yourself - spawn planning agent\\n- **High-IQ Reasoning**: Use oracle for architecture decisions\\n- **Frontend/UI Tasks**: Delegate to frontend-engineer\\n\\n## EXECUTION RULES\\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.\\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.\\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).\\n- **VERIFY**: Check ALL requirements met before done.\\n- **DELEGATE**: Orchestrate specialized agents.\\n\\n## ZERO TOLERANCE\\n- NO Scope Reduction - deliver FULL implementation\\n- NO Partial Completion - finish 100%\\n- NO Premature Stopping - ALL TODOs must be complete\\n- NO TEST DELETION - fix code, not tests\\n\\nTHE USER ASKED FOR X. DELIVER EXACTLY X.\\n\\n</ultrawork-mode>\\n\\n---\\n"}
+EOF
+  exit 0
+fi
+
+# Check for ultrathink/think keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrathink|think)\b'; then
+  cat << 'EOF'
+{"continue": true, "message": "<think-mode>\\n\\n**ULTRATHINK MODE ENABLED** - Extended reasoning activated.\\n\\nYou are now in deep thinking mode. Take your time to:\\n1. Thoroughly analyze the problem from multiple angles\\n2. Consider edge cases and potential issues\\n3. Think through the implications of each approach\\n4. Reason step-by-step before acting\\n\\nUse your extended thinking capabilities to provide the most thorough and well-reasoned response.\\n\\n</think-mode>\\n\\n---\\n"}
+EOF
+  exit 0
+fi
+
+# Check for search keywords (EN + multilingual)
+if echo "$PROMPT_LOWER" | grep -qE '\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all'; then
+  cat << 'EOF'
+{"continue": true, "message": "<search-mode>\\nMAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:\\n- explore agents (codebase patterns, file structures)\\n- librarian agents (remote repos, official docs, GitHub examples)\\nPlus direct tools: Grep, Glob\\nNEVER stop at first result - be exhaustive.\\n</search-mode>\\n\\n---\\n"}
+EOF
+  exit 0
+fi
+
+# Check for analyze keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to'; then
+  cat << 'EOF'
+{"continue": true, "message": "<analyze-mode>\\nANALYSIS MODE. Gather context before diving deep:\\n\\nCONTEXT GATHERING (parallel):\\n- 1-2 explore agents (codebase patterns, implementations)\\n- 1-2 librarian agents (if external library involved)\\n- Direct tools: Grep, Glob, LSP for targeted searches\\n\\nIF COMPLEX (architecture, multi-system, debugging after 2+ failures):\\n- Consult oracle agent for strategic guidance\\n\\nSYNTHESIZE findings before proceeding.\\n</analyze-mode>\\n\\n---\\n"}
+EOF
+  exit 0
+fi
+
+# No keywords detected - continue without modification
+echo '{"continue": true}'
+exit 0