fix: setup wizard config merging, model selection, and Claude Max TTL

- Proper JSONC parser (state machine) handles comments inside strings,
  trailing commas — no more silent parse failures wiping configs
- All config writers merge into existing files instead of overwriting
- Parse failures skip the file with a warning instead of writing {}
- Model selection follows actual fallback chain order with github-copilot
  per-request models recommended first (correct dotted model names)
- Removed '(free with Copilot)' noise from copilot model labels
- Added Claude Max/Pro question — sets cache_ttl to 59m for Anthropic
- Detect oh-my-openagent.json(c) in addition to oh-my-opencode.json(c)
- Removed stale claude-sonnet-4-5 from historian options

Author: ualtinok

src/cli/opencode-helpers.ts

@@ -70,73 +70,57 @@ export function buildModelSelection(
     const result: { label: string; value: string; recommended?: boolean }[] = [];
     const added = new Set<string>();
 
-    const addIfAvailable = (pattern: string, recommended = false) => {
+    const addIfAvailable = (pattern: string, hint?: string) => {
         const matches = allModels.filter((m) => m === pattern || m.endsWith(`/${pattern}`));
         for (const m of matches) {
             if (!added.has(m)) {
                 added.add(m);
                 result.push({
-                    label: m,
+                    label: hint ? `${m} — ${hint}` : m,
                     value: m,
-                    recommended: recommended && result.length === 0,
+                    recommended: result.length === 0,
                 });
             }
         }
     };
 
     if (role === "historian") {
-        // Per-request models first — cheap, fast, good at summarization
-        addIfAvailable("claude-sonnet-4-6", true);
-        addIfAvailable("claude-sonnet-4-5");
-        addIfAvailable("gemini-3.1-pro");
-        addIfAvailable("gpt-5.4");
-        addIfAvailable("glm-5");
-        addIfAvailable("minimax-m2.7");
-
-        // Copilot-backed models (free for copilot users)
-        for (const m of allModels.filter((m) => m.startsWith("github-copilot/"))) {
-            if (!added.has(m)) {
-                added.add(m);
-                result.push({ label: `${m} (free with Copilot)`, value: m });
-            }
-        }
+        // Follow the actual fallback chain order.
+        // Per-request providers first (github-copilot) — better for historian's
+        // single long prompt/request pattern vs token-based billing.
+        addIfAvailable("github-copilot/claude-sonnet-4.6", "per-request billing");
+        addIfAvailable("anthropic/claude-sonnet-4-6");
+        addIfAvailable("github-copilot/gpt-5.4", "per-request billing");
+        addIfAvailable("openai/gpt-5.4");
+        addIfAvailable("github-copilot/gemini-3.1-pro-preview", "per-request billing");
+        addIfAvailable("opencode-go/minimax-m2.7");
+        addIfAvailable("opencode-go/glm-5");
     } else if (role === "dreamer") {
         // Local/cheap models first — dreamer runs overnight
         for (const m of allModels.filter((m) => m.startsWith("ollama/"))) {
             if (!added.has(m)) {
                 added.add(m);
-                result.push({ label: `${m} (local)`, value: m, recommended: result.length === 0 });
+                result.push({ label: `${m} — local`, value: m, recommended: result.length === 0 });
             }
         }
 
-        addIfAvailable("claude-sonnet-4-6", result.length === 0);
-        addIfAvailable("gemini-3-flash");
-        addIfAvailable("glm-5");
-        addIfAvailable("minimax-m2.7");
-        addIfAvailable("gpt-5.4-mini");
-
-        for (const m of allModels.filter((m) => m.startsWith("github-copilot/"))) {
-            if (!added.has(m)) {
-                added.add(m);
-                result.push({ label: `${m} (free with Copilot)`, value: m });
-            }
-        }
+        addIfAvailable("github-copilot/claude-sonnet-4.6", "per-request billing");
+        addIfAvailable("anthropic/claude-sonnet-4-6");
+        addIfAvailable("github-copilot/gemini-3-flash-preview", "per-request billing");
+        addIfAvailable("opencode-go/glm-5");
+        addIfAvailable("opencode-go/minimax-m2.7");
     } else if (role === "sidekick") {
         // Fast models first
         for (const m of allModels.filter((m) => m.startsWith("cerebras/"))) {
             if (!added.has(m)) {
                 added.add(m);
-                result.push({
-                    label: `${m} (fastest)`,
-                    value: m,
-                    recommended: result.length === 0,
-                });
+                result.push({ label: m, value: m, recommended: result.length === 0 });
             }
         }
 
-        addIfAvailable("gpt-5-nano");
-        addIfAvailable("gemini-3-flash");
-        addIfAvailable("gpt-5.4-mini");
+        addIfAvailable("opencode/gpt-5-nano");
+        addIfAvailable("github-copilot/gemini-3-flash-preview");
+        addIfAvailable("github-copilot/gpt-5-mini");
     }
 
     return result;

src/cli/setup.ts

@@ -19,19 +19,62 @@ function ensureDir(dir: string): void {
     }
 }
 
-function stripJsoncComments(text: string): string {
-    return text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+function stripJsoncToJson(text: string): string {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let escaped = false;
+
+    while (i < text.length) {
+        const ch = text[i];
+
+        if (escaped) {
+            result += ch;
+            escaped = false;
+            i++;
+            continue;
+        }
+
+        if (inString) {
+            if (ch === "\\") escaped = true;
+            else if (ch === '"') inString = false;
+            result += ch;
+            i++;
+            continue;
+        }
+
+        // Line comment
+        if (ch === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n") i++;
+            continue;
+        }
+
+        // Block comment
+        if (ch === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+            i += 2;
+            continue;
+        }
+
+        if (ch === '"') inString = true;
+        result += ch;
+        i++;
+    }
+
+    // Strip trailing commas before } or ]
+    return result.replace(/,(\s*[}\]])/g, "$1");
 }
 
-function readJsonc(path: string): Record<string, unknown> {
+function readJsonc(path: string): Record<string, unknown> | null {
     const content = readFileSync(path, "utf-8");
     try {
-        return JSON.parse(stripJsoncComments(content));
-    } catch {
-        return {};
+        return JSON.parse(stripJsoncToJson(content));
+    } catch (err) {
+        console.error(`  ⚠ Failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+        return null;
     }
 }
-
 // ─── Config Manipulators ──────────────────────────────────
 
 function addPluginToOpenCodeConfig(configPath: string, format: "json" | "jsonc" | "none"): void {
@@ -48,6 +91,10 @@ function addPluginToOpenCodeConfig(configPath: string, format: "json" | "jsonc"
 
     // Read existing config, merge our changes, preserve everything else
     const existing = readJsonc(configPath);
+    if (!existing) {
+        log.warn(`Could not parse ${configPath} — skipping to avoid data loss`);
+        return;
+    }
 
     // Add plugin if not present
     const plugins = (existing.plugin as string[]) ?? [];
@@ -74,11 +121,12 @@ function writeMagicContextConfig(
         dreamerModel: string | null;
         sidekickEnabled: boolean;
         sidekickModel: string | null;
+        claudeMax: boolean;
     },
 ): void {
     // Read existing config to preserve user's other settings
-    const config: Record<string, unknown> = existsSync(configPath) ? readJsonc(configPath) : {};
-
+    const config: Record<string, unknown> =
+        (existsSync(configPath) ? readJsonc(configPath) : null) ?? {};
     if (options.historianModel) {
         const historian = (config.historian as Record<string, unknown>) ?? {};
         historian.model = options.historianModel;
@@ -107,13 +155,23 @@ function writeMagicContextConfig(
         config.sidekick = sidekick;
     }
 
+    if (options.claudeMax) {
+        const cacheTtl = (config.cache_ttl as Record<string, string>) ?? {};
+        if (!cacheTtl.default) cacheTtl.default = "5m";
+        cacheTtl["anthropic/claude-sonnet-4-6"] = "59m";
+        cacheTtl["anthropic/claude-opus-4-6"] = "59m";
+        config.cache_ttl = cacheTtl;
+    }
+
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
 }
-
 function disableOmoHooks(omoConfigPath: string): void {
     const config = readJsonc(omoConfigPath);
+    if (!config) {
+        log.warn(`Could not parse ${omoConfigPath} — skipping to avoid data loss`);
+        return;
+    }
     const disabledHooks = (config.disabled_hooks as string[]) ?? [];
-
     const hooksToDisable = [
         "context-window-monitor",
         "preemptive-compaction",
@@ -233,13 +291,28 @@ export async function runSetup(): Promise<number> {
         log.info("Using built-in fallback chain for sidekick");
     }
 
+    // ─── Claude Max subscription ────────────────────────
+    const hasAnthropic = allModels.some((m) => m.startsWith("anthropic/"));
+    let claudeMax = false;
+    if (hasAnthropic) {
+        log.message(
+            "Claude Max/Pro subscribers get extended prompt caching (up to 1 hour).\n" +
+                "This lets Magic Context defer context operations much longer, saving money.",
+        );
+        claudeMax = await confirm("Do you have a Claude Max or Pro subscription?", false);
+        if (claudeMax) {
+            log.success("Cache TTL set to 59m for Anthropic models");
+        }
+    }
+
     // Write magic-context config
     writeMagicContextConfig(paths.magicContextConfig, {
         historianModel,
         dreamerEnabled,
         dreamerModel,
         sidekickEnabled,
         sidekickModel,
+        claudeMax,
     });
     log.success(`Config written to ${paths.magicContextConfig}`);