gnosys 5.1.0 → 5.2.0

package/dist/lib/setup.js

@@ -2,7 +2,8 @@
  * Gnosys Interactive Setup Wizard.
  *
  * Guides users through provider selection, model tier, API key storage,
- * IDE integration. Web knowledge base is set up separately via: gnosys web init
+ * task model configuration, and IDE integration.
+ * Web knowledge base is set up separately via: gnosys web init
  *
  * Uses Node.js built-in readline/promises — no external dependencies.
  */
@@ -13,6 +14,7 @@ import fsSync from "fs";
 import path from "path";
 import os from "os";
 import { execSync } from "child_process";
+import { loadConfig, updateConfig, getProviderModel, } from "./config.js";
 // ─── ANSI Colors ────────────────────────────────────────────────────────────
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
@@ -275,6 +277,14 @@ const PROVIDER_ORDER = [
     "lmstudio",
     "custom",
 ];
+// Task descriptions for display
+const TASK_DESCRIPTIONS = {
+    structuring: "adding memories, tagging",
+    synthesis: "Q&A answers",
+    vision: "images, PDFs",
+    transcription: "audio files",
+    dream: "overnight consolidation",
+};
 // ─── Exported Helpers ───────────────────────────────────────────────────────
 /**
  * Returns the cheapest capable model for structuring tasks.
@@ -329,6 +339,89 @@ export async function writeApiKey(provider, key) {
     }
     await fs.writeFile(envPath, lines.join("\n") + "\n", "utf-8");
 }
+/**
+ * Write an API key to the macOS Keychain.
+ * Uses the -U flag to update if the entry already exists.
+ * Returns true on success, false on failure.
+ */
+export function writeApiKeyToKeychain(envVar, key) {
+    if (process.platform !== "darwin")
+        return false;
+    try {
+        // The -U flag updates if the password already exists
+        execSync(`security add-generic-password -a "$USER" -s "${envVar}" -w "${key.replace(/"/g, '\\"')}" -U`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write an API key using Linux secret-tool (GNOME Keyring).
+ * Returns true on success, false on failure.
+ */
+function writeApiKeyToSecretTool(envVar, key, provider) {
+    if (process.platform === "darwin")
+        return false;
+    try {
+        // Check if secret-tool is available
+        execSync("which secret-tool", { stdio: "pipe" });
+        // Write the key — printf avoids trailing newline issues
+        execSync(`printf "%s" "${key.replace(/"/g, '\\"')}" | secret-tool store --label="Gnosys ${provider}" service gnosys account ${envVar}`, { stdio: "pipe", shell: "/bin/sh" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if secret-tool is available on Linux.
+ */
+function hasSecretTool() {
+    if (process.platform === "darwin")
+        return false;
+    try {
+        execSync("which secret-tool", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect where an existing API key is stored.
+ * Returns description like "macOS Keychain", "env var", ".env file", or empty string.
+ */
+function detectKeySource(envVarName, legacyEnvVar) {
+    // Check macOS Keychain
+    if (process.platform === "darwin") {
+        try {
+            const result = execSync(`security find-generic-password -a "$USER" -s "${envVarName}" -w`, { stdio: "pipe", encoding: "utf-8" }).trim();
+            if (result)
+                return "macOS Keychain";
+        }
+        catch {
+            // Not in keychain
+        }
+    }
+    // Check environment variable (new-style)
+    if (process.env[envVarName])
+        return `$${envVarName}`;
+    // Check legacy env var
+    if (legacyEnvVar && process.env[legacyEnvVar])
+        return `$${legacyEnvVar}`;
+    // Check .env file
+    try {
+        const envPath = path.join(os.homedir(), ".config", "gnosys", ".env");
+        const content = fsSync.readFileSync(envPath, "utf-8");
+        if (content.includes(`${envVarName}=`))
+            return "~/.config/gnosys/.env";
+    }
+    catch {
+        // No .env
+    }
+    return "";
+}
 /**
  * Detect which IDEs are available in the given project directory.
  * Returns an array like ["claude", "cursor", "codex"].
@@ -440,7 +533,8 @@ export async function setupIDE(ide, projectDir) {
  */
 async function askChoice(rl, question, options) {
     console.log();
-    console.log(question);
+    if (question)
+        console.log(question);
     console.log();
     for (let i = 0; i < options.length; i++) {
         console.log(`  ${BOLD}${i + 1}.${RESET} ${options[i]}`);
@@ -485,6 +579,7 @@ function formatPrice(input, output) {
 }
 /**
  * Print a bordered box with a title and key-value rows.
+ * Supports rows with empty keys (spacer rows) and section headers.
  */
 function printBox(title, rows) {
     const maxKeyLen = Math.max(...rows.map(([k]) => k.length));
@@ -497,8 +592,14 @@ function printBox(title, rows) {
     console.log(`\u2502  ${BOLD}${title}${RESET}${" ".repeat(innerWidth - title.length - 2)}\u2502`);
     console.log(`\u251C${border}\u2524`);
     for (const [key, val] of rows) {
-        const line = `${key.padEnd(maxKeyLen)}  ${val}`;
-        console.log(`\u2502  ${line}${" ".repeat(innerWidth - line.length - 2)}\u2502`);
+        if (key === "" && val === "") {
+            // Spacer row
+            console.log(`\u2502${" ".repeat(innerWidth)}\u2502`);
+        }
+        else {
+            const line = `${key.padEnd(maxKeyLen)}  ${val}`;
+            console.log(`\u2502  ${line}${" ".repeat(innerWidth - line.length - 2)}\u2502`);
+        }
     }
     console.log(`\u2514${border}\u2518`);
     console.log();
@@ -535,6 +636,77 @@ async function getRegisteredProjects() {
     }
     return projects;
 }
+/**
+ * Try to load existing gnosys.json config for displaying current values.
+ * Checks the project .gnosys dir first, then the global ~/.gnosys dir.
+ * Returns null if no config found.
+ */
+async function loadExistingConfig(projectDir) {
+    // Try project-level config first
+    try {
+        const projectStore = path.join(projectDir, ".gnosys");
+        const stat = await fs.stat(path.join(projectStore, "gnosys.json"));
+        if (stat.isFile()) {
+            return await loadConfig(projectStore);
+        }
+    }
+    catch {
+        // No project config
+    }
+    // Try global config at ~/.gnosys
+    try {
+        const globalStore = path.join(os.homedir(), ".gnosys");
+        const stat = await fs.stat(path.join(globalStore, "gnosys.json"));
+        if (stat.isFile()) {
+            return await loadConfig(globalStore);
+        }
+    }
+    catch {
+        // No global config
+    }
+    return null;
+}
+/**
+ * Let the user pick a provider from the list.
+ * Returns the provider name or "skip".
+ * If currentProvider is given, shows it as the current value.
+ */
+async function pickProvider(rl, dynamicModels, stepLabel, currentProvider) {
+    const currentHint = currentProvider ? ` ${DIM}(current: ${currentProvider})${RESET}` : "";
+    const providerOptions = PROVIDER_ORDER.map((key) => {
+        const tiers = dynamicModels[key] ?? PROVIDER_TIERS[key];
+        const display = PROVIDER_DISPLAY[key];
+        if (!tiers || tiers.length === 0)
+            return display;
+        const minIn = Math.min(...tiers.map((t) => t.input));
+        const maxOut = Math.max(...tiers.map((t) => t.output));
+        if (minIn === 0 && maxOut === 0)
+            return display;
+        return `${display}      ${DIM}$${minIn.toFixed(2)}\u2013$${maxOut.toFixed(2)}/M tokens${RESET}`;
+    });
+    const choiceIdx = await askChoice(rl, `${stepLabel}${currentHint}`, providerOptions);
+    return PROVIDER_ORDER[choiceIdx];
+}
+/**
+ * Let the user pick a model from a provider's tiers.
+ * Returns the model string.
+ */
+async function pickModel(rl, provider, dynamicModels, stepLabel, currentModel) {
+    const tiers = dynamicModels[provider] ?? PROVIDER_TIERS[provider];
+    if (!tiers || tiers.length === 0)
+        return "";
+    const isLocal = provider === "ollama" || provider === "lmstudio";
+    const currentHint = currentModel ? ` ${DIM}(current: ${currentModel})${RESET}` : "";
+    const tierOptions = tiers.map((t) => {
+        const rec = t.recommended ? `  ${CYAN}<- recommended${RESET}` : "";
+        if (isLocal) {
+            return `${t.name}${rec}`;
+        }
+        return `${t.name} (${t.model})  ${DIM}${formatPrice(t.input, t.output)}${RESET}${rec}`;
+    });
+    const tierIndex = await askChoice(rl, `${stepLabel}${currentHint}`, tierOptions);
+    return tiers[tierIndex].model;
+}
 // ─── Main Setup Wizard ──────────────────────────────────────────────────────
 export async function runSetup(opts) {
     const version = getVersion();
@@ -585,6 +757,12 @@ export async function runSetup(opts) {
         console.log(`\u2502  ${DIM}${tagline}${RESET}${" ".repeat(bannerInner - tagline.length - 2)}\u2502`);
         console.log(`\u2514${bannerBorder}\u2518`);
         console.log();
+        // ─── Load existing config for defaults ───────────────────────────
+        const existingConfig = await loadExistingConfig(projectDir);
+        const currentProvider = existingConfig?.llm.defaultProvider;
+        const currentModel = existingConfig
+            ? getProviderModel(existingConfig, existingConfig.llm.defaultProvider)
+            : undefined;
         // ─── Pre-check: Upgrade detection ─────────────────────────────────
         const centralDbPath = path.join(os.homedir(), ".gnosys", "gnosys.db");
         const centralDbExists = fsSync.existsSync(centralDbPath);
@@ -643,7 +821,7 @@ export async function runSetup(opts) {
             console.log(`${DIM}Using bundled model data (offline or fetch failed)${RESET}`);
         }
         console.log();
-        // ─── Step 1/4 — Provider ──────────────────────────────────────────
+        // ─── Step 1/5 — Provider ──────────────────────────────────────────
         const providerOptions = PROVIDER_ORDER.map((key) => {
             const tiers = dynamicModels[key] ?? PROVIDER_TIERS[key];
             const display = PROVIDER_DISPLAY[key];
@@ -657,15 +835,21 @@ export async function runSetup(opts) {
         });
         // Add "Skip" option
         providerOptions.push("Skip (core memory works without LLM)");
-        const providerIndex = await askChoice(rl, `${BOLD}Step 1/4${RESET} ${DIM}\u2014${RESET} Choose your LLM provider`, providerOptions);
+        const currentProviderHint = currentProvider
+            ? ` ${DIM}(current: ${currentProvider})${RESET}`
+            : "";
+        const providerIndex = await askChoice(rl, `${BOLD}Step 1/5${RESET} ${DIM}\u2014${RESET} Choose your LLM provider${currentProviderHint}`, providerOptions);
         const isSkip = providerIndex === PROVIDER_ORDER.length; // last option
         const provider = isSkip ? "skip" : PROVIDER_ORDER[providerIndex];
-        // ─── Step 2/4 — Model tier ────────────────────────────────────────
+        // ─── Step 2/5 — Model tier ────────────────────────────────────────
         let model = "";
         if (!isSkip && provider !== "custom") {
             const tiers = dynamicModels[provider] ?? PROVIDER_TIERS[provider];
             if (tiers.length > 0) {
                 const isLocal = provider === "ollama" || provider === "lmstudio";
+                const currentModelHint = (currentProvider === provider && currentModel)
+                    ? ` ${DIM}(current: ${currentModel})${RESET}`
+                    : "";
                 const tierOptions = tiers.map((t) => {
                     const rec = t.recommended ? `  ${CYAN}<- recommended${RESET}` : "";
                     if (isLocal) {
@@ -673,14 +857,14 @@ export async function runSetup(opts) {
                     }
                     return `${t.name} (${t.model})  ${DIM}${formatPrice(t.input, t.output)}${RESET}${rec}`;
                 });
-                const tierIndex = await askChoice(rl, `${BOLD}Step 2/4${RESET} ${DIM}\u2014${RESET} Choose model tier`, tierOptions);
+                const tierIndex = await askChoice(rl, `${BOLD}Step 2/5${RESET} ${DIM}\u2014${RESET} Choose model tier${currentModelHint}`, tierOptions);
                 model = tiers[tierIndex].model;
             }
         }
         else if (provider === "custom") {
             // Custom: ask for base URL and model name
             console.log();
-            console.log(`${BOLD}Step 2/4${RESET} ${DIM}\u2014${RESET} Custom provider details`);
+            console.log(`${BOLD}Step 2/5${RESET} ${DIM}\u2014${RESET} Custom provider details`);
             console.log();
             const baseUrl = await askInput(rl, "Base URL (OpenAI-compatible)");
             model = await askInput(rl, "Model name");
@@ -715,11 +899,11 @@ export async function runSetup(opts) {
             }
         }
         else if (isSkip) {
-            // Skip step 3 entirely
+            // Skip step 2 entirely
             console.log();
-            console.log(`${DIM}Step 2/4 \u2014 Model tier: skipped${RESET}`);
+            console.log(`${DIM}Step 2/5 \u2014 Model tier: skipped${RESET}`);
         }
-        // ─── Step 3/4 — API key ───────────────────────────────────────────
+        // ─── Step 3/5 — API key ───────────────────────────────────────────
         let apiKeyWritten = false;
         let apiKeySource = "";
         const needsKey = !isSkip &&
@@ -739,57 +923,95 @@ export async function runSetup(opts) {
         const legacyEnvVar = legacyEnvVars[provider] ?? "";
         if (needsKey) {
             console.log();
-            console.log(`${BOLD}Step 3/4${RESET} ${DIM}\u2014${RESET} API Key`);
+            console.log(`${BOLD}Step 3/5${RESET} ${DIM}\u2014${RESET} API Key`);
             console.log();
+            // Check where the key currently lives
+            const existingKeySource = detectKeySource(envVarName, legacyEnvVar);
             // Check if key already exists in environment
             const existingKey = process.env[envVarName] || (legacyEnvVar ? process.env[legacyEnvVar] : "");
-            if (existingKey) {
-                const source = process.env[envVarName] ? envVarName : legacyEnvVar;
-                console.log(`  ${CHECK} Found existing key in $${source} (${maskKey(existingKey)})`);
+            if (existingKey || existingKeySource) {
+                const source = existingKeySource || "env";
+                console.log(`  ${CHECK} Found existing key (${source})`);
+                if (existingKey) {
+                    console.log(`  ${DIM}  ${maskKey(existingKey)}${RESET}`);
+                }
                 apiKeyWritten = true;
-                apiKeySource = "env";
+                apiKeySource = existingKeySource || "env";
+                // Offer to change it
+                const changeKey = await askYesNo(rl, "  Change key storage?", false);
+                if (!changeKey) {
+                    // Keep existing — skip the rest of step 3
+                }
+                else {
+                    // Fall through to key storage options below
+                    apiKeyWritten = false;
+                    apiKeySource = "";
+                }
             }
-            else {
+            if (!apiKeyWritten) {
                 console.log(`  Provider: ${GREEN}${provider}${RESET}`);
                 console.log(`  Env var:  ${GREEN}${envVarName}${RESET}`);
                 console.log();
                 const isMac = process.platform === "darwin";
+                const isLinux = process.platform === "linux";
+                const hasSecret = isLinux && hasSecretTool();
                 const shell = path.basename(process.env.SHELL ?? "zsh");
                 const profileFile = shell === "bash" ? "~/.bash_profile" : "~/.zshrc";
                 const options = [];
                 if (isMac) {
                     options.push(`Store in macOS Keychain (recommended \u2014 most secure, no plaintext on disk)`);
                 }
+                if (hasSecret) {
+                    options.push(`Store in GNOME Keyring (recommended \u2014 encrypted, no plaintext on disk)`);
+                }
                 options.push(`Set via environment variable (${profileFile})`, `Save to ~/.config/gnosys/.env (\u26a0 plaintext on disk \u2014 least secure)`, `Skip (configure later)`);
                 const keyChoice = await askChoice(rl, "", options);
-                // Adjust index based on whether macOS Keychain option was shown
-                const keychainIdx = isMac ? 0 : -1;
-                const envIdx = isMac ? 1 : 0;
-                const dotenvIdx = isMac ? 2 : 1;
-                const skipIdx = isMac ? 3 : 2;
+                // Build the index map based on which options are present
+                let idx = 0;
+                const keychainIdx = isMac ? idx++ : -1;
+                const gnomeIdx = hasSecret ? idx++ : -1;
+                const envIdx = idx++;
+                const dotenvIdx = idx++;
+                const skipIdx = idx++;
+                // skipIdx is unused as a variable but documents the last index
                 if (keyChoice === keychainIdx) {
-                    // macOS Keychain
-                    console.log();
-                    console.log(`  Run this in a ${BOLD}separate terminal${RESET}:`);
-                    console.log();
-                    console.log(`  ${GREEN}security add-generic-password -a "$USER" -s "${envVarName}" -w "your-key-here"${RESET}`);
-                    console.log();
-                    console.log(`  ${DIM}Replace "your-key-here" with your actual API key.${RESET}`);
-                    console.log(`  ${DIM}Gnosys will read it automatically at runtime.${RESET}`);
+                    // macOS Keychain — ask for the key directly and write it
                     console.log();
-                    await askInput(rl, "Press Enter after setting the key...", { default: "" });
-                    // Verify the key was set
-                    try {
-                        const { execSync } = await import("child_process");
-                        const result = execSync(`security find-generic-password -a "$USER" -s "${envVarName}" -w`, { stdio: "pipe", encoding: "utf-8" }).trim();
-                        if (result) {
-                            console.log(`  ${CHECK} Key verified in macOS Keychain (${maskKey(result)})`);
+                    const key = await askInput(rl, `Enter your ${provider} API key`);
+                    if (key) {
+                        const success = writeApiKeyToKeychain(envVarName, key);
+                        if (success) {
+                            console.log(`  ${CHECK} Key saved to macOS Keychain (${maskKey(key)})`);
                             apiKeyWritten = true;
-                            apiKeySource = "keychain";
+                            apiKeySource = "macOS Keychain";
+                        }
+                        else {
+                            console.log(`  ${CROSS} Failed to write to Keychain. Falling back to .env file.`);
+                            await writeApiKey(provider, key);
+                            console.log(`  ${CHECK} Key saved to ~/.config/gnosys/.env (${maskKey(key)})`);
+                            apiKeyWritten = true;
+                            apiKeySource = "~/.config/gnosys/.env";
                         }
                     }
-                    catch {
-                        console.log(`  ${WARN} Could not verify key in Keychain. You can set it later.`);
+                }
+                else if (keyChoice === gnomeIdx) {
+                    // Linux GNOME Keyring — ask for the key directly
+                    console.log();
+                    const key = await askInput(rl, `Enter your ${provider} API key`);
+                    if (key) {
+                        const success = writeApiKeyToSecretTool(envVarName, key, provider);
+                        if (success) {
+                            console.log(`  ${CHECK} Key saved to GNOME Keyring (${maskKey(key)})`);
+                            apiKeyWritten = true;
+                            apiKeySource = "GNOME Keyring";
+                        }
+                        else {
+                            console.log(`  ${CROSS} Failed to write to GNOME Keyring. Falling back to .env file.`);
+                            await writeApiKey(provider, key);
+                            console.log(`  ${CHECK} Key saved to ~/.config/gnosys/.env (${maskKey(key)})`);
+                            apiKeyWritten = true;
+                            apiKeySource = "~/.config/gnosys/.env";
+                        }
                     }
                 }
                 else if (keyChoice === envIdx) {
@@ -804,10 +1026,9 @@ export async function runSetup(opts) {
                     console.log();
                     await askInput(rl, "Press Enter after setting the key...", { default: "" });
                     // Verify
-                    // Note: we can't detect it in this process since env was set in another terminal
                     console.log(`  ${DIM}Key will be available in new terminal sessions.${RESET}`);
                     apiKeyWritten = true;
-                    apiKeySource = "env";
+                    apiKeySource = "shell profile";
                 }
                 else if (keyChoice === dotenvIdx) {
                     // .env file (least secure)
@@ -824,7 +1045,7 @@ export async function runSetup(opts) {
                             await writeApiKey(provider, key);
                             console.log(`  ${CHECK} Key saved to ~/.config/gnosys/.env (${maskKey(key)})`);
                             apiKeyWritten = true;
-                            apiKeySource = "dotenv";
+                            apiKeySource = "~/.config/gnosys/.env";
                         }
                     }
                     else {
@@ -834,7 +1055,12 @@ export async function runSetup(opts) {
                 else {
                     // Skip
                     console.log(`  ${DIM}Skipped. Set your key later using one of these methods:`);
-                    console.log(`  \u2022 macOS Keychain: security add-generic-password -a "$USER" -s "${envVarName}" -w "key"${isMac ? "" : " (macOS only)"}`);
+                    if (isMac) {
+                        console.log(`  \u2022 macOS Keychain: security add-generic-password -a "$USER" -s "${envVarName}" -w "key" -U`);
+                    }
+                    if (hasSecret) {
+                        console.log(`  \u2022 GNOME Keyring: printf '%s' 'key' | secret-tool store --label="Gnosys ${provider}" service gnosys account ${envVarName}`);
+                    }
                     console.log(`  \u2022 Shell profile:  echo 'export ${envVarName}=key' >> ${profileFile}`);
                     console.log(`  \u2022 Dotenv file:    echo '${envVarName}=key' >> ~/.config/gnosys/.env${RESET}`);
                 }
@@ -842,84 +1068,335 @@ export async function runSetup(opts) {
         }
         else {
             console.log();
-            console.log(`${DIM}Step 3/4 \u2014 API key: not needed (local provider)${RESET}`);
+            console.log(`${DIM}Step 3/5 \u2014 API key: not needed (local provider)${RESET}`);
         }
-        // ─── Step 4/4 — IDE integration ───────────────────────────────────
-        const detectedIdes = await detectIDEs(projectDir);
-        const configuredIdes = [];
-        if (detectedIdes.length > 0) {
-            const ideLabels = {
-                claude: "Claude Code",
-                cursor: "Cursor",
-                codex: "Codex",
-            };
-            const detectedNames = detectedIdes.map((id) => ideLabels[id] ?? id).join(", ");
+        // ─── Step 4/5 — Task Model Configuration ─────────────────────────
+        const taskOverrides = {};
+        let dreamEnabled = existingConfig?.dream?.enabled ?? false;
+        let dreamProvider = existingConfig?.dream?.provider ?? "ollama";
+        let dreamModel = existingConfig?.dream?.model ?? "";
+        if (!isSkip) {
             console.log();
-            console.log(`${BOLD}Step 4/4${RESET} ${DIM}\u2014${RESET} IDE Integration`);
+            console.log(`${BOLD}Step 4/5${RESET} ${DIM}\u2014${RESET} Task Routing`);
             console.log();
-            console.log(`Detected: ${GREEN}${detectedNames}${RESET}`);
-            const ideOptions = [];
-            for (const ide of detectedIdes) {
-                ideOptions.push(`${ideLabels[ide] ?? ide} only`);
-            }
-            if (detectedIdes.length > 1) {
-                ideOptions.push("All detected");
-            }
-            ideOptions.push("Skip");
-            const ideIndex = await askChoice(rl, "", ideOptions);
-            let idesToSetup = [];
-            if (ideIndex < detectedIdes.length) {
-                // Individual IDE selected
-                idesToSetup = [detectedIdes[ideIndex]];
-            }
-            else if (detectedIdes.length > 1 && ideIndex === detectedIdes.length) {
-                // "All detected"
-                idesToSetup = [...detectedIdes];
-            }
-            // Last option is always "Skip"
-            for (const ide of idesToSetup) {
-                const result = await setupIDE(ide, projectDir);
-                if (result.success) {
-                    console.log(`  ${CHECK} ${result.message}`);
-                    configuredIdes.push(ide);
+            console.log(`Gnosys uses different LLM models for different tasks. Each defaults to your`);
+            console.log(`chosen provider, but you can override them individually.`);
+            console.log();
+            const tasks = ["structuring", "synthesis", "vision", "transcription"];
+            // Build a temporary config to see what defaults look like with the new provider
+            const effectiveRouting = {};
+            for (const task of tasks) {
+                if (existingConfig?.taskModels?.[task]) {
+                    // Use the existing override
+                    effectiveRouting[task] = {
+                        provider: existingConfig.taskModels[task].provider,
+                        model: existingConfig.taskModels[task].model,
+                    };
                 }
                 else {
-                    console.log(`  ${CROSS} ${ideLabels[ide] ?? ide}: ${result.message}`);
+                    // Derive from the newly chosen default provider
+                    const p = provider;
+                    let m = model;
+                    if (task === "structuring") {
+                        m = getStructuringModel(p, model);
+                    }
+                    effectiveRouting[task] = { provider: p, model: m };
                 }
             }
-            // Sync global rules
-            if (idesToSetup.length > 0) {
-                try {
-                    const { syncToTarget } = await import("./rulesGen.js");
-                    const { GnosysDB } = await import("./db.js");
-                    const db = GnosysDB.openCentral();
-                    await syncToTarget(db, projectDir, "global", null);
-                    db.close();
+            // Dream routing
+            effectiveRouting.dream = {
+                provider: dreamProvider,
+                model: dreamModel || getProviderModel(existingConfig ?? { llm: { defaultProvider: "ollama", ollama: { model: "llama3.2", baseUrl: "http://localhost:11434" } } }, dreamProvider),
+            };
+            // Display the table
+            const taskNameWidth = 16;
+            const routingWidth = 38;
+            console.log(`  ${BOLD}${"Task".padEnd(taskNameWidth)}${"Current Routing".padEnd(routingWidth)}${RESET}`);
+            console.log(`  ${"\u2500".repeat(taskNameWidth + routingWidth)}`);
+            for (const task of [...tasks, "dream"]) {
+                const r = effectiveRouting[task];
+                const desc = TASK_DESCRIPTIONS[task] ?? "";
+                const routingStr = `${r.provider} / ${r.model}`;
+                const status = task === "dream" && !dreamEnabled ? `${DIM}(disabled)${RESET}` : `${DIM}(${desc})${RESET}`;
+                console.log(`  ${task.padEnd(taskNameWidth)}${routingStr.padEnd(routingWidth)}${status}`);
+            }
+            console.log();
+            const taskChoice = await askChoice(rl, "", [
+                `Keep defaults (use ${provider} for everything available)`,
+                "Customize individual tasks",
+                "Use same provider for ALL tasks (including dream)",
+            ]);
+            if (taskChoice === 1) {
+                // Customize individual tasks
+                console.log();
+                console.log(`${DIM}For each task, pick a provider and model. Press Enter to keep the default.${RESET}`);
+                for (const task of tasks) {
+                    console.log();
+                    console.log(`  ${BOLD}${task}${RESET} ${DIM}(${TASK_DESCRIPTIONS[task]})${RESET}`);
+                    const currentTaskRouting = effectiveRouting[task];
+                    const useDefault = await askYesNo(rl, `  Keep ${currentTaskRouting.provider} / ${currentTaskRouting.model}?`, true);
+                    if (!useDefault) {
+                        // Pick a provider for this task
+                        const taskProvider = await pickProvider(rl, dynamicModels, `  Provider for ${task}`, currentTaskRouting.provider);
+                        // Pick a model
+                        let taskModel;
+                        if (taskProvider === "ollama" || taskProvider === "lmstudio") {
+                            taskModel = await pickModel(rl, taskProvider, dynamicModels, `  Model for ${task}`);
+                        }
+                        else if (taskProvider === "custom") {
+                            taskModel = await askInput(rl, "  Model name");
+                        }
+                        else {
+                            taskModel = await pickModel(rl, taskProvider, dynamicModels, `  Model for ${task}`);
+                        }
+                        taskOverrides[task] = { provider: taskProvider, model: taskModel };
+                    }
                 }
-                catch {
-                    // Non-critical — rules sync is best-effort during setup
+                // Dream configuration
+                console.log();
+                console.log(`  ${BOLD}dream${RESET} ${DIM}(${TASK_DESCRIPTIONS.dream})${RESET}`);
+                console.log(`  ${DIM}Dream mode runs offline consolidation — discovering relationships,`);
+                console.log(`  generating summaries, and scoring memories. Defaults to Ollama (free/local).${RESET}`);
+                dreamEnabled = await askYesNo(rl, `  Enable dream mode?`, dreamEnabled);
+                if (dreamEnabled) {
+                    const keepDreamDefault = await askYesNo(rl, `  Keep ${dreamProvider} / ${dreamModel || "default"}?`, true);
+                    if (!keepDreamDefault) {
+                        dreamProvider = await pickProvider(rl, dynamicModels, `  Provider for dream`, dreamProvider);
+                        dreamModel = await pickModel(rl, dreamProvider, dynamicModels, `  Model for dream`);
+                    }
+                    taskOverrides.dream = { provider: dreamProvider, model: dreamModel };
+                }
+            }
+            else if (taskChoice === 2) {
+                // Use same provider for ALL tasks including dream
+                console.log();
+                console.log(`  ${DIM}All tasks will use ${provider} / ${model}.${RESET}`);
+                for (const task of tasks) {
+                    let taskModel = model;
+                    if (task === "structuring") {
+                        taskModel = getStructuringModel(provider, model);
+                    }
+                    taskOverrides[task] = { provider, model: taskModel };
+                }
+                dreamEnabled = await askYesNo(rl, `  Enable dream mode with ${provider}?`, true);
+                if (dreamEnabled) {
+                    dreamProvider = provider;
+                    dreamModel = model;
+                    taskOverrides.dream = { provider, model };
                 }
             }
+            // taskChoice === 0: keep defaults, do nothing
         }
         else {
             console.log();
-            console.log(`${DIM}Step 4/4 \u2014 IDE integration: no IDEs detected${RESET}`);
+            console.log(`${DIM}Step 4/5 \u2014 Task routing: skipped (no provider)${RESET}`);
+        }
+        // ─── Step 5/5 — IDE integration (enhanced) ───────────────────────
+        const detectedIdes = await detectIDEs(projectDir);
+        const configuredIdes = [];
+        console.log();
+        console.log(`${BOLD}Step 5/5${RESET} ${DIM}\u2014${RESET} IDE Integration`);
+        console.log();
+        const ideLabels = {
+            claude: "Claude Code",
+            cursor: "Cursor",
+            codex: "Codex",
+        };
+        // Build IDE options: show detected ones and offer to create missing ones
+        const allIdeKeys = ["claude", "cursor", "codex"];
+        const ideOptions = [];
+        const ideKeyForOption = []; // parallel array mapping option index to IDE key
+        for (const ide of allIdeKeys) {
+            const isDetected = detectedIdes.includes(ide);
+            const label = ideLabels[ide] ?? ide;
+            if (isDetected) {
+                ideOptions.push(`${label} (detected)`);
+            }
+            else if (ide === "claude") {
+                // Claude CLI needs to be installed, can't just create a directory
+                ideOptions.push(`${label} ${DIM}(not detected \u2014 install Claude CLI first)${RESET}`);
+            }
+            else {
+                // Offer to create the directory
+                ideOptions.push(`${label} ${DIM}(create .${ide}/ \u2014 not detected)${RESET}`);
+            }
+            ideKeyForOption.push(ide);
+        }
+        ideOptions.push("All");
+        ideOptions.push("Skip");
+        if (detectedIdes.length > 0) {
+            const detectedNames = detectedIdes.map((id) => ideLabels[id] ?? id).join(", ");
+            console.log(`Detected: ${GREEN}${detectedNames}${RESET}`);
+        }
+        else {
+            console.log(`${DIM}No IDE integrations detected in this directory.${RESET}`);
+        }
+        const ideIndex = await askChoice(rl, "", ideOptions);
+        let idesToSetup = [];
+        if (ideIndex < allIdeKeys.length) {
+            // Individual IDE selected
+            idesToSetup = [ideKeyForOption[ideIndex]];
+        }
+        else if (ideIndex === allIdeKeys.length) {
+            // "All"
+            idesToSetup = [...allIdeKeys];
+        }
+        // Last option is "Skip"
+        for (const ide of idesToSetup) {
+            // For non-detected IDEs (except claude), create the directory first
+            if (!detectedIdes.includes(ide) && ide !== "claude") {
+                const dirPath = path.join(projectDir, `.${ide}`);
+                try {
+                    await fs.mkdir(dirPath, { recursive: true });
+                    console.log(`  ${CHECK} Created .${ide}/ directory`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(`  ${CROSS} Could not create .${ide}/: ${msg}`);
+                    continue;
+                }
+            }
+            const result = await setupIDE(ide, projectDir);
+            if (result.success) {
+                console.log(`  ${CHECK} ${result.message}`);
+                configuredIdes.push(ide);
+            }
+            else {
+                console.log(`  ${CROSS} ${ideLabels[ide] ?? ide}: ${result.message}`);
+            }
+        }
+        // Sync global rules
+        if (idesToSetup.length > 0) {
+            try {
+                const { syncToTarget } = await import("./rulesGen.js");
+                const { GnosysDB } = await import("./db.js");
+                const db = GnosysDB.openCentral();
+                await syncToTarget(db, projectDir, "global", null);
+                db.close();
+            }
+            catch {
+                // Non-critical — rules sync is best-effort during setup
+            }
         }
         // ─── Compute structuring model ────────────────────────────────────
-        const structuringModel = isSkip ? "" : getStructuringModel(provider, model);
+        const structuringModel = isSkip ? "" : (taskOverrides.structuring?.model ?? getStructuringModel(provider, model));
+        // ─── Write config to gnosys.json ─────────────────────────────────
+        if (!isSkip) {
+            // Determine which store path to write to — prefer project, fall back to global
+            let storePath;
+            const projectStore = path.join(projectDir, ".gnosys");
+            const globalStore = path.join(os.homedir(), ".gnosys");
+            if (fsSync.existsSync(path.join(projectStore, "gnosys.json"))) {
+                storePath = projectStore;
+            }
+            else if (fsSync.existsSync(path.join(globalStore, "gnosys.json"))) {
+                storePath = globalStore;
+            }
+            else {
+                // Default to global store — create directory if needed
+                await fs.mkdir(globalStore, { recursive: true });
+                storePath = globalStore;
+            }
+            // Build the config updates
+            // Build LLM config update, preserving existing provider-specific settings
+            const existingLlm = existingConfig?.llm;
+            const existingProviderConfig = existingLlm
+                ? existingLlm[provider]
+                : undefined;
+            const providerConfigBase = (typeof existingProviderConfig === "object" && existingProviderConfig !== null)
+                ? existingProviderConfig
+                : {};
+            const configUpdates = {
+                llm: {
+                    ...(existingLlm ?? {}),
+                    defaultProvider: provider,
+                    [provider]: {
+                        ...providerConfigBase,
+                        model,
+                    },
+                },
+            };
+            // Task model overrides — only write if the user actually changed them
+            const taskModelsUpdate = {};
+            if (taskOverrides.structuring) {
+                taskModelsUpdate.structuring = taskOverrides.structuring;
+            }
+            if (taskOverrides.synthesis) {
+                taskModelsUpdate.synthesis = taskOverrides.synthesis;
+            }
+            if (taskOverrides.vision) {
+                taskModelsUpdate.vision = taskOverrides.vision;
+            }
+            if (taskOverrides.transcription) {
+                taskModelsUpdate.transcription = taskOverrides.transcription;
+            }
+            if (Object.keys(taskModelsUpdate).length > 0) {
+                configUpdates.taskModels = taskModelsUpdate;
+            }
+            // Dream configuration
+            configUpdates.dream = {
+                ...(existingConfig?.dream ?? {}),
+                enabled: dreamEnabled,
+                provider: dreamProvider,
+                ...(dreamModel ? { model: dreamModel } : {}),
+            };
+            try {
+                await updateConfig(storePath, configUpdates);
+                console.log();
+                console.log(`  ${CHECK} Config written to ${storePath}/gnosys.json`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log();
+                console.log(`  ${WARN} Could not write config: ${msg}`);
+            }
+        }
         // ─── Summary ──────────────────────────────────────────────────────
+        // Compute final effective routing for summary display
+        const summaryRouting = {};
+        const taskNames = ["structuring", "synthesis", "vision", "transcription", "dream"];
+        for (const task of taskNames) {
+            if (isSkip) {
+                summaryRouting[task] = "not configured";
+                continue;
+            }
+            if (task === "dream") {
+                if (!dreamEnabled) {
+                    summaryRouting[task] = "disabled";
+                }
+                else {
+                    const p = taskOverrides.dream?.provider ?? dreamProvider;
+                    const m = taskOverrides.dream?.model ?? (dreamModel || "default");
+                    summaryRouting[task] = `${p} / ${m}`;
+                }
+                continue;
+            }
+            if (taskOverrides[task]) {
+                summaryRouting[task] = `${taskOverrides[task].provider} / ${taskOverrides[task].model}`;
+            }
+            else {
+                // Default routing
+                const p = provider;
+                let m = model;
+                if (task === "structuring")
+                    m = getStructuringModel(p, m);
+                summaryRouting[task] = `${p} / ${m}`;
+            }
+        }
         const summaryRows = [
             ["Provider:", isSkip ? "none" : provider],
             ["Model:", model || "none"],
-            ["Structuring:", structuringModel || "n/a"],
-            ["API key:", apiKeyWritten ? "~/.config/gnosys/.env" : "not set"],
+            ["API key:", apiKeyWritten ? `${apiKeySource} ${CHECK}` : "not set"],
+            ["", ""],
+            ["Task Routing:", ""],
+            ["  structuring:", summaryRouting.structuring],
+            ["  synthesis:", summaryRouting.synthesis],
+            ["  vision:", summaryRouting.vision],
+            ["  transcription:", summaryRouting.transcription],
+            ["  dream:", summaryRouting.dream],
         ];
         if (configuredIdes.length > 0) {
-            const ideLabels = {
-                claude: "Claude Code",
-                cursor: "Cursor",
-                codex: "Codex",
-            };
+            summaryRows.push(["", ""]);
             const ideNames = configuredIdes.map((id) => ideLabels[id] ?? id).join(", ");
             summaryRows.push(["IDEs:", ideNames]);
         }
@@ -936,6 +1413,8 @@ export async function runSetup(opts) {
             ides: configuredIdes,
             mode: "agent",
             upgraded,
+            taskOverrides: Object.keys(taskOverrides).length > 0 ? taskOverrides : undefined,
+            dreamEnabled,
         };
     }
     catch (err) {