@vinaes/succ 1.4.0 → 1.5.42

package/dist/commands/init.js

@@ -2,17 +2,83 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
 import { select, input, password } from '@inquirer/prompts';
 import ora from 'ora';
 import isInstalledGlobally from 'is-installed-globally';
-import { getProjectRoot, getSuccDir, isOnboardingCompleted, markOnboardingCompleted, } from '../lib/config.js';
+import { getProjectRoot, getSuccDir, getConfig, isOnboardingCompleted, markOnboardingCompleted, } from '../lib/config.js';
 import { runStaticWizard, runAiOnboarding } from '../lib/onboarding/index.js';
 import { logWarn } from '../lib/fault-logger.js';
 import { getSoulTemplate, getLearningsTemplate, getContextRulesTemplate, getInboxMocTemplate, getProjectMocTemplate, getDecisionsMocTemplate, getFeaturesMocTemplate, getFilesMocTemplate, getTechnicalMocTemplate, getSystemsMocTemplate, getStrategyMocTemplate, getSessionsMocTemplate, getKnowledgeMocTemplate, getArchiveMocTemplate, getPrdMocTemplate, getCommunicationMocTemplate, } from './init-templates.js';
+import { getStablePort } from '../lib/daemon-port.js';
 // Get the directory where succ is installed
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const SUCC_PACKAGE_DIR = path.resolve(__dirname, '..', '..');
+/** Check if a URL points to a known cloud LLM provider */
+function isCloudProvider(url) {
+    try {
+        const hostname = new URL(url).hostname;
+        return (hostname === 'openrouter.ai' ||
+            hostname.endsWith('.openrouter.ai') ||
+            hostname === 'openai.com' ||
+            hostname.endsWith('.openai.com'));
+    }
+    catch {
+        return false;
+    }
+}
+/** Detect Claude Code CLI version. Returns null if not installed. */
+function getClaudeCodeVersion() {
+    try {
+        const stdout = execFileSync('claude', ['--version'], {
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf8',
+        });
+        const match = stdout.match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Check if version supports HTTP hooks (v2.1.63+) */
+function supportsHttpHooks(version) {
+    if (!version)
+        return false;
+    const parts = version.split('.').map(Number);
+    if (parts.length < 3)
+        return false;
+    const [major, minor, patch] = parts;
+    if (major > 2)
+        return true;
+    if (major === 2 && minor > 1)
+        return true;
+    if (major === 2 && minor === 1 && patch >= 63)
+        return true;
+    return false;
+}
+/** Check if a hook entry belongs to succ (command or HTTP) */
+function isSuccHook(h) {
+    const hooks = h.hooks;
+    if (!hooks || hooks.length === 0)
+        return false;
+    const hook = hooks[0];
+    const cmd = hook.command || '';
+    const url = hook.url || '';
+    // Command hooks
+    if (cmd.includes('.succ/hooks/') ||
+        cmd.includes('/hooks/succ-') ||
+        cmd.includes('\\hooks\\succ-'))
+        return true;
+    if (/succ-(session|stop|user|post|pre)-/.test(cmd))
+        return true;
+    // HTTP hooks
+    if (url.includes('/api/hooks/'))
+        return true;
+    return false;
+}
 export async function init(options = {}) {
     const projectRoot = getProjectRoot();
     const succDir = getSuccDir();
@@ -21,11 +87,6 @@ export async function init(options = {}) {
     // Determine if running in global mode
     // --global flag forces global mode (for testing), otherwise auto-detect
     const useGlobalHooks = options.global || isInstalledGlobally;
-    // Check if already initialized
-    if (fs.existsSync(path.join(succDir, 'succ.db')) && !options.force) {
-        console.log('succ is already initialized. Use --force to reinitialize.');
-        return;
-    }
     // Create directories - flat brain vault structure (no numbered prefixes)
     const projectName = path.basename(projectRoot);
     const dirs = [
@@ -153,30 +214,46 @@ export async function init(options = {}) {
             'succ-user-prompt.cjs',
             'succ-post-tool.cjs',
             'succ-pre-tool.cjs',
+            'succ-pre-compact.cjs',
         ];
         for (const hookFile of hooksToCreate) {
             const destPath = path.join(succDir, 'hooks', hookFile);
             const srcPath = path.join(SUCC_PACKAGE_DIR, 'hooks', hookFile);
-            if (!fs.existsSync(destPath) || options.force) {
-                // Try to copy from package hooks/ directory (source of truth)
-                if (fs.existsSync(srcPath)) {
-                    fs.copyFileSync(srcPath, destPath);
-                    log(options.force && fs.existsSync(destPath)
-                        ? `Updated hooks/${hookFile}`
-                        : `Created hooks/${hookFile}`);
-                }
-                else {
-                    // Fallback to inline templates for backwards compatibility
+            const existed = fs.existsSync(destPath);
+            // Always overwrite hook scripts so re-running `succ init` keeps them
+            // at the version shipped with the current package. This is intentional:
+            // hooks are generated files, not user-editable.
+            if (fs.existsSync(srcPath)) {
+                fs.copyFileSync(srcPath, destPath);
+                log(existed ? `Updated hooks/${hookFile}` : `Created hooks/${hookFile}`);
+            }
+            else {
+                // Fallback to inline templates for backwards compatibility
+                if (!existed || options.force) {
                     const hookContent = getHookContent(hookFile);
                     if (hookContent) {
                         fs.writeFileSync(destPath, hookContent);
-                        log(options.force && fs.existsSync(destPath)
-                            ? `Updated hooks/${hookFile}`
-                            : `Created hooks/${hookFile}`);
+                        log(existed ? `Updated hooks/${hookFile}` : `Created hooks/${hookFile}`);
                     }
                 }
             }
         }
+        // Copy hooks/core/ shared modules (adapter, daemon-boot)
+        // Always overwrite so re-runs stay in sync with the installed package.
+        const coreSrcDir = path.join(SUCC_PACKAGE_DIR, 'hooks', 'core');
+        const coreDestDir = path.join(succDir, 'hooks', 'core');
+        if (fs.existsSync(coreSrcDir)) {
+            if (!fs.existsSync(coreDestDir)) {
+                fs.mkdirSync(coreDestDir, { recursive: true });
+            }
+            const coreFiles = fs.readdirSync(coreSrcDir).filter((f) => f.endsWith('.cjs'));
+            for (const coreFile of coreFiles) {
+                const dest = path.join(coreDestDir, coreFile);
+                const existed = fs.existsSync(dest);
+                fs.copyFileSync(path.join(coreSrcDir, coreFile), dest);
+                log(existed ? `Updated hooks/core/${coreFile}` : `Created hooks/core/${coreFile}`);
+            }
+        }
     }
     // Create or merge settings.json in .claude/ (Claude Code looks for it there)
     const claudeDir = path.join(projectRoot, '.claude');
@@ -227,223 +304,190 @@ export async function init(options = {}) {
     }
     const settingsPath = path.join(claudeDir, 'settings.json');
     const settingsExisted = fs.existsSync(settingsPath);
-    if (!settingsExisted || options.force) {
+    {
+        // Always install/update hooks and settings so re-running `succ init` on an existing
+        // project updates hooks to the latest version. The merge logic inside preserves
+        // existing permissions and any non-succ hooks.
         // Determine hooks path based on installation mode
-        // Global install: hooks are in the succ package directory
-        // Local dev: hooks are copied to .succ/hooks/ in the project
+        // Use $CLAUDE_PROJECT_DIR for portability (works regardless of cwd)
         const hooksPath = useGlobalHooks
             ? path.join(SUCC_PACKAGE_DIR, 'hooks').replace(/\\/g, '/')
-            : '.succ/hooks';
+            : '$CLAUDE_PROJECT_DIR/.succ/hooks';
+        // Detect Claude Code version for HTTP hooks support
+        const claudeVersion = getClaudeCodeVersion();
+        const useHttp = supportsHttpHooks(claudeVersion);
+        // Compute stable port for HTTP hook URLs (getConfig merges global + project config)
+        const mergedConfig = getConfig();
+        const hookPort = mergedConfig.daemon?.port ?? getStablePort(projectRoot);
+        const baseUrl = `http://127.0.0.1:${hookPort}/api/hooks`;
         if (verbose) {
             console.log(`  Installation mode: ${useGlobalHooks ? 'global' : 'local development'}`);
             console.log(`  Hooks path: ${hooksPath}`);
+            console.log(`  Claude Code version: ${claudeVersion || 'not detected'}`);
+            console.log(`  HTTP hooks: ${useHttp ? 'yes' : 'no (command fallback)'}`);
+            console.log(`  Hook port: ${hookPort}`);
         }
-        // Define succ hooks
-        // Hook files prefixed with "succ-" to avoid conflicts with other hooks
+        // Helper to build a command hook entry
+        const cmdHook = (script, timeout, statusMsg) => ({
+            type: 'command',
+            command: `node --no-warnings --no-deprecation "${hooksPath}/${script}"`,
+            timeout,
+            statusMessage: statusMsg,
+        });
+        // Helper to build an HTTP hook entry
+        const httpHook = (route, timeout, statusMsg) => ({
+            type: 'http',
+            url: `${baseUrl}/${route}`,
+            timeout,
+            statusMessage: statusMsg,
+        });
+        // Define succ hooks — HTTP when supported, command fallback
         const succHooks = {
+            // Command-only events (Claude Code limitation)
             SessionStart: [
                 {
-                    hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-session-start.cjs"`,
-                            timeout: 10,
-                        },
-                    ],
+                    hooks: [cmdHook('succ-session-start.cjs', 10, 'succ: loading context...')],
                 },
             ],
-            Stop: [
+            SessionEnd: [
                 {
-                    hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-stop-reflection.cjs"`,
-                            timeout: 60,
-                        },
-                    ],
+                    hooks: [cmdHook('succ-session-end.cjs', 60, 'succ: saving session...')],
                 },
             ],
-            SessionEnd: [
+            // HTTP when supported, command fallback
+            Stop: [
                 {
                     hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-session-end.cjs"`,
-                            timeout: 60,
-                        },
+                        useHttp
+                            ? httpHook('stop', 60, 'succ: recording activity...')
+                            : cmdHook('succ-stop-reflection.cjs', 60, 'succ: recording activity...'),
                     ],
                 },
             ],
             UserPromptSubmit: [
                 {
                     hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-user-prompt.cjs"`,
-                            timeout: 10,
-                        },
+                        useHttp
+                            ? httpHook('user-prompt', 10, 'succ: checking context...')
+                            : cmdHook('succ-user-prompt.cjs', 10, 'succ: checking context...'),
                     ],
                 },
             ],
             PostToolUse: [
                 {
                     hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-post-tool.cjs"`,
-                            timeout: 5,
-                        },
+                        useHttp
+                            ? httpHook('post-tool', 5, 'succ: capturing...')
+                            : cmdHook('succ-post-tool.cjs', 5, 'succ: capturing...'),
                     ],
                 },
             ],
             PreToolUse: [
                 {
-                    matcher: 'Bash',
                     hooks: [
-                        {
-                            type: 'command',
-                            command: `node --no-warnings --no-deprecation "${hooksPath}/succ-pre-tool.cjs"`,
-                            timeout: 10,
-                        },
+                        useHttp
+                            ? httpHook('pre-tool', 10, 'succ: checking rules...')
+                            : cmdHook('succ-pre-tool.cjs', 10, 'succ: checking rules...'),
                     ],
                 },
             ],
+            // PreCompact — command-only (Claude Code limitation)
+            PreCompact: [
+                {
+                    hooks: [cmdHook('succ-pre-compact.cjs', 5, 'succ: analyzing session...')],
+                },
+            ],
+            // New hooks (HTTP only, no command fallback needed)
+            ...(useHttp
+                ? {
+                    PermissionRequest: [
+                        {
+                            hooks: [httpHook('permission', 5, 'succ: checking permission rules...')],
+                        },
+                    ],
+                    SubagentStop: [
+                        {
+                            hooks: [httpHook('subagent-stop', 5, 'succ: saving agent results...')],
+                        },
+                    ],
+                    TaskCompleted: [
+                        {
+                            hooks: [httpHook('task-completed', 5, 'succ: consolidating...')],
+                        },
+                    ],
+                }
+                : {}),
         };
         let finalSettings;
-        if (settingsExisted && !options.force) {
-            // Merge with existing settings (non-force mode)
-            try {
-                const existingContent = fs.readFileSync(settingsPath, 'utf-8');
-                const existingSettings = JSON.parse(existingContent);
-                // Preserve all existing settings
-                finalSettings = { ...existingSettings };
-                // Ensure hooks object exists
-                if (!finalSettings.hooks) {
-                    finalSettings.hooks = {};
+        // Unified merge logic: strip old succ hooks (command + HTTP), add fresh ones.
+        // Works for both merge and force modes — always upgrades hook transport.
+        const stripAndAddSuccHooks = (existingSettings) => {
+            const settings = { ...existingSettings };
+            if (!settings.hooks)
+                settings.hooks = {};
+            // Strip all existing succ hooks from every event type
+            for (const [hookType, hookConfig] of Object.entries(settings.hooks)) {
+                if (!Array.isArray(hookConfig))
+                    continue;
+                const nonSucc = hookConfig.filter((h) => !isSuccHook(h));
+                if (nonSucc.length > 0) {
+                    settings.hooks[hookType] = nonSucc;
                 }
-                // Merge hooks: add succ hooks without duplicating
-                for (const [hookType, hookConfig] of Object.entries(succHooks)) {
-                    if (!finalSettings.hooks[hookType]) {
-                        // No existing hooks of this type, just add ours
-                        finalSettings.hooks[hookType] = hookConfig;
-                    }
-                    else {
-                        const existingHooks = finalSettings.hooks[hookType];
-                        const succHookEntries = hookConfig;
-                        for (const succEntry of succHookEntries) {
-                            // Check if this exact succ hook is already present
-                            const succCommand = succEntry.hooks?.[0]?.command || '';
-                            const succMatcher = succEntry.matcher || '';
-                            const alreadyExists = existingHooks.some((existing) => {
-                                const existingCommand = existing.hooks?.[0]?.command || '';
-                                // Check for succ hook files (prefixed with "succ-")
-                                if (succCommand.includes('succ-session-start.cjs') &&
-                                    existingCommand.includes('succ-session-start.cjs'))
-                                    return true;
-                                if (succCommand.includes('succ-session-end.cjs') &&
-                                    existingCommand.includes('succ-session-end.cjs'))
-                                    return true;
-                                if (succCommand.includes('succ-stop-reflection.cjs') &&
-                                    existingCommand.includes('succ-stop-reflection.cjs'))
-                                    return true;
-                                if (succCommand.includes('succ-user-prompt.cjs') &&
-                                    existingCommand.includes('succ-user-prompt.cjs'))
-                                    return true;
-                                if (succCommand.includes('succ-post-tool.cjs') &&
-                                    existingCommand.includes('succ-post-tool.cjs'))
-                                    return true;
-                                if (succCommand.includes('succ-pre-tool.cjs') &&
-                                    existingCommand.includes('succ-pre-tool.cjs'))
-                                    return true;
-                                // For Notification hooks, check matcher
-                                if (succMatcher && existing.matcher === succMatcher)
-                                    return true;
-                                return false;
-                            });
-                            if (!alreadyExists) {
-                                existingHooks.push(succEntry);
-                            }
-                        }
-                    }
+                else {
+                    delete settings.hooks[hookType];
                 }
-                log('Merged settings.json (preserved existing permissions and hooks)');
             }
-            catch {
-                // Failed to parse existing, create new
-                finalSettings = { hooks: succHooks };
-                log('Created settings.json (failed to parse existing)');
+            // Add fresh succ hooks
+            for (const [hookType, hookConfig] of Object.entries(succHooks)) {
+                const entries = hookConfig;
+                if (entries.length === 0)
+                    continue;
+                if (!settings.hooks[hookType]) {
+                    settings.hooks[hookType] = entries;
+                }
+                else {
+                    settings.hooks[hookType] = [...settings.hooks[hookType], ...entries];
+                }
             }
-        }
-        else if (settingsExisted && options.force) {
-            // Force mode: replace succ hooks but preserve other settings
+            return settings;
+        };
+        if (settingsExisted) {
             try {
                 const existingContent = fs.readFileSync(settingsPath, 'utf-8');
-                const existingSettings = JSON.parse(existingContent);
-                // Preserve non-hook settings (permissions, etc.)
-                finalSettings = { ...existingSettings };
-                // Replace hooks entirely with new succ hooks
-                // but preserve any non-succ hooks
-                if (finalSettings.hooks) {
-                    for (const [hookType, hookConfig] of Object.entries(finalSettings.hooks)) {
-                        const existingHooks = hookConfig;
-                        // Filter out old succ hooks (both old names and new "succ-" prefixed names)
-                        const nonSuccHooks = existingHooks.filter((h) => {
-                            const cmd = h.hooks?.[0]?.command || '';
-                            // Remove hooks in .succ/hooks/ directory (local dev)
-                            if (cmd.includes('.succ/hooks/'))
-                                return false;
-                            // Remove hooks from global succ install (contains /hooks/succ- pattern)
-                            if (cmd.includes('/hooks/succ-') || cmd.includes('\\hooks\\succ-'))
-                                return false;
-                            // Also remove any legacy hooks with succ hook names
-                            if (cmd.includes('session-start.cjs') ||
-                                cmd.includes('session-end.cjs') ||
-                                cmd.includes('stop-reflection.cjs') ||
-                                cmd.includes('user-prompt.cjs') ||
-                                cmd.includes('post-tool.cjs') ||
-                                cmd.includes('pre-tool.cjs') ||
-                                cmd.includes('idle-reflection.cjs'))
-                                return false;
-                            return true;
-                        });
-                        if (nonSuccHooks.length > 0) {
-                            finalSettings.hooks[hookType] = nonSuccHooks;
-                        }
-                        else {
-                            delete finalSettings.hooks[hookType];
-                        }
-                    }
+                const parsed = JSON.parse(existingContent);
+                // Guard against valid JSON that isn't a plain object (null, array, primitive).
+                // Spreading a non-object would silently discard the value or throw at runtime.
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                    throw new Error(`settings.json contains ${parsed === null ? 'null' : Array.isArray(parsed) ? 'an array' : `a ${typeof parsed}`} — expected a plain object`);
                 }
-                // Now add fresh succ hooks
-                if (!finalSettings.hooks) {
-                    finalSettings.hooks = {};
-                }
-                for (const [hookType, hookConfig] of Object.entries(succHooks)) {
-                    if (!finalSettings.hooks[hookType]) {
-                        finalSettings.hooks[hookType] = hookConfig;
-                    }
-                    else {
-                        finalSettings.hooks[hookType] = [
-                            ...finalSettings.hooks[hookType],
-                            ...hookConfig,
-                        ];
-                    }
-                }
-                log('Replaced succ hooks in settings.json (--force)');
+                const existingSettings = parsed;
+                finalSettings = stripAndAddSuccHooks(existingSettings);
+                log(options.force
+                    ? 'Replaced succ hooks in settings.json (--force)'
+                    : 'Merged settings.json (preserved existing permissions and hooks)');
             }
-            catch {
-                // Failed to parse existing, create new
+            catch (error) {
+                logWarn('init', 'Failed to parse existing Claude settings.json for hook merge', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
                 finalSettings = { hooks: succHooks };
                 log('Created settings.json (failed to parse existing)');
             }
         }
         else {
-            // Create new settings
             finalSettings = { hooks: succHooks };
             log('Created settings.json');
         }
         fs.writeFileSync(settingsPath, JSON.stringify(finalSettings, null, 2));
     }
+    // Check if already initialized (after hooks/settings so re-runs always refresh them)
+    if (fs.existsSync(path.join(succDir, 'succ.db')) && !options.force) {
+        // Always reconcile MCP server config even if DB exists — ensures older installs
+        // or previous failures get the Claude entry added.
+        addMcpServer(projectRoot);
+        spinner.succeed('succ hooks/settings refreshed (already initialized).');
+        return;
+    }
     // Note: All hooks are now created in the earlier block using copyFileSync from hooks/ directory
     // Add MCP server to Claude Code config
     const mcpResult = addMcpServer(projectRoot);
@@ -506,7 +550,7 @@ async function runOnboarding(useAi) {
         return;
     }
     // Ask for onboarding style (unless --ai flag was used)
-    let onboardingStyle = 'quick';
+    let onboardingStyle;
     if (useAi) {
         onboardingStyle = 'interactive';
     }
@@ -576,6 +620,22 @@ async function runInteractiveSetup(projectRoot, _verbose = false) {
             default: 'global',
         });
         const targetConfig = configScope === 'global' ? newGlobalConfig : newProjectConfig;
+        // When user chose global scope, warn if project config already contains LLM overrides.
+        // Project-level llm keys take precedence over global, so stale entries can shadow the
+        // new global settings the wizard is about to write.
+        if (configScope === 'global' && fs.existsSync(projectConfigPath)) {
+            try {
+                const existingProjectCfg = JSON.parse(fs.readFileSync(projectConfigPath, 'utf-8'));
+                if (existingProjectCfg?.llm && Object.keys(existingProjectCfg.llm).length > 0) {
+                    console.log('\n  \x1b[33mNote:\x1b[0m Your project config (.succ/config.json) has existing LLM');
+                    console.log('  settings that will override the global config for this project.');
+                    console.log('  Remove the `llm` key from .succ/config.json to use global settings.\n');
+                }
+            }
+            catch {
+                // Ignore parse errors — non-critical warning path
+            }
+        }
         // Step 2: Embedding mode
         console.log('\n┌─────────────────────────────────────────────────────────┐');
         console.log('│  succ converts text to vectors (embeddings) for search. │');
@@ -630,7 +690,7 @@ async function runInteractiveSetup(projectRoot, _verbose = false) {
             targetConfig.llm.embeddings.model = embeddingModel;
             targetConfig.llm.embeddings.dimensions = embeddingDimensions;
             // Prompt for API key if the URL looks like a cloud provider
-            if (embeddingApiUrl.includes('openrouter.ai') || embeddingApiUrl.includes('openai.com')) {
+            if (isCloudProvider(embeddingApiUrl)) {
                 const apiKey = await password({
                     message: 'API key:',
                     mask: '*',
@@ -691,8 +751,7 @@ async function runInteractiveSetup(projectRoot, _verbose = false) {
             targetConfig.llm.analyze.api_url = analyzeApiUrl;
             targetConfig.llm.analyze.model = analyzeModel;
             // Prompt for API key if cloud provider and not already set
-            if (!targetConfig.llm.api_key &&
-                (analyzeApiUrl.includes('openrouter.ai') || analyzeApiUrl.includes('openai.com'))) {
+            if (!targetConfig.llm.api_key && isCloudProvider(analyzeApiUrl)) {
                 const apiKey = await password({
                     message: 'API key:',
                     mask: '*',
@@ -751,30 +810,69 @@ async function runInteractiveSetup(projectRoot, _verbose = false) {
             console.log('\n  ✓ Background services disabled');
             console.log('    Run `succ index` and `succ analyze` manually when needed');
         }
-        // Save daemon config to target scope
-        if (daemonMode !== 'none') {
-            targetConfig.daemon = daemonConfig;
-        }
+        // Daemon settings are always written to the project config, never global.
+        // Background-service toggles are per-project: writing them to the global
+        // config would bleed across unrelated projects.
+        // When daemonMode is 'none', explicitly write a disabled block so that
+        // mergeAndWriteConfig's additive deep merge does not leave behind any
+        // pre-existing daemon.enabled / auto_start values set to true.
+        newProjectConfig.daemon =
+            daemonMode === 'none'
+                ? { enabled: false, watch: { auto_start: false }, analyze: { auto_start: false } }
+                : daemonConfig;
         console.log('');
-        // Save config to chosen scope
-        if (configScope === 'global') {
-            if (Object.keys(newGlobalConfig).length > 0) {
-                if (!fs.existsSync(globalConfigDir)) {
-                    fs.mkdirSync(globalConfigDir, { recursive: true });
+        // Save config to chosen scope — merge with existing to avoid overwriting
+        // user-configured fields (storage backend, Qdrant, custom settings, etc.)
+        const mergeAndWriteConfig = (configPath, configDir, newConfig) => {
+            if (Object.keys(newConfig).length === 0)
+                return;
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            let existing = {};
+            if (fs.existsSync(configPath)) {
+                try {
+                    const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                    if (typeof raw === 'object' && raw !== null && !Array.isArray(raw)) {
+                        existing = raw;
+                    }
+                    else {
+                        logWarn('init', `${configPath} is not a plain object — treating as empty`, {});
+                    }
+                }
+                catch (e) {
+                    logWarn('init', `Failed to parse existing ${configPath}, will overwrite`, {
+                        error: e instanceof Error ? e.message : String(e),
+                    });
                 }
-                fs.writeFileSync(globalConfigPath, JSON.stringify(newGlobalConfig, null, 2));
-                console.log(`  Saved: ${globalConfigPath}`);
             }
-        }
-        else {
-            if (Object.keys(newProjectConfig).length > 0) {
-                if (!fs.existsSync(projectConfigDir)) {
-                    fs.mkdirSync(projectConfigDir, { recursive: true });
+            // Deep merge: wizard keys override, but preserve keys not covered by wizard
+            const merged = { ...existing };
+            for (const [key, value] of Object.entries(newConfig)) {
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    merged[key] = { ...(existing[key] ?? {}), ...value };
+                    // One level deeper for nested objects (llm.embeddings, llm.analyze, daemon.watch, etc.)
+                    for (const [subKey, subValue] of Object.entries(value)) {
+                        if (typeof subValue === 'object' && subValue !== null && !Array.isArray(subValue)) {
+                            merged[key][subKey] = { ...(existing[key]?.[subKey] ?? {}), ...subValue };
+                        }
+                    }
+                }
+                else {
+                    merged[key] = value;
                 }
-                fs.writeFileSync(projectConfigPath, JSON.stringify(newProjectConfig, null, 2));
-                console.log(`  Saved: ${projectConfigPath}`);
             }
+            fs.writeFileSync(configPath, JSON.stringify(merged, null, 2));
+            const isNew = Object.keys(existing).length === 0;
+            console.log(`  ${isNew ? 'Created' : 'Merged into'}: ${configPath}`);
+        };
+        if (configScope === 'global') {
+            mergeAndWriteConfig(globalConfigPath, globalConfigDir, newGlobalConfig);
         }
+        // Always write project config — daemon settings are project-scoped even when
+        // embedding/analyze settings are global. mergeAndWriteConfig is a no-op when
+        // newProjectConfig is empty so this is safe for pure global setups.
+        mergeAndWriteConfig(projectConfigPath, projectConfigDir, newProjectConfig);
         // Final message
         console.log('\n┌─────────────────────────────────────────────────────────┐');
         console.log('│                    Setup Complete!                      │');
@@ -790,7 +888,8 @@ async function runInteractiveSetup(projectRoot, _verbose = false) {
     }
     catch (error) {
         // Handle Ctrl+C gracefully
-        if (error?.name === 'ExitPromptError' || error?.message?.includes('closed')) {
+        if (error instanceof Error &&
+            (error.name === 'ExitPromptError' || error.message?.includes('closed'))) {
             console.log('\n\n  Setup cancelled.\n');
             process.exit(0);
         }
@@ -837,7 +936,7 @@ function addMcpServer(_projectRoot) {
     }
     catch (error) {
         logWarn('init', `Failed to add MCP server to ${claudeConfigPath}`, { error: String(error) });
-        console.warn(`  Warning: Failed to add MCP server to ${claudeConfigPath}: ${error.message}`);
+        console.warn(`  Warning: Failed to add MCP server to ${claudeConfigPath}: ${error instanceof Error ? error.message : String(error)}`);
         logWarn('init', 'You can add it manually: succ init --force');
         console.warn('  You can add it manually: succ init --force');
         return 'failed';
@@ -857,7 +956,10 @@ function getHookContent(hookFile) {
             return fs.readFileSync(hookPath, 'utf-8');
         }
     }
-    catch {
+    catch (error) {
+        logWarn('init', 'Failed to read hook file from package directory', {
+            error: error instanceof Error ? error.message : String(error),
+        });
         // File read error
     }
     return null;