gnosys 5.11.3 → 5.12.0

package/dist/lib/setup/sections/providers.js

@@ -0,0 +1,255 @@
+/**
+ * Setup: Providers — API keys and provider credentials.
+ *
+ * `gnosys setup providers` or summary menu row "providers".
+ */
+import { loadConfig, updateConfig, } from "../../config.js";
+import { apiKeyServiceName, deleteStoredSecret, listStoredKeySlots, maskKeySnippet, storeApiKeySecret, } from "../../apiKeyVault.js";
+import { resolveActiveStorePath } from "../storePath.js";
+import { safeQuestion } from "../ui/safePrompt.js";
+import { Header } from "../ui/header.js";
+import { Title } from "../ui/title.js";
+import { Footer } from "../ui/footer.js";
+import { printStatus } from "../ui/status.js";
+import { c, color, glyph } from "../ui/tokens.js";
+import { CLOUD_PROVIDERS_FOR_KEYS, LOCAL_PROVIDERS, renderProviderLabel, renderProviderMark, } from "../providerGlyphs.js";
+async function ask(rl, prompt) {
+    return (await safeQuestion(rl, prompt)).trim();
+}
+async function askYesNo(rl, prompt, defaultYes = true) {
+    const hint = defaultYes ? " [Y/n] " : " [y/N] ";
+    const answer = (await ask(rl, prompt + hint)).toLowerCase();
+    if (!answer)
+        return defaultYes;
+    return answer === "y" || answer === "yes";
+}
+async function askChoice(rl, prompt, choices, defaultIdx = 0) {
+    console.log("");
+    if (prompt)
+        console.log(prompt);
+    choices.forEach((ch, i) => {
+        const marker = i === defaultIdx ? color(c.textDim, " (default)") : "";
+        console.log(`  ${i + 1}. ${ch}${marker}`);
+    });
+    for (let attempts = 0; attempts < 5; attempts++) {
+        const answer = await ask(rl, ` ${color(c.accent, glyph.prompt)} `);
+        if (!answer)
+            return defaultIdx;
+        const n = parseInt(answer, 10);
+        if (!Number.isNaN(n) && n >= 1 && n <= choices.length)
+            return n - 1;
+        printStatus("warn", `pick a number 1–${choices.length}`);
+    }
+    return defaultIdx;
+}
+function slotScopeLabel(slot) {
+    if (slot.scope === "global")
+        return "global";
+    return "provider";
+}
+async function clearConfigProviderApiKey(storePath, provider) {
+    const cfg = await loadConfig(storePath);
+    const patch = {};
+    switch (provider) {
+        case "anthropic":
+            if (!cfg.llm.anthropic.apiKey)
+                return;
+            patch.anthropic = { ...cfg.llm.anthropic, apiKey: "" };
+            break;
+        case "openai":
+            if (!cfg.llm.openai.apiKey)
+                return;
+            patch.openai = { ...cfg.llm.openai, apiKey: "" };
+            break;
+        case "groq":
+            if (!cfg.llm.groq.apiKey)
+                return;
+            patch.groq = { ...cfg.llm.groq, apiKey: "" };
+            break;
+        case "xai":
+            if (!cfg.llm.xai.apiKey)
+                return;
+            patch.xai = { ...cfg.llm.xai, apiKey: "" };
+            break;
+        case "mistral":
+            if (!cfg.llm.mistral.apiKey)
+                return;
+            patch.mistral = { ...cfg.llm.mistral, apiKey: "" };
+            break;
+        case "openrouter":
+            if (!cfg.llm.openrouter.apiKey)
+                return;
+            patch.openrouter = { ...cfg.llm.openrouter, apiKey: "" };
+            break;
+        case "custom":
+            if (!cfg.llm.custom?.apiKey)
+                return;
+            patch.custom = { ...cfg.llm.custom, apiKey: "" };
+            break;
+        default:
+            return;
+    }
+    await updateConfig(storePath, { llm: patch });
+}
+function renderProviderRow(index, provider, cfg, local = false) {
+    const mark = renderProviderMark(provider);
+    const slots = listStoredKeySlots(cfg, provider);
+    const hasKey = slots.length > 0;
+    const status = local
+        ? color(c.textDim, "local · no key")
+        : hasKey
+            ? color(c.ok, `${glyph.ok} key`)
+            : color(c.textGhost, "no key");
+    const preview = hasKey && !local ? `  ${color(c.textDim, slots[0].preview ?? "")}` : "";
+    const num = color(c.textDim, String(index));
+    const name = color(c.text, provider.padEnd(12));
+    return ` ${num}  ${mark}  ${name}  ${status}${preview}`;
+}
+async function manageProviderKeys(rl, storePath, cfg, provider) {
+    let changed = false;
+    while (true) {
+        const slots = listStoredKeySlots(cfg, provider);
+        console.log("");
+        console.log(Header(["gnosys", "setup", "providers", provider]));
+        console.log("");
+        console.log(Title(renderProviderLabel(provider), "stored credentials for this provider"));
+        console.log("");
+        if (slots.length === 0) {
+            console.log(`  ${color(c.textDim, "No keys found for this provider.")}`);
+            console.log(`  ${color(c.textDim, `Add one with rotate — saved as GNOSYS_GLOBAL_${provider.toUpperCase()}_KEY`)}`);
+            console.log("");
+        }
+        else {
+            for (const slot of slots) {
+                const scope = color(c.textMid, slotScopeLabel(slot).padEnd(14));
+                const src = color(c.textDim, slot.source.padEnd(22));
+                const prev = slot.preview ? color(c.text, slot.preview) : "";
+                console.log(`  ${scope} ${src} ${prev}`);
+                console.log(`  ${color(c.textGhost, "      " + slot.service)}`);
+            }
+            console.log("");
+        }
+        const choice = await askChoice(rl, "Actions", [
+            slots.length === 0 ? "Add API key (global)" : "Rotate global API key",
+            "Delete one stored key…",
+            "Back",
+        ], 2);
+        if (choice === 2) {
+            return changed;
+        }
+        if (choice === 0) {
+            const service = apiKeyServiceName(provider, "global");
+            console.log("");
+            console.log(`  ${color(c.textDim, `Keychain: ${service}`)}`);
+            const key = await ask(rl, ` ${color(c.accent, glyph.prompt)} Enter ${provider} API key: `);
+            if (!key) {
+                printStatus("warn", "skipped");
+                continue;
+            }
+            if (storeApiKeySecret(service, key, provider)) {
+                const store = process.platform === "darwin" ? "macOS Keychain" : "GNOME Keyring";
+                printStatus("ok", "key saved", `${store} · ${maskKeySnippet(key)}`);
+                changed = true;
+            }
+            else {
+                printStatus("fail", "could not write to secure store");
+            }
+            continue;
+        }
+        if (choice === 1) {
+            if (slots.length === 0) {
+                printStatus("warn", "nothing to delete");
+                continue;
+            }
+            const labels = slots.map((s, i) => `${i + 1}. ${slotScopeLabel(s)} · ${s.service}`);
+            const pick = await askChoice(rl, "Delete which key?", [...labels, "Cancel"], labels.length);
+            if (pick >= slots.length)
+                continue;
+            const slot = slots[pick];
+            if (slot.service === "gnosys.json") {
+                if (await askYesNo(rl, "Clear API key from gnosys.json?", false)) {
+                    await clearConfigProviderApiKey(storePath, provider);
+                    printStatus("ok", "cleared gnosys.json apiKey");
+                    changed = true;
+                    cfg = await loadConfig(storePath);
+                }
+                continue;
+            }
+            if (slot.source.startsWith("$")) {
+                printStatus("warn", `unset ${slot.service} in your shell or ~/.config/gnosys/.env`, "env vars cannot be removed from here");
+                continue;
+            }
+            if (await askYesNo(rl, `Delete ${slot.service} from secure store?`, false)) {
+                if (deleteStoredSecret(slot.service)) {
+                    printStatus("ok", "deleted", slot.service);
+                    changed = true;
+                }
+                else {
+                    printStatus("fail", "delete failed or entry not found");
+                }
+            }
+            continue;
+        }
+    }
+}
+/**
+ * Providers + API key management screen.
+ */
+export async function runProvidersSetup(opts) {
+    const storePath = resolveActiveStorePath(opts.directory);
+    let cfg = await loadConfig(storePath);
+    let anyChange = false;
+    const menuProviders = [
+        ...CLOUD_PROVIDERS_FOR_KEYS,
+        ...LOCAL_PROVIDERS,
+    ];
+    while (true) {
+        console.log("");
+        console.log(Header(["gnosys", "setup", "providers"]));
+        console.log("");
+        console.log(Title("Providers", "API keys live here · pick task routing separately for models per task"));
+        console.log("");
+        for (let i = 0; i < menuProviders.length; i++) {
+            const p = menuProviders[i];
+            const local = LOCAL_PROVIDERS.includes(p);
+            console.log(renderProviderRow(i + 1, p, cfg, local));
+        }
+        console.log("");
+        console.log(`  ${color(c.textDim, "Keys: global = GNOSYS_GLOBAL_<PROVIDER>_KEY (shared across tasks)")}`);
+        console.log(Footer("number · manage    enter · back"));
+        const answer = await ask(opts.rl, ` ${color(c.accent, glyph.prompt)} `);
+        if (!answer) {
+            return anyChange;
+        }
+        const n = parseInt(answer, 10);
+        if (Number.isNaN(n) || n < 1 || n > menuProviders.length) {
+            printStatus("warn", `enter 1–${menuProviders.length} or press Enter to go back`);
+            continue;
+        }
+        const provider = menuProviders[n - 1];
+        if (LOCAL_PROVIDERS.includes(provider)) {
+            console.log("");
+            printStatus("ok", `${provider} is local`, "no API key required");
+            continue;
+        }
+        const changed = await manageProviderKeys(opts.rl, storePath, cfg, provider);
+        if (changed) {
+            anyChange = true;
+            cfg = await loadConfig(storePath);
+        }
+    }
+}
+/** Summary line: how many providers have keys. */
+export async function describeProvidersSummary(cfg) {
+    const named = [];
+    for (const p of CLOUD_PROVIDERS_FOR_KEYS) {
+        if (listStoredKeySlots(cfg, p).length > 0) {
+            named.push(p);
+        }
+    }
+    if (named.length === 0)
+        return "no keys stored";
+    const preview = named.slice(0, 3).join(", ");
+    const suffix = named.length > 3 ? ` +${named.length - 3}` : "";
+    return `${named.length} with keys · ${preview}${suffix}`;
+}

package/dist/lib/setup/sections/routing.d.ts

@@ -2,9 +2,7 @@
  * Setup: Task Routing.
  *
  * Standalone wizard for configuring per-task LLM routing
- * (structuring / synthesis / vision / transcription / dream).
- * Extracted from the linear `runSetup` flow so it can be invoked
- * directly via `gnosys setup routing` or from the summary-first menu.
+ * (structuring / synthesis / vision / transcription / chat / dream).
  */
 import type { Interface as ReadlineInterface } from "readline/promises";
 export interface RoutingOptions {
@@ -12,8 +10,6 @@ export interface RoutingOptions {
     directory: string;
 }
 /**
- * Run the task-routing wizard. Reads current config, walks the 3-way choice
- * (keep defaults / customize individual / use same for all), writes any
- * overrides via updateConfig(). Returns true if config was changed.
+ * Run the task-routing wizard.
  */
 export declare function runRoutingSetup(opts: RoutingOptions): Promise<boolean>;

package/dist/lib/setup/sections/routing.js

@@ -2,17 +2,18 @@
  * Setup: Task Routing.
  *
  * Standalone wizard for configuring per-task LLM routing
- * (structuring / synthesis / vision / transcription / dream).
- * Extracted from the linear `runSetup` flow so it can be invoked
- * directly via `gnosys setup routing` or from the summary-first menu.
+ * (structuring / synthesis / vision / transcription / chat / dream).
  */
-import { loadConfig, updateConfig, resolveTaskModel, getProviderModel, } from "../../config.js";
+import { loadConfig, updateConfig, getProviderModel, } from "../../config.js";
+import { buildApiKeyRequirementsFromConfig, buildEffectiveRouting, ensureApiKeys, } from "../../apiKeyVault.js";
 import { safeQuestion } from "../ui/safePrompt.js";
 import { Header } from "../ui/header.js";
 import { Title } from "../ui/title.js";
 import { Footer } from "../ui/footer.js";
 import { printStatus } from "../ui/status.js";
 import { classifyCost, renderRoutingTable, renderRoutingDiff, } from "../routingRender.js";
+import { runCommaListRoutingEditor } from "./taskRoutingEditor.js";
+import { resolveActiveStorePath } from "../storePath.js";
 const DIM = "\x1b[2m";
 const RESET = "\x1b[0m";
 const TASKS = ["structuring", "synthesis", "chat", "vision", "transcription"];
@@ -45,23 +46,6 @@ async function askChoice(rl, prompt, choices, defaultIdx = 0) {
     }
     return defaultIdx;
 }
-function buildEffectiveRouting(cfg) {
-    const out = {};
-    for (const t of TASKS) {
-        const r = resolveTaskModel(cfg, t);
-        out[t] = { provider: r.provider, model: r.model };
-    }
-    out.dream = {
-        provider: cfg.dream?.provider ?? "ollama",
-        model: cfg.dream?.model ?? getProviderModel(cfg, (cfg.dream?.provider ?? "ollama")),
-    };
-    return out;
-}
-/**
- * Build the table-row payload from current routing data. Marks any
- * task whose effective provider/model differs from the snapshot as
- * `changed` so the renderer can highlight it (▶ in accent-hi).
- */
 function buildTaskRows(routing, baseline, dreamEnabled) {
     const rows = [];
     for (const t of [...TASKS, "dream"]) {
@@ -75,72 +59,33 @@ function buildTaskRows(routing, baseline, dreamEnabled) {
     return rows;
 }
 /**
- * Run the task-routing wizard. Reads current config, walks the 3-way choice
- * (keep defaults / customize individual / use same for all), writes any
- * overrides via updateConfig(). Returns true if config was changed.
+ * Run the task-routing wizard.
  */
 export async function runRoutingSetup(opts) {
-    const cfg = await loadConfig(opts.directory);
+    const storePath = resolveActiveStorePath(opts.directory);
+    const cfg = await loadConfig(storePath);
     const provider = cfg.llm.defaultProvider;
     const model = getProviderModel(cfg, provider);
     console.log("");
     console.log(Header(["gnosys", "setup", "routing"]));
     console.log("");
-    console.log(Title("Task routing", "each task can use a different model — overrides the default"));
+    console.log(Title("Task routing", "pick provider + model per task — set API keys under setup providers"));
     console.log("");
     const dreamEnabled = !!cfg.dream?.enabled;
     const baseline = buildEffectiveRouting(cfg);
-    // Initial table: nothing has changed yet, so every row is `changed: false`.
     const initialRows = buildTaskRows(baseline, baseline, dreamEnabled);
     console.log(renderRoutingTable(initialRows));
     console.log("");
-    // v5.9.4 Bug 5 — clearer option copy. Option 1 keeps current routing
-    // (skip, no changes). Option 2 customises individual tasks. Option 3
-    // CLEARS all task overrides so every task falls back to the default
-    // provider; we show a Diff() of what's being removed before committing.
     const choice = await askChoice(opts.rl, "What would you like to do?", [
         "Keep current routing (no changes)",
-        "Customize individual tasks",
+        "Edit tasks — pick by number, then provider + model for each",
         "Reset all task overrides to use default",
     ], 0);
     if (choice === 0) {
         console.log(`${DIM}No changes.${RESET}`);
         return false;
     }
-    const newTaskModels = {
-        ...(cfg.taskModels ?? {}),
-    };
-    let dreamProvider = (cfg.dream?.provider ?? "ollama");
-    let dreamModel = cfg.dream?.model ?? "llama3.2";
-    let dreamEnabledNew = dreamEnabled;
-    if (choice === 1) {
-        // Customize each task
-        for (const t of TASKS) {
-            const current = baseline[t];
-            const keep = await askYesNo(opts.rl, `Keep ${t} → ${current.provider} / ${current.model}?`, true);
-            if (!keep) {
-                const p = await ask(opts.rl, `  Provider for ${t} (e.g. anthropic, openai, xai, ollama): `);
-                const m = await ask(opts.rl, `  Model for ${t}: `);
-                if (p && m)
-                    newTaskModels[t] = { provider: p, model: m };
-            }
-        }
-        // Dream
-        dreamEnabledNew = await askYesNo(opts.rl, "Enable dream mode?", dreamEnabled);
-        if (dreamEnabledNew) {
-            const keepDream = await askYesNo(opts.rl, `Keep dream → ${dreamProvider} / ${dreamModel}?`, true);
-            if (!keepDream) {
-                const p = (await ask(opts.rl, "  Provider for dream: "));
-                if (p)
-                    dreamProvider = p;
-                dreamModel = (await ask(opts.rl, "  Model for dream: ")) || dreamModel;
-            }
-        }
-    }
-    else {
-        // v5.9.4 Bug 5 — choice === 2 now means "reset all task overrides to use
-        // default". Show the user what's about to be cleared (the rows currently
-        // pinned to non-default providers) before committing.
+    if (choice === 2) {
         const { Diff } = await import("../ui/diff.js");
         const overridesBeingCleared = Object.entries(cfg.taskModels ?? {})
             .filter(([, v]) => v.provider !== provider || v.model !== model)
@@ -162,26 +107,22 @@ export async function runRoutingSetup(opts) {
             console.log(`${DIM}Cancelled.${RESET}`);
             return false;
         }
-        // Clear every overridden task back to default by deleting the keys.
-        for (const t of TASKS)
-            delete newTaskModels[t];
+        await updateConfig(storePath, { taskModels: {} });
+        printStatus("ok", "routing reset", "all tasks use default provider/model");
+        console.log(Footer("press enter to return"));
+        return true;
     }
-    // Persist
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await updateConfig(opts.directory, {
-        taskModels: newTaskModels,
-        dream: {
-            ...(cfg.dream ?? {}),
-            enabled: dreamEnabledNew,
-            provider: dreamProvider,
-            model: dreamModel,
-        },
+    const patch = await runCommaListRoutingEditor(opts.rl, storePath, cfg);
+    if (!patch) {
+        return false;
+    }
+    await updateConfig(storePath, {
+        taskModels: patch.taskModels,
+        dream: patch.dream,
     });
-    // v5.9.3 Screen 4 — re-render the table with `▶` markers on changed rows
-    // followed by a Diff() block summarizing what shipped. Then a final
-    // status line that names the saved file.
-    const updatedCfg = await loadConfig(opts.directory);
+    const updatedCfg = await loadConfig(storePath);
     const updatedRouting = buildEffectiveRouting(updatedCfg);
+    const dreamEnabledNew = !!updatedCfg.dream?.enabled;
     const finalRows = buildTaskRows(updatedRouting, baseline, dreamEnabledNew);
     console.log("");
     console.log(renderRoutingTable(finalRows));
@@ -196,8 +137,15 @@ export async function runRoutingSetup(opts) {
     }
     console.log(renderRoutingDiff(diffEntries));
     console.log("");
-    printStatus("ok", "routing saved", `${opts.directory}/.gnosys/gnosys.json`);
-    // Footer hint (right-aligned) for any follow-up navigation in the menu flow.
+    printStatus("ok", "routing saved", `${storePath}/gnosys.json`);
+    const keyReqs = buildApiKeyRequirementsFromConfig(updatedCfg);
+    if (keyReqs.length > 0) {
+        const askInput = async (r, prompt) => ask(r, `${prompt}: `);
+        await ensureApiKeys(opts.rl, keyReqs, askInput, {
+            dim: DIM,
+            reset: RESET,
+        });
+    }
     console.log(Footer("press enter to return"));
     return true;
 }

package/dist/lib/setup/sections/taskRoutingEditor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Comma-list task routing editor (provider + model per selected task).
+ */
+import type { Interface as ReadlineInterface } from "readline/promises";
+import { type GnosysConfig } from "../../config.js";
+/**
+ * Let the user pick tasks by number, then provider + model for each.
+ * Returns a patch for taskModels + dream, or null if cancelled.
+ */
+export declare function runCommaListRoutingEditor(rl: ReadlineInterface, storePath: string, cfg: GnosysConfig): Promise<{
+    taskModels: NonNullable<GnosysConfig["taskModels"]>;
+    dream: GnosysConfig["dream"];
+} | null>;
+export declare function applyRoutingPatch(projectDir: string, patch: {
+    taskModels: NonNullable<GnosysConfig["taskModels"]>;
+    dream: GnosysConfig["dream"];
+}): Promise<GnosysConfig>;

package/dist/lib/setup/sections/taskRoutingEditor.js

@@ -0,0 +1,149 @@
+/**
+ * Comma-list task routing editor (provider + model per selected task).
+ */
+import { loadConfig, updateConfig, } from "../../config.js";
+import { ASSIGNABLE_TASK_LIST, fetchDynamicModels, getAssignableRouting, modelForTaskAssignment, parseCommaSeparatedTaskSelection, pickModel, pickProvider, TASK_DESCRIPTIONS, } from "../../setup.js";
+import { resolveActiveStorePath } from "../storePath.js";
+import { safeQuestion } from "../ui/safePrompt.js";
+import { renderProviderMark } from "../providerGlyphs.js";
+import { c, color, glyph } from "../ui/tokens.js";
+import { printStatus } from "../ui/status.js";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+async function askInput(rl, prompt, opts) {
+    const hint = opts?.default ? ` ${DIM}(${opts.default})${RESET}` : "";
+    const raw = await safeQuestion(rl, `${prompt}${hint} `);
+    const trimmed = raw.trim();
+    return trimmed || opts?.default || "";
+}
+async function askYesNo(rl, question, defaultYes = true) {
+    const hint = defaultYes ? "Y/n" : "y/N";
+    const answer = await safeQuestion(rl, `${question} [${hint}] `);
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "")
+        return defaultYes;
+    return trimmed === "y" || trimmed === "yes";
+}
+/**
+ * Let the user pick tasks by number, then provider + model for each.
+ * Returns a patch for taskModels + dream, or null if cancelled.
+ */
+export async function runCommaListRoutingEditor(rl, storePath, cfg) {
+    const tasks = ASSIGNABLE_TASK_LIST;
+    const dreamEnabledBefore = !!cfg.dream?.enabled;
+    const currentByTask = {};
+    for (const task of tasks) {
+        currentByTask[task] = getAssignableRouting(cfg, task);
+    }
+    console.log();
+    console.log(`${BOLD}Which tasks should get a new provider and model?${RESET}`);
+    console.log(`${DIM}Enter numbers (comma-separated), ${BOLD}all${RESET}${DIM}, or ${BOLD}none${RESET}${DIM}. Unlisted tasks keep current routing.${RESET}`);
+    console.log();
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        const cur = currentByTask[task];
+        const desc = TASK_DESCRIPTIONS[task] ?? "";
+        const mark = renderProviderMark(cur.provider);
+        const off = task === "dream" && !dreamEnabledBefore ? `  ${DIM}[off]${RESET}` : "";
+        console.log(`  ${BOLD}${i + 1}.${RESET} ${mark} ${task.padEnd(14)} ${DIM}now:${RESET} ${cur.provider} / ${cur.model}  ${DIM}(${desc})${RESET}${off}`);
+    }
+    console.log();
+    let selectedIndices = [];
+    while (true) {
+        const raw = await askInput(rl, "Tasks to edit (e.g. 1,3,6 or all)", { default: "all" });
+        const parsed = parseCommaSeparatedTaskSelection(raw, tasks.length);
+        if (parsed === "all") {
+            selectedIndices = tasks.map((_, i) => i);
+            break;
+        }
+        if (parsed === "none") {
+            selectedIndices = [];
+            break;
+        }
+        if (parsed && parsed.length > 0) {
+            selectedIndices = parsed;
+            break;
+        }
+        console.log(`${color(c.fail, "Enter numbers 1-" + tasks.length + ", comma-separated, or 'all'.")}`);
+    }
+    if (selectedIndices.length === 0) {
+        printStatus("warn", "no tasks selected");
+        return null;
+    }
+    const selectedSet = new Set(selectedIndices.map((i) => tasks[i]));
+    const planned = { ...currentByTask };
+    const dynamicModels = await fetchDynamicModels();
+    for (const task of tasks) {
+        if (!selectedSet.has(task))
+            continue;
+        console.log("");
+        console.log(`${BOLD}${task}${RESET} ${DIM}— ${TASK_DESCRIPTIONS[task] ?? ""}${RESET}`);
+        const cur = currentByTask[task];
+        const provider = await pickProvider(rl, dynamicModels, "Provider", cur.provider);
+        let model;
+        const tiers = dynamicModels[provider];
+        if (provider === "custom" || !tiers || tiers.length === 0) {
+            model = await askInput(rl, "Model name", { default: cur.model });
+        }
+        else {
+            model = await pickModel(rl, provider, dynamicModels, "Model", cur.model);
+        }
+        if (!model) {
+            printStatus("warn", `skipped ${task} — no model`);
+            continue;
+        }
+        planned[task] = {
+            provider: provider,
+            model: modelForTaskAssignment(task, provider, model),
+        };
+    }
+    console.log();
+    console.log(`${BOLD}Planned task routing${RESET}`);
+    console.log(`  ${"Task".padEnd(16)}${"Provider / model".padEnd(42)}`);
+    console.log(`  ${"\u2500".repeat(56)}`);
+    for (const task of tasks) {
+        const p = planned[task];
+        const marker = selectedSet.has(task) ? `${color(c.accentHi, glyph.selection)} ` : "  ";
+        const off = task === "dream" && !dreamEnabledBefore
+            ? `  ${DIM}(dream off)${RESET}`
+            : "";
+        console.log(`${marker}${task.padEnd(14)}${p.provider} / ${p.model}${off}`);
+    }
+    console.log(`${DIM}  ${glyph.selection} = will update${RESET}`);
+    console.log();
+    if (!(await askYesNo(rl, "Save this routing?", true))) {
+        printStatus("warn", "cancelled");
+        return null;
+    }
+    const taskModels = {
+        ...(cfg.taskModels ?? {}),
+    };
+    for (const task of ASSIGNABLE_TASK_LIST) {
+        if (task === "dream")
+            continue;
+        if (selectedSet.has(task)) {
+            taskModels[task] = planned[task];
+        }
+    }
+    let dream = { ...(cfg.dream ?? {}) };
+    if (selectedSet.has("dream")) {
+        dream = {
+            ...dream,
+            provider: planned.dream.provider,
+            model: planned.dream.model,
+        };
+        if (!dreamEnabledBefore && (await askYesNo(rl, "Enable dream mode?", true))) {
+            dream.enabled = true;
+        }
+    }
+    return { taskModels, dream };
+}
+export async function applyRoutingPatch(projectDir, patch) {
+    const storePath = resolveActiveStorePath(projectDir);
+    await updateConfig(storePath, {
+        taskModels: patch.taskModels,
+        dream: patch.dream,
+    });
+    return loadConfig(storePath);
+}

package/dist/lib/setup/summary.d.ts

@@ -47,9 +47,18 @@ export interface SummaryOptions {
  * (Enter or `done`). Returns true if any section was edited.
  */
 export declare function runSummaryWizard(opts?: SummaryOptions): Promise<boolean>;
+/**
+ * Settings-panel value for multi-machine sync (v13 design).
+ * Shows the configured master folder path, or "NA (single-machine only)" when unset.
+ */
+export declare function formatMultiMachineSyncSummary(remotePath: string | null): string;
+/** Resolve multi-machine sync status for the summary panel row. */
+export declare function describeMultiMachineSyncPanel(): Promise<string>;
 export declare const __test: {
     resolveActiveStorePath: typeof resolveActiveStorePath;
     renderPanelRows: typeof renderPanelRows;
     buildTrailingMap: typeof buildTrailingMap;
+    formatMultiMachineSyncSummary: typeof formatMultiMachineSyncSummary;
+    describeMultiMachineSyncPanel: typeof describeMultiMachineSyncPanel;
 };
 export {};