claudecode-omc 4.8.2 → 4.8.3

package/scripts/post-tool-verifier.mjs

@@ -12,6 +12,9 @@ import { homedir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { readStdin } from './lib/stdin.mjs';
 
+const AGENT_OUTPUT_ANALYSIS_LIMIT = parseInt(process.env.OMC_AGENT_OUTPUT_ANALYSIS_LIMIT || '12000', 10);
+const AGENT_OUTPUT_SUMMARY_LIMIT = parseInt(process.env.OMC_AGENT_OUTPUT_SUMMARY_LIMIT || '360', 10);
+
 // Get the directory of this script to resolve the dist module
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -208,6 +211,36 @@ function detectBackgroundOperation(output) {
   return bgPatterns.some(pattern => pattern.test(output));
 }
 
+export function summarizeAgentResult(output, maxChars = AGENT_OUTPUT_SUMMARY_LIMIT) {
+  if (!output || typeof output !== 'string') return '';
+
+  const normalized = output
+    .replace(/\r/g, '')
+    .split('\n')
+    .map(l => l.trim())
+    .filter(Boolean)
+    .slice(0, 6)
+    .join(' | ');
+
+  if (!normalized) return '';
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxChars - 20)).trimEnd()} … [truncated]`;
+}
+
+function clipToolOutputForAnalysis(toolName, output) {
+  if (typeof output !== 'string') return { clipped: '', wasTruncated: false };
+
+  const isAgentResultTool = toolName === 'Task' || toolName === 'TaskCreate' || toolName === 'TaskUpdate' || toolName === 'TaskOutput';
+  if (!isAgentResultTool || output.length <= AGENT_OUTPUT_ANALYSIS_LIMIT) {
+    return { clipped: output, wasTruncated: false };
+  }
+
+  return {
+    clipped: `${output.slice(0, AGENT_OUTPUT_ANALYSIS_LIMIT)}\n...[agent output truncated by OMC context guard]`,
+    wasTruncated: true,
+  };
+}
+
 /**
  * Process <remember> tags from agent output
  * <remember>content</remember> -> Working Memory
@@ -292,7 +325,8 @@ function getAgentCompletionSummary(directory) {
 }
 
 // Generate contextual message
-function generateMessage(toolName, toolOutput, sessionId, toolCount, directory) {
+function generateMessage(toolName, toolOutput, sessionId, toolCount, directory, options = {}) {
+  const { wasTruncated = false, rawLength = 0 } = options;
   let message = '';
 
   switch (toolName) {
@@ -320,12 +354,28 @@ function generateMessage(toolName, toolOutput, sessionId, toolCount, directory)
       } else if (toolCount > 5) {
         message = `Multiple tasks delegated (${toolCount} total). Track their completion status.`;
       }
+      if (wasTruncated) {
+        const truncationNote = `Agent result stream clipped for context safety (${rawLength} chars). Synthesize only key outcomes in main session.`;
+        message = message ? `${message} | ${truncationNote}` : truncationNote;
+      }
       if (agentSummary) {
         message = message ? `${message} | ${agentSummary}` : agentSummary;
       }
       break;
     }
 
+    case 'TaskOutput': {
+      const summary = summarizeAgentResult(toolOutput);
+      if (summary) {
+        message = `TaskOutput summary: ${summary}`;
+      }
+      if (wasTruncated) {
+        const truncationNote = `TaskOutput clipped (${rawLength} chars). Continue with concise synthesis and defer full logs to files.`;
+        message = message ? `${message} | ${truncationNote}` : truncationNote;
+      }
+      break;
+    }
+
     case 'Edit':
       if (detectWriteFailure(toolOutput)) {
         message = 'Edit operation failed. Verify file exists and content matches exactly.';
@@ -389,6 +439,7 @@ async function main() {
     const toolName = data.tool_name || data.toolName || '';
     const rawResponse = data.tool_response || data.toolOutput || '';
     const toolOutput = typeof rawResponse === 'string' ? rawResponse : JSON.stringify(rawResponse);
+    const { clipped: clippedToolOutput, wasTruncated } = clipToolOutputForAnalysis(toolName, toolOutput);
     const sessionId = data.session_id || data.sessionId || 'unknown';
     const directory = data.cwd || data.directory || process.cwd();
 
@@ -409,11 +460,14 @@ async function main() {
       toolName === 'TaskCreate' ||
       toolName === 'TaskUpdate'
     ) {
-      processRememberTags(toolOutput, directory);
+      processRememberTags(clippedToolOutput, directory);
     }
 
     // Generate contextual message
-    const message = generateMessage(toolName, toolOutput, sessionId, toolCount, directory);
+    const message = generateMessage(toolName, clippedToolOutput, sessionId, toolCount, directory, {
+      wasTruncated,
+      rawLength: toolOutput.length,
+    });
 
     // Build response - use hookSpecificOutput.additionalContext for PostToolUse
     const response = { continue: true };

package/scripts/pre-tool-enforcer.mjs

@@ -6,8 +6,10 @@
  * Cross-platform: Windows, macOS, Linux
  */
 
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, renameSync, statSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { execSync } from 'child_process';
+import { homedir } from 'os';
 import { pathToFileURL } from 'url';
 import { readStdin } from './lib/stdin.mjs';
 
@@ -22,6 +24,103 @@ const MODE_STATE_FILES = [
   'team-state.json',
   'omc-teams-state.json',
 ];
+const AGENT_HEAVY_TOOLS = new Set(['Task', 'TaskCreate', 'TaskUpdate']);
+const PREFLIGHT_CONTEXT_THRESHOLD = parseInt(process.env.OMC_AGENT_PREFLIGHT_CONTEXT_THRESHOLD || '72', 10);
+
+/**
+ * Resolve transcript path in worktree environments.
+ * Mirrors logic used by context safety/guard hooks.
+ */
+function resolveTranscriptPath(transcriptPath, cwd) {
+  if (!transcriptPath) return transcriptPath;
+  try {
+    if (existsSync(transcriptPath)) return transcriptPath;
+  } catch { /* fallthrough */ }
+
+  const worktreePattern = /--claude-worktrees-[^/\\]+/;
+  if (worktreePattern.test(transcriptPath)) {
+    const resolvedPath = transcriptPath.replace(worktreePattern, '');
+    try {
+      if (existsSync(resolvedPath)) return resolvedPath;
+    } catch { /* fallthrough */ }
+  }
+
+  const effectiveCwd = cwd || process.cwd();
+  try {
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const absoluteCommonDir = resolve(effectiveCwd, gitCommonDir);
+    const mainRepoRoot = dirname(absoluteCommonDir);
+
+    const worktreeTop = execSync('git rev-parse --show-toplevel', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    if (mainRepoRoot !== worktreeTop) {
+      const lastSep = transcriptPath.lastIndexOf('/');
+      const sessionFile = lastSep !== -1 ? transcriptPath.substring(lastSep + 1) : '';
+      if (sessionFile) {
+        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+        const projectsDir = join(configDir, 'projects');
+        if (existsSync(projectsDir)) {
+          const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
+          const resolvedPath = join(projectsDir, encodedMain, sessionFile);
+          try {
+            if (existsSync(resolvedPath)) return resolvedPath;
+          } catch { /* fallthrough */ }
+        }
+      }
+    }
+  } catch { /* best-effort fallback */ }
+
+  return transcriptPath;
+}
+
+function estimateContextPercent(transcriptPath) {
+  if (!transcriptPath) return 0;
+
+  let fd = -1;
+  try {
+    const stat = statSync(transcriptPath);
+    if (stat.size === 0) return 0;
+
+    fd = openSync(transcriptPath, 'r');
+    const readSize = Math.min(4096, stat.size);
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, stat.size - readSize);
+    closeSync(fd);
+    fd = -1;
+
+    const tail = buf.toString('utf-8');
+    const windowMatch = tail.match(/"context_window"\s{0,5}:\s{0,5}(\d+)/g);
+    const inputMatch = tail.match(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g);
+
+    if (!windowMatch || !inputMatch) return 0;
+
+    const lastWindow = parseInt(windowMatch[windowMatch.length - 1].match(/(\d+)/)[1], 10);
+    const lastInput = parseInt(inputMatch[inputMatch.length - 1].match(/(\d+)/)[1], 10);
+
+    if (lastWindow === 0) return 0;
+    return Math.round((lastInput / lastWindow) * 100);
+  } catch {
+    return 0;
+  } finally {
+    if (fd !== -1) try { closeSync(fd); } catch { /* ignore */ }
+  }
+}
+
+function buildPreflightRecoveryAdvice(contextPercent) {
+  return `[OMC] Preflight context guard: ${contextPercent}% used ` +
+    `(threshold: ${PREFLIGHT_CONTEXT_THRESHOLD}%). Avoid spawning additional agent-heavy tasks ` +
+    `until context is reduced. Safe recovery: (1) pause new Task fan-out, (2) run /compact now, ` +
+    `(3) if compact fails, open a fresh session and continue from .omc/state + .omc/notepad.md.`;
+}
 
 // Simple JSON field extraction
 function extractJsonField(input, field, defaultValue = '') {
@@ -216,6 +315,85 @@ function generateMessage(toolName, todoStatus, modeActive = false) {
   return '';
 }
 
+// ---------------------------------------------------------------------------
+// Skill Active State (issue #1033)
+// Writes skill-active-state.json so the persistent-mode Stop hook can prevent
+// premature session termination while a skill is executing.
+// ---------------------------------------------------------------------------
+
+const SKILL_PROTECTION_CONFIGS = {
+  none:   { maxReinforcements: 0,  staleTtlMs: 0 },
+  light:  { maxReinforcements: 3,  staleTtlMs: 5 * 60 * 1000 },
+  medium: { maxReinforcements: 5,  staleTtlMs: 15 * 60 * 1000 },
+  heavy:  { maxReinforcements: 10, staleTtlMs: 30 * 60 * 1000 },
+};
+
+const SKILL_PROTECTION_MAP = {
+  autopilot: 'none', ralph: 'none', ultrawork: 'none', team: 'none',
+  'omc-teams': 'none', ultraqa: 'none', cancel: 'none',
+  trace: 'none', hud: 'none', 'omc-doctor': 'none', 'omc-help': 'none',
+  'learn-about-omc': 'none', note: 'none',
+  tdd: 'light', 'build-fix': 'light', analyze: 'light', skill: 'light',
+  'configure-notifications': 'light',
+  'code-review': 'medium', 'security-review': 'medium', plan: 'medium',
+  ralplan: 'medium', review: 'medium', 'external-context': 'medium',
+  sciomc: 'medium', learner: 'medium', 'omc-setup': 'medium',
+  'mcp-setup': 'medium', 'project-session-manager': 'medium',
+  'writer-memory': 'medium', 'ralph-init': 'medium', ccg: 'medium',
+  deepinit: 'heavy',
+};
+
+function getSkillProtectionLevel(skillName) {
+  const normalized = (skillName || '').toLowerCase().replace(/^oh-my-claudecode:/, '');
+  return SKILL_PROTECTION_MAP[normalized] || 'light';
+}
+
+function extractSkillName(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return null;
+  const rawSkill = toolInput.skill || toolInput.skill_name || toolInput.skillName || toolInput.command || null;
+  if (typeof rawSkill !== 'string' || !rawSkill.trim()) return null;
+  const normalized = rawSkill.trim();
+  return normalized.includes(':') ? normalized.split(':').at(-1).toLowerCase() : normalized.toLowerCase();
+}
+
+function writeSkillActiveState(directory, skillName, sessionId) {
+  const protection = getSkillProtectionLevel(skillName);
+  if (protection === 'none') return;
+
+  const config = SKILL_PROTECTION_CONFIGS[protection];
+  const now = new Date().toISOString();
+  const normalized = (skillName || '').toLowerCase().replace(/^oh-my-claudecode:/, '');
+
+  const state = {
+    active: true,
+    skill_name: normalized,
+    session_id: sessionId || undefined,
+    started_at: now,
+    last_checked_at: now,
+    reinforcement_count: 0,
+    max_reinforcements: config.maxReinforcements,
+    stale_ttl_ms: config.staleTtlMs,
+  };
+
+  const stateDir = join(directory, '.omc', 'state');
+  const safeSessionId = sessionId && SESSION_ID_PATTERN.test(sessionId) ? sessionId : '';
+  const targetDir = safeSessionId
+    ? join(stateDir, 'sessions', safeSessionId)
+    : stateDir;
+  const targetPath = join(targetDir, 'skill-active-state.json');
+
+  try {
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+    }
+    const tmpPath = targetPath + '.tmp';
+    writeFileSync(tmpPath, JSON.stringify(state, null, 2), { mode: 0o600 });
+    renameSync(tmpPath, targetPath);
+  } catch {
+    // Best-effort; don't fail the hook
+  }
+}
+
 // Record Skill/Task invocations to flow trace (best-effort)
 async function recordToolInvocation(data, directory) {
   try {
@@ -252,6 +430,19 @@ async function main() {
     try { data = JSON.parse(input); } catch {}
     recordToolInvocation(data, directory);
 
+    // Activate skill state when Skill tool is invoked (issue #1033)
+    // Writes skill-active-state.json so the persistent-mode Stop hook can
+    // prevent premature session termination while a skill is executing.
+    if (toolName === 'Skill') {
+      const toolInput = data.toolInput || data.tool_input || {};
+      const skillName = extractSkillName(toolInput);
+      if (skillName) {
+        const sid = typeof data.session_id === 'string' ? data.session_id
+          : typeof data.sessionId === 'string' ? data.sessionId : '';
+        writeSkillActiveState(directory, skillName, sid);
+      }
+    }
+
     const sessionId =
       typeof data.session_id === 'string'
         ? data.session_id
@@ -287,6 +478,20 @@ async function main() {
 
     const todoStatus = getTodoStatus(directory);
 
+    if (AGENT_HEAVY_TOOLS.has(toolName)) {
+      const rawTranscriptPath = data.transcript_path || data.transcriptPath || '';
+      const transcriptPath = resolveTranscriptPath(rawTranscriptPath, directory);
+      const contextPercent = estimateContextPercent(transcriptPath);
+
+      if (contextPercent >= PREFLIGHT_CONTEXT_THRESHOLD) {
+        console.log(JSON.stringify({
+          decision: 'block',
+          reason: buildPreflightRecoveryAdvice(contextPercent),
+        }));
+        return;
+      }
+    }
+
     let message;
     if (toolName === 'Task' || toolName === 'TaskCreate' || toolName === 'TaskUpdate') {
       const toolInput = data.toolInput || data.tool_input || null;

package/scripts/run-provider-advisor.js

@@ -9,6 +9,7 @@ const PROVIDER_BINARIES = {
   codex: 'codex',
   gemini: 'gemini',
 };
+const SHOULD_USE_WINDOWS_SHELL = process.platform === 'win32';
 
 /**
  * Build CLI args for a given provider.
@@ -74,13 +75,37 @@ function parseArgs(argv) {
   return { provider, prompt: rest.join(' ').trim() };
 }
 
-function ensureBinary(binary) {
+const CODEX_STRIPPED_ENV_VARS = new Set(['RUST_LOG', 'RUST_BACKTRACE', 'RUST_LIB_BACKTRACE']);
+
+function buildProviderEnv(provider, env = process.env) {
+  if (provider !== 'codex') {
+    return env;
+  }
+
+  return Object.fromEntries(
+    Object.entries(env).filter(([key]) => !CODEX_STRIPPED_ENV_VARS.has(key)),
+  );
+}
+
+function ensureBinary(provider, binary) {
   const probe = spawnSync(binary, ['--version'], {
     stdio: 'ignore',
     encoding: 'utf8',
+    env: buildProviderEnv(provider),
+    shell: SHOULD_USE_WINDOWS_SHELL,
   });
 
-  if (probe.error && probe.error.code === 'ENOENT') {
+  const isMissingOnWindowsShell = SHOULD_USE_WINDOWS_SHELL
+    && probe.status !== 0
+    && (() => {
+      const whereResult = spawnSync('where', [binary], {
+        encoding: 'utf8',
+        env: buildProviderEnv(provider),
+      });
+      return whereResult.status !== 0 || !whereResult.stdout?.trim();
+    })();
+
+  if ((probe.error && probe.error.code === 'ENOENT') || isMissingOnWindowsShell) {
     const verify = `${binary} --version`;
     console.error(`[ask-${binary}] Missing required local CLI binary: ${binary}`);
     console.error(`[ask-${binary}] Install/configure ${binary} CLI, then verify with: ${verify}`);
@@ -182,12 +207,14 @@ async function main() {
   const { provider, prompt } = parseArgs(process.argv.slice(2));
   const binary = PROVIDER_BINARIES[provider];
 
-  ensureBinary(binary);
+  ensureBinary(provider, binary);
 
   const providerArgs = buildProviderArgs(provider, prompt);
   const run = spawnSync(binary, providerArgs, {
     encoding: 'utf8',
     maxBuffer: 10 * 1024 * 1024,
+    env: buildProviderEnv(provider),
+    shell: SHOULD_USE_WINDOWS_SHELL,
   });
 
   const stdout = run.stdout || '';

package/scripts/session-start.mjs

@@ -353,7 +353,7 @@ async function main() {
 You have an active ultrawork session from ${ultraworkState.started_at}.
 Original task: ${ultraworkState.original_prompt}
 
-Continue working in ultrawork mode until all tasks are complete.
+Treat this as prior-session context only. Prioritize the user's newest request, and resume ultrawork only if the user explicitly asks to continue it.
 
 </session-restore>
 
@@ -387,7 +387,7 @@ You have an active ralph-loop session.
 Original task: ${ralphState.prompt || 'Task in progress'}
 Iteration: ${ralphState.iteration || 1}/${ralphState.max_iterations || 10}
 
-Continue working until the task is verified complete.
+Treat this as prior-session context only. Prioritize the user's newest request, and resume the ralph loop only if the user explicitly asks to continue it.
 
 </session-restore>
 
@@ -420,7 +420,7 @@ Continue working until the task is verified complete.
 [PENDING TASKS DETECTED]
 
 You have ${incompleteCount} incomplete tasks from a previous session.
-Please continue working on these tasks.
+Treat this as prior-session context only. Prioritize the user's newest request, and resume these tasks only if the user explicitly asks to continue them.
 
 </session-restore>
 

package/scripts/setup-claude-md.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+# setup-claude-md.sh - Unified CLAUDE.md download/merge script
+# Usage: setup-claude-md.sh <local|global>
+#
+# Handles: version extraction, backup, download, marker stripping, merge, version reporting.
+# For global mode, also cleans up legacy hooks.
+
+set -euo pipefail
+
+MODE="${1:?Usage: setup-claude-md.sh <local|global>}"
+DOWNLOAD_URL="https://raw.githubusercontent.com/Yeachan-Heo/oh-my-claudecode/main/docs/CLAUDE.md"
+
+# Determine target path
+if [ "$MODE" = "local" ]; then
+  mkdir -p .claude
+  TARGET_PATH=".claude/CLAUDE.md"
+elif [ "$MODE" = "global" ]; then
+  TARGET_PATH="$HOME/.claude/CLAUDE.md"
+else
+  echo "ERROR: Invalid mode '$MODE'. Use 'local' or 'global'." >&2
+  exit 1
+fi
+
+# Extract old version before download
+OLD_VERSION=$(grep -m1 'OMC:VERSION:' "$TARGET_PATH" 2>/dev/null | sed -E 's/.*OMC:VERSION:([^ ]+).*/\1/' || true)
+if [ -z "$OLD_VERSION" ]; then
+  OLD_VERSION=$(omc --version 2>/dev/null | head -1 || true)
+fi
+if [ -z "$OLD_VERSION" ]; then
+  OLD_VERSION="none"
+fi
+
+# Backup existing
+if [ -f "$TARGET_PATH" ]; then
+  BACKUP_DATE=$(date +%Y-%m-%d_%H%M%S)
+  BACKUP_PATH="${TARGET_PATH}.backup.${BACKUP_DATE}"
+  cp "$TARGET_PATH" "$BACKUP_PATH"
+  echo "Backed up existing CLAUDE.md to $BACKUP_PATH"
+fi
+
+# Download fresh OMC content to temp file
+TEMP_OMC=$(mktemp /tmp/omc-claude-XXXXXX.md)
+trap 'rm -f "$TEMP_OMC"' EXIT
+curl -fsSL "$DOWNLOAD_URL" -o "$TEMP_OMC"
+
+if [ ! -s "$TEMP_OMC" ]; then
+  echo "ERROR: Failed to download CLAUDE.md. Aborting."
+  echo "FALLBACK: Manually download from: $DOWNLOAD_URL"
+  rm -f "$TEMP_OMC"
+  exit 1
+fi
+
+# Strip existing markers from downloaded content (idempotency)
+# Use awk for cross-platform compatibility (GNU/BSD)
+if grep -q '<!-- OMC:START -->' "$TEMP_OMC"; then
+  awk '/<!-- OMC:END -->/{p=0} p; /<!-- OMC:START -->/{p=1}' "$TEMP_OMC" > "${TEMP_OMC}.clean"
+  mv "${TEMP_OMC}.clean" "$TEMP_OMC"
+fi
+
+if [ ! -f "$TARGET_PATH" ]; then
+  # Fresh install: wrap in markers
+  {
+    echo '<!-- OMC:START -->'
+    cat "$TEMP_OMC"
+    echo '<!-- OMC:END -->'
+  } > "$TARGET_PATH"
+  rm -f "$TEMP_OMC"
+  echo "Installed CLAUDE.md (fresh)"
+else
+  # Merge: preserve user content outside OMC markers
+  if grep -q '<!-- OMC:START -->' "$TARGET_PATH"; then
+    # Has markers: remove ALL complete OMC blocks, preserve only real user text
+    # Use perl -0 for a global multiline regex replace (portable across GNU/BSD environments)
+    perl -0pe 's/^<!-- OMC:START -->\R[\s\S]*?^<!-- OMC:END -->(?:\R)?//msg; s/^<!-- User customizations(?: \([^)]+\))? -->\R?//mg; s/\A(?:[ \t]*\R)+//; s/(?:\R[ \t]*)+\z//;' \
+      "$TARGET_PATH" > "${TARGET_PATH}.preserved"
+
+    if grep -Eq '^<!-- OMC:(START|END) -->$' "${TARGET_PATH}.preserved"; then
+      # Corrupted/unmatched markers remain: preserve the whole original file for manual recovery
+      OLD_CONTENT=$(cat "$TARGET_PATH")
+      {
+        echo '<!-- OMC:START -->'
+        cat "$TEMP_OMC"
+        echo '<!-- OMC:END -->'
+        echo ""
+        echo "<!-- User customizations (recovered from corrupted markers) -->"
+        printf '%s\n' "$OLD_CONTENT"
+      } > "${TARGET_PATH}.tmp"
+    else
+      PRESERVED_CONTENT=$(cat "${TARGET_PATH}.preserved")
+      {
+        echo '<!-- OMC:START -->'
+        cat "$TEMP_OMC"
+        echo '<!-- OMC:END -->'
+        if printf '%s' "$PRESERVED_CONTENT" | grep -q '[^[:space:]]'; then
+          echo ""
+          echo "<!-- User customizations -->"
+          printf '%s\n' "$PRESERVED_CONTENT"
+        fi
+      } > "${TARGET_PATH}.tmp"
+    fi
+
+    mv "${TARGET_PATH}.tmp" "$TARGET_PATH"
+    rm -f "${TARGET_PATH}.preserved"
+    echo "Updated OMC section (user customizations preserved)"
+  else
+    # No markers: wrap new content in markers, append old content as user section
+    OLD_CONTENT=$(cat "$TARGET_PATH")
+    {
+      echo '<!-- OMC:START -->'
+      cat "$TEMP_OMC"
+      echo '<!-- OMC:END -->'
+      echo ""
+      echo "<!-- User customizations (migrated from previous CLAUDE.md) -->"
+      printf '%s\n' "$OLD_CONTENT"
+    } > "${TARGET_PATH}.tmp"
+    mv "${TARGET_PATH}.tmp" "$TARGET_PATH"
+    echo "Migrated existing CLAUDE.md (added OMC markers, preserved old content)"
+  fi
+  rm -f "$TEMP_OMC"
+fi
+
+# Extract new version and report
+NEW_VERSION=$(grep -m1 'OMC:VERSION:' "$TARGET_PATH" 2>/dev/null | sed -E 's/.*OMC:VERSION:([^ ]+).*/\1/' || true)
+if [ -z "$NEW_VERSION" ]; then
+  NEW_VERSION=$(omc --version 2>/dev/null | head -1 || true)
+fi
+if [ -z "$NEW_VERSION" ]; then
+  NEW_VERSION="unknown"
+fi
+if [ "$OLD_VERSION" = "none" ]; then
+  echo "Installed CLAUDE.md: $NEW_VERSION"
+elif [ "$OLD_VERSION" = "$NEW_VERSION" ]; then
+  echo "CLAUDE.md unchanged: $NEW_VERSION"
+else
+  echo "Updated CLAUDE.md: $OLD_VERSION -> $NEW_VERSION"
+fi
+
+# Legacy hooks cleanup (global mode only)
+if [ "$MODE" = "global" ]; then
+  rm -f ~/.claude/hooks/keyword-detector.sh
+  rm -f ~/.claude/hooks/stop-continuation.sh
+  rm -f ~/.claude/hooks/persistent-mode.sh
+  rm -f ~/.claude/hooks/session-start.sh
+  echo "Legacy hooks cleaned"
+
+  # Check for manual hook entries in settings.json
+  SETTINGS_FILE="$HOME/.claude/settings.json"
+  if [ -f "$SETTINGS_FILE" ]; then
+    if jq -e '.hooks' "$SETTINGS_FILE" > /dev/null 2>&1; then
+      echo ""
+      echo "NOTE: Found legacy hooks in settings.json. These should be removed since"
+      echo "the plugin now provides hooks automatically. Remove the \"hooks\" section"
+      echo "from ~/.claude/settings.json to prevent duplicate hook execution."
+    fi
+  fi
+fi
+
+# Verify plugin installation
+grep -q "oh-my-claudecode" ~/.claude/settings.json && echo "Plugin verified" || echo "Plugin NOT found - run: claude /install-plugin oh-my-claudecode"