gsd-pi 2.76.0 → 2.77.0

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -34,6 +34,144 @@ function tryParsePercentage(val) {
     const n = Number(val);
     return !isNaN(n) && n >= 0 && n <= 100 ? n : null;
 }
+// ─── Prompt helpers (reduce boilerplate across configure* functions) ─────────
+/** Ask for a boolean; returns the chosen value, or undefined if user kept current/escaped. */
+async function promptBoolean(ctx, label, current, defaultVal) {
+    const currentStr = typeof current === "boolean" ? String(current) : "";
+    const suffix = currentStr
+        ? ` (current: ${currentStr})`
+        : defaultVal !== undefined ? ` (default: ${defaultVal})` : "";
+    const choice = await ctx.ui.select(`${label}${suffix}:`, ["true", "false", "(keep current)"]);
+    if (!choice || choice === "(keep current)")
+        return undefined;
+    return choice === "true";
+}
+/** Ask for an enum-style value; returns the chosen string, or undefined if kept. */
+async function promptEnum(ctx, label, current, values, defaultVal) {
+    const currentStr = typeof current === "string" ? current : "";
+    const suffix = currentStr
+        ? ` (current: ${currentStr})`
+        : defaultVal ? ` (default: ${defaultVal})` : "";
+    const options = [...values, "(keep current)"];
+    const choice = await ctx.ui.select(`${label}${suffix}:`, options);
+    if (!choice || typeof choice !== "string" || choice === "(keep current)")
+        return undefined;
+    return choice;
+}
+/**
+ * Ask for a non-negative integer.
+ * Returns parsed number on success; "clear" when the user explicitly cleared an existing value;
+ * undefined on escape, empty-with-no-existing-value, or invalid input (warning emitted in the invalid case).
+ */
+async function promptInteger(ctx, label, current, defaultVal) {
+    const hadValue = current !== undefined && current !== null;
+    const currentStr = hadValue ? String(current) : "";
+    const suffix = currentStr ? ` (current: ${currentStr})` : defaultVal ? ` (default: ${defaultVal})` : "";
+    const input = await ctx.ui.input(`${label}${suffix}:`, currentStr || (defaultVal ?? ""));
+    if (input === null || input === undefined)
+        return undefined;
+    const val = input.trim();
+    if (!val)
+        return hadValue ? "clear" : undefined;
+    const parsed = tryParseInteger(val);
+    if (parsed === null) {
+        ctx.ui.notify(`Invalid value "${val}" for ${label} — must be a whole number. Keeping previous value.`, "warning");
+        return undefined;
+    }
+    return parsed;
+}
+/** Ask for a finite number. See promptInteger for return semantics. */
+async function promptNumber(ctx, label, current, defaultVal) {
+    const hadValue = current !== undefined && current !== null;
+    const currentStr = hadValue ? String(current) : "";
+    const suffix = currentStr ? ` (current: ${currentStr})` : defaultVal ? ` (default: ${defaultVal})` : "";
+    const input = await ctx.ui.input(`${label}${suffix}:`, currentStr || (defaultVal ?? ""));
+    if (input === null || input === undefined)
+        return undefined;
+    const val = input.trim();
+    if (!val)
+        return hadValue ? "clear" : undefined;
+    const parsed = tryParseNumber(val);
+    if (parsed === null) {
+        ctx.ui.notify(`Invalid value "${val}" for ${label} — must be a number. Keeping previous value.`, "warning");
+        return undefined;
+    }
+    return parsed;
+}
+/** Apply a promptInteger/promptNumber result to a prefs dict. */
+function applyNumber(prefs, key, result) {
+    if (result === undefined)
+        return;
+    if (result === "clear")
+        delete prefs[key];
+    else
+        prefs[key] = result;
+}
+/** Ask for a free-form string; returns the trimmed value, empty string to clear, or undefined if escaped. */
+async function promptString(ctx, label, current, defaultVal) {
+    const currentStr = typeof current === "string" ? current : "";
+    const suffix = currentStr ? ` (current: ${currentStr})` : defaultVal ? ` (default: ${defaultVal})` : "";
+    const input = await ctx.ui.input(`${label}${suffix}:`, currentStr || (defaultVal ?? ""));
+    if (input === null || input === undefined)
+        return undefined;
+    return input.trim();
+}
+/** Parse comma- or newline-separated input into a deduplicated string array. */
+function parseStringList(input) {
+    return input
+        .split(/[,\n]/)
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}
+/** Sub-menu to edit a string list field (add / remove / clear / done). Mutates the parent prefs object. */
+async function editStringListField(ctx, prefs, key, label) {
+    const current = Array.isArray(prefs[key]) ? [...prefs[key]] : [];
+    let list = current;
+    while (true) {
+        const summary = list.length === 0 ? "(empty)" : `${list.length} item(s): ${list.slice(0, 3).join(", ")}${list.length > 3 ? "…" : ""}`;
+        const choice = await ctx.ui.select(`${label} — ${summary}`, ["Add entries", "Remove entry", "Clear all", "Done"]);
+        const pick = typeof choice === "string" ? choice : "";
+        if (!pick || pick === "Done")
+            break;
+        if (pick === "Add entries") {
+            const input = await ctx.ui.input(`Add to ${label} (comma- or newline-separated):`, "");
+            if (input) {
+                for (const item of parseStringList(input)) {
+                    if (!list.includes(item))
+                        list.push(item);
+                }
+            }
+        }
+        else if (pick === "Remove entry") {
+            if (list.length === 0)
+                continue;
+            const removeChoice = await ctx.ui.select(`Remove which entry?`, [...list, "(cancel)"]);
+            const removeStr = typeof removeChoice === "string" ? removeChoice : "";
+            if (removeStr && removeStr !== "(cancel)") {
+                list = list.filter(x => x !== removeStr);
+            }
+        }
+        else if (pick === "Clear all") {
+            list = [];
+        }
+    }
+    if (list.length > 0) {
+        prefs[key] = list;
+    }
+    else if (prefs[key] !== undefined) {
+        delete prefs[key];
+    }
+}
+/** Set a nested object key, creating the parent object if needed, and deleting on undefined/empty. */
+function setNested(parent, parentKey, childKey, value) {
+    let child = parent[parentKey];
+    if (!child || typeof child !== "object")
+        child = {};
+    if (value === undefined)
+        return;
+    child[childKey] = value;
+    parent[parentKey] = child;
+}
 export async function handlePrefs(args, ctx) {
     const trimmed = args.trim();
     if (trimmed === "" || trimmed === "global" || trimmed === "wizard" || trimmed === "setup"
@@ -135,10 +273,26 @@ export function buildCategorySummaries(prefs) {
     const modeSummary = mode ?? "(not set)";
     // Models
     const models = prefs.models;
+    const tokenProfile = prefs.token_profile;
+    const serviceTier = prefs.service_tier;
+    const flatRate = Array.isArray(prefs.flat_rate_providers) ? prefs.flat_rate_providers.length : 0;
+    const dynRouting = prefs.dynamic_routing;
     let modelsSummary = "(not configured)";
-    if (models && Object.keys(models).length > 0) {
-        const parts = Object.entries(models).map(([phase, model]) => `${phase}: ${formatConfiguredModel(model)}`);
-        modelsSummary = parts.join(", ");
+    {
+        const parts = [];
+        if (models && Object.keys(models).length > 0) {
+            parts.push(`${Object.keys(models).length} phase(s)`);
+        }
+        if (tokenProfile)
+            parts.push(`profile: ${tokenProfile}`);
+        if (serviceTier)
+            parts.push(`tier: ${serviceTier}`);
+        if (flatRate)
+            parts.push(`flat-rate: ${flatRate}`);
+        if (dynRouting?.enabled)
+            parts.push("routing: on");
+        if (parts.length > 0)
+            modelsSummary = parts.join(", ");
     }
     // Timeouts
     const autoSup = prefs.auto_supervisor;
@@ -173,14 +327,32 @@ export function buildCategorySummaries(prefs) {
     // Skills
     const discovery = prefs.skill_discovery;
     const uat = prefs.uat_dispatch;
+    const alwaysUse = Array.isArray(prefs.always_use_skills) ? prefs.always_use_skills.length : 0;
+    const preferS = Array.isArray(prefs.prefer_skills) ? prefs.prefer_skills.length : 0;
+    const avoidS = Array.isArray(prefs.avoid_skills) ? prefs.avoid_skills.length : 0;
+    const rulesCount = Array.isArray(prefs.skill_rules) ? prefs.skill_rules.length : 0;
+    const customInstr = Array.isArray(prefs.custom_instructions) ? prefs.custom_instructions.length : 0;
     let skillsSummary = "(not configured)";
-    if (discovery || uat !== undefined) {
+    {
         const parts = [];
         if (discovery)
             parts.push(`discovery: ${discovery}`);
         if (uat !== undefined)
             parts.push(`uat: ${uat}`);
-        skillsSummary = parts.join(", ");
+        if (alwaysUse)
+            parts.push(`always: ${alwaysUse}`);
+        if (preferS)
+            parts.push(`prefer: ${preferS}`);
+        if (avoidS)
+            parts.push(`avoid: ${avoidS}`);
+        if (rulesCount)
+            parts.push(`rules: ${rulesCount}`);
+        if (customInstr)
+            parts.push(`custom: ${customInstr}`);
+        if (prefs.skill_staleness_days !== undefined)
+            parts.push(`stale: ${prefs.skill_staleness_days}d`);
+        if (parts.length > 0)
+            skillsSummary = parts.join(", ");
     }
     // Budget
     const ceiling = prefs.budget_ceiling;
@@ -204,9 +376,145 @@ export function buildCategorySummaries(prefs) {
     }
     // Advanced
     const uniqueIds = prefs.unique_milestone_ids;
+    const experimentalRtk = prefs.experimental?.rtk;
     let advancedSummary = "(defaults)";
-    if (uniqueIds !== undefined) {
-        advancedSummary = `unique IDs: ${uniqueIds ? "on" : "off"}`;
+    {
+        const parts = [];
+        if (uniqueIds !== undefined)
+            parts.push(`unique: ${uniqueIds ? "on" : "off"}`);
+        if (prefs.auto_visualize !== undefined)
+            parts.push(`viz: ${prefs.auto_visualize ? "on" : "off"}`);
+        if (prefs.auto_report !== undefined)
+            parts.push(`report: ${prefs.auto_report ? "on" : "off"}`);
+        if (prefs.show_token_cost)
+            parts.push("cost-display");
+        if (prefs.forensics_dedup)
+            parts.push("forensics-dedup");
+        if (prefs.widget_mode)
+            parts.push(`widget: ${prefs.widget_mode}`);
+        if (experimentalRtk)
+            parts.push("rtk");
+        if (parts.length > 0)
+            advancedSummary = parts.join(", ");
+    }
+    // Phases
+    const phases = prefs.phases;
+    let phasesSummary = "(defaults)";
+    if (phases && Object.keys(phases).length > 0) {
+        const activeFlags = Object.entries(phases).filter(([, v]) => v === true).map(([k]) => k);
+        phasesSummary = activeFlags.length === 0 ? "(no flags)" : `${activeFlags.length} flag(s): ${activeFlags.slice(0, 2).join(", ")}${activeFlags.length > 2 ? "…" : ""}`;
+    }
+    // Parallelism
+    const parallel = prefs.parallel;
+    const sliceParallel = prefs.slice_parallel;
+    let parallelismSummary = "(defaults)";
+    {
+        const parts = [];
+        if (parallel?.enabled)
+            parts.push(`milestone: ${parallel.max_workers ?? 2}w`);
+        if (sliceParallel?.enabled)
+            parts.push(`slice: ${sliceParallel.max_workers ?? 2}w`);
+        if (parts.length > 0)
+            parallelismSummary = parts.join(", ");
+    }
+    // Verification
+    const verifyCmds = Array.isArray(prefs.verification_commands) ? prefs.verification_commands.length : 0;
+    const safety = prefs.safety_harness;
+    let verificationSummary = "(defaults)";
+    {
+        const parts = [];
+        if (verifyCmds)
+            parts.push(`${verifyCmds} cmd(s)`);
+        if (prefs.verification_auto_fix)
+            parts.push("auto-fix");
+        if (prefs.enhanced_verification === false)
+            parts.push("enhanced: off");
+        if (prefs.enhanced_verification_strict)
+            parts.push("strict");
+        if (safety?.enabled === false)
+            parts.push("harness: off");
+        else if (safety && Object.keys(safety).length > 0)
+            parts.push("harness: custom");
+        if (parts.length > 0)
+            verificationSummary = parts.join(", ");
+    }
+    // Discuss
+    let discussSummary = "(defaults)";
+    {
+        const parts = [];
+        if (prefs.discuss_preparation === false)
+            parts.push("prep: off");
+        if (prefs.discuss_web_research === false)
+            parts.push("web: off");
+        if (prefs.discuss_depth)
+            parts.push(`depth: ${prefs.discuss_depth}`);
+        if (parts.length > 0)
+            discussSummary = parts.join(", ");
+    }
+    // Context & Codebase
+    const ctxMgmt = prefs.context_management;
+    const codebase = prefs.codebase;
+    let contextSummary = "(defaults)";
+    {
+        const parts = [];
+        if (prefs.context_selection)
+            parts.push(`selection: ${prefs.context_selection}`);
+        if (ctxMgmt && Object.keys(ctxMgmt).length > 0)
+            parts.push(`mgmt: ${Object.keys(ctxMgmt).length} field(s)`);
+        if (prefs.context_window_override !== undefined)
+            parts.push(`override: ${prefs.context_window_override}`);
+        if (codebase && Object.keys(codebase).length > 0)
+            parts.push("codebase: custom");
+        if (parts.length > 0)
+            contextSummary = parts.join(", ");
+    }
+    // Hooks & Reactive
+    const reactive = prefs.reactive_execution;
+    const gateEval = prefs.gate_evaluation;
+    const postHooks = Array.isArray(prefs.post_unit_hooks) ? prefs.post_unit_hooks.length : 0;
+    const preHooks = Array.isArray(prefs.pre_dispatch_hooks) ? prefs.pre_dispatch_hooks.length : 0;
+    let hooksSummary = "(defaults)";
+    {
+        const parts = [];
+        if (postHooks)
+            parts.push(`post: ${postHooks}`);
+        if (preHooks)
+            parts.push(`pre: ${preHooks}`);
+        if (reactive?.enabled)
+            parts.push("reactive: on");
+        if (gateEval?.enabled)
+            parts.push("gate-eval: on");
+        if (parts.length > 0)
+            hooksSummary = parts.join(", ");
+    }
+    // UoK
+    const uok = prefs.uok;
+    let uokSummary = "(defaults)";
+    if (uok && Object.keys(uok).length > 0) {
+        if (uok.enabled === false)
+            uokSummary = "off";
+        else
+            uokSummary = `${Object.keys(uok).length} setting(s)`;
+    }
+    // Integrations
+    const cmux = prefs.cmux;
+    const remote = prefs.remote_questions;
+    const github = prefs.github;
+    let integrationsSummary = "(defaults)";
+    {
+        const parts = [];
+        if (prefs.language)
+            parts.push(`lang: ${prefs.language}`);
+        if (prefs.search_provider)
+            parts.push(`search: ${prefs.search_provider}`);
+        if (cmux?.enabled)
+            parts.push("cmux");
+        if (remote?.channel)
+            parts.push(`remote: ${remote.channel}`);
+        if (github?.enabled)
+            parts.push("github");
+        if (parts.length > 0)
+            integrationsSummary = parts.join(", ");
     }
     return {
         mode: modeSummary,
@@ -217,6 +525,14 @@ export function buildCategorySummaries(prefs) {
         budget: budgetSummary,
         notifications: notifSummary,
         advanced: advancedSummary,
+        phases: phasesSummary,
+        parallelism: parallelismSummary,
+        verification: verificationSummary,
+        discuss: discussSummary,
+        context: contextSummary,
+        hooks: hooksSummary,
+        uok: uokSummary,
+        integrations: integrationsSummary,
     };
 }
 // ─── Category configuration functions ────────────────────────────────────────
@@ -342,6 +658,62 @@ async function configureModels(ctx, prefs) {
     else {
         delete prefs.models;
     }
+    // ─── Extra routing-level model preferences ────────────────────────────────
+    const tokenProfile = await promptEnum(ctx, "Token profile (cost/quality tradeoff)", prefs.token_profile, ["budget", "balanced", "quality", "burn-max"]);
+    if (tokenProfile !== undefined)
+        prefs.token_profile = tokenProfile;
+    const serviceTier = await promptEnum(ctx, "OpenAI service tier (gpt-5.4 only)", prefs.service_tier, ["priority", "flex"]);
+    if (serviceTier !== undefined)
+        prefs.service_tier = serviceTier;
+    await editStringListField(ctx, prefs, "flat_rate_providers", "Flat-rate providers (suppress dynamic routing)");
+    await configureDynamicRouting(ctx, prefs);
+}
+async function configureDynamicRouting(ctx, prefs) {
+    const dr = prefs.dynamic_routing ?? {};
+    const enabled = await promptBoolean(ctx, "Enable dynamic routing (tier-based model selection)", dr.enabled);
+    if (enabled !== undefined)
+        dr.enabled = enabled;
+    if (dr.enabled !== true) {
+        // If routing is disabled / kept-off, still let the user configure sub-fields (they may enable later).
+    }
+    const cap = await promptBoolean(ctx, "Capability-aware routing", dr.capability_routing, false);
+    if (cap !== undefined)
+        dr.capability_routing = cap;
+    const escalate = await promptBoolean(ctx, "Escalate to heavier tier on failure", dr.escalate_on_failure, true);
+    if (escalate !== undefined)
+        dr.escalate_on_failure = escalate;
+    const pressure = await promptBoolean(ctx, "Downgrade under budget pressure", dr.budget_pressure, true);
+    if (pressure !== undefined)
+        dr.budget_pressure = pressure;
+    const cross = await promptBoolean(ctx, "Cross-provider routing", dr.cross_provider, true);
+    if (cross !== undefined)
+        dr.cross_provider = cross;
+    const hooks = await promptBoolean(ctx, "Route hook sessions dynamically", dr.hooks, true);
+    if (hooks !== undefined)
+        dr.hooks = hooks;
+    const flatRate = await promptBoolean(ctx, "Allow dynamic routing for flat-rate providers", dr.allow_flat_rate_providers, false);
+    if (flatRate !== undefined)
+        dr.allow_flat_rate_providers = flatRate;
+    // tier_models.light / standard / heavy — optional model IDs
+    const tierModels = dr.tier_models ?? {};
+    for (const tier of ["light", "standard", "heavy"]) {
+        const current = typeof tierModels[tier] === "string" ? tierModels[tier] : "";
+        const input = await promptString(ctx, `Model for ${tier} tier (e.g. claude-haiku-4-5)`, current);
+        if (input === undefined)
+            continue;
+        if (input)
+            tierModels[tier] = input;
+        else if (current)
+            delete tierModels[tier];
+    }
+    if (Object.keys(tierModels).length > 0)
+        dr.tier_models = tierModels;
+    else
+        delete dr.tier_models;
+    if (Object.keys(dr).length > 0)
+        prefs.dynamic_routing = dr;
+    else if (prefs.dynamic_routing !== undefined)
+        delete prefs.dynamic_routing;
 }
 async function configureTimeouts(ctx, prefs) {
     const autoSup = prefs.auto_supervisor ?? {};
@@ -477,17 +849,90 @@ async function configureGit(ctx, prefs) {
 }
 async function configureSkills(ctx, prefs) {
     // Skill discovery mode
-    const currentDiscovery = prefs.skill_discovery ?? "";
-    const discoveryChoice = await ctx.ui.select(`Skill discovery mode${currentDiscovery ? ` (current: ${currentDiscovery})` : ""}:`, ["auto", "suggest", "off", "(keep current)"]);
-    if (discoveryChoice && discoveryChoice !== "(keep current)") {
-        prefs.skill_discovery = discoveryChoice;
-    }
+    const discovery = await promptEnum(ctx, "Skill discovery mode", prefs.skill_discovery, ["auto", "suggest", "off"]);
+    if (discovery !== undefined)
+        prefs.skill_discovery = discovery;
     // UAT dispatch
-    const currentUat = prefs.uat_dispatch;
-    const uatChoice = await ctx.ui.select(`UAT dispatch mode${currentUat !== undefined ? ` (current: ${currentUat})` : " (default: false)"}:`, ["true", "false", "(keep current)"]);
-    if (uatChoice && uatChoice !== "(keep current)") {
-        prefs.uat_dispatch = uatChoice === "true";
+    const uat = await promptBoolean(ctx, "UAT dispatch mode", prefs.uat_dispatch, false);
+    if (uat !== undefined)
+        prefs.uat_dispatch = uat;
+    // Skill lists — edit via sub-menus
+    await editStringListField(ctx, prefs, "always_use_skills", "Always-use skills");
+    await editStringListField(ctx, prefs, "prefer_skills", "Preferred skills");
+    await editStringListField(ctx, prefs, "avoid_skills", "Avoided skills");
+    await editStringListField(ctx, prefs, "custom_instructions", "Custom instructions");
+    // Skill rules (array of {when, use?, prefer?, avoid?})
+    await configureSkillRules(ctx, prefs);
+    // Skill staleness days
+    const staleness = await promptInteger(ctx, "Skill staleness days (0 to disable)", prefs.skill_staleness_days, "60");
+    applyNumber(prefs, "skill_staleness_days", staleness);
+}
+async function configureSkillRules(ctx, prefs) {
+    let rules = Array.isArray(prefs.skill_rules) ? [...prefs.skill_rules] : [];
+    while (true) {
+        const summary = rules.length === 0
+            ? "(no rules)"
+            : `${rules.length} rule(s)`;
+        const listLabels = rules.map((r, i) => `#${i + 1} when: ${r.when}`);
+        const options = [...listLabels, "Add rule", "Done"];
+        const choice = await ctx.ui.select(`Skill rules — ${summary}`, options);
+        const pick = typeof choice === "string" ? choice : "";
+        if (!pick || pick === "Done")
+            break;
+        if (pick === "Add rule") {
+            const whenInput = await ctx.ui.input("Rule condition (free text, e.g. 'frontend tasks'):", "");
+            const when = typeof whenInput === "string" ? whenInput.trim() : "";
+            if (!when)
+                continue;
+            const rule = { when };
+            for (const field of ["use", "prefer", "avoid"]) {
+                const listInput = await ctx.ui.input(`Skills to ${field} (comma- or newline-separated, blank to skip):`, "");
+                if (listInput) {
+                    const parsed = parseStringList(listInput);
+                    if (parsed.length > 0)
+                        rule[field] = parsed;
+                }
+            }
+            if (rule.use || rule.prefer || rule.avoid)
+                rules.push(rule);
+            else
+                ctx.ui.notify("Rule discarded — must have at least one of use/prefer/avoid.", "warning");
+        }
+        else if (pick.startsWith("#")) {
+            const idx = Number(pick.slice(1, pick.indexOf(" "))) - 1;
+            if (idx < 0 || idx >= rules.length)
+                continue;
+            const editChoice = await ctx.ui.select(`Rule #${idx + 1}`, ["Edit condition", "Edit use list", "Edit prefer list", "Edit avoid list", "Delete rule", "Cancel"]);
+            const ec = typeof editChoice === "string" ? editChoice : "";
+            if (!ec || ec === "Cancel")
+                continue;
+            if (ec === "Delete rule") {
+                rules = rules.filter((_, i) => i !== idx);
+                continue;
+            }
+            if (ec === "Edit condition") {
+                const newWhen = await promptString(ctx, "Rule condition", rules[idx].when);
+                if (newWhen !== undefined && newWhen !== "")
+                    rules[idx].when = newWhen;
+            }
+            else {
+                const fieldKey = ec === "Edit use list" ? "use" : ec === "Edit prefer list" ? "prefer" : "avoid";
+                const currentList = rules[idx][fieldKey] ?? [];
+                const listInput = await ctx.ui.input(`${fieldKey} list (comma- or newline-separated, blank to clear):`, currentList.join(", "));
+                if (listInput === null || listInput === undefined)
+                    continue;
+                const parsed = parseStringList(listInput);
+                if (parsed.length > 0)
+                    rules[idx][fieldKey] = parsed;
+                else
+                    delete rules[idx][fieldKey];
+            }
+        }
     }
+    if (rules.length > 0)
+        prefs.skill_rules = rules;
+    else if (prefs.skill_rules !== undefined)
+        delete prefs.skill_rules;
 }
 async function configureBudget(ctx, prefs) {
     const currentCeiling = prefs.budget_ceiling;
@@ -552,6 +997,451 @@ async function configureNotifications(ctx, prefs) {
         prefs.notifications = notif;
     }
 }
+async function configurePhases(ctx, prefs) {
+    const phases = prefs.phases ?? {};
+    const fields = [
+        { key: "skip_research", label: "Skip research phase" },
+        { key: "skip_reassess", label: "Skip roadmap reassessment" },
+        { key: "skip_slice_research", label: "Skip slice-level research" },
+        { key: "skip_milestone_validation", label: "Skip milestone validation" },
+        { key: "reassess_after_slice", label: "Reassess roadmap after each slice" },
+        { key: "require_slice_discussion", label: "Pause for discussion before each slice" },
+        { key: "mid_execution_escalation", label: "Allow mid-execution escalation (ADR-011 P2)" },
+        { key: "progressive_planning", label: "Progressive planning (S01 full, S02+ sketches)" },
+    ];
+    for (const field of fields) {
+        const val = await promptBoolean(ctx, field.label, phases[field.key]);
+        if (val !== undefined)
+            phases[field.key] = val;
+    }
+    if (Object.keys(phases).length > 0)
+        prefs.phases = phases;
+    else if (prefs.phases !== undefined)
+        delete prefs.phases;
+}
+async function configureParallelism(ctx, prefs) {
+    // parallel: milestone-level
+    const parallel = prefs.parallel ?? {};
+    const pEnabled = await promptBoolean(ctx, "Parallel milestone execution", parallel.enabled, false);
+    if (pEnabled !== undefined)
+        parallel.enabled = pEnabled;
+    const pWorkers = await promptInteger(ctx, "Max parallel workers (1–4)", parallel.max_workers, "2");
+    if (pWorkers !== undefined && pWorkers !== "clear")
+        parallel.max_workers = Math.max(1, Math.min(4, pWorkers));
+    else if (pWorkers === "clear")
+        delete parallel.max_workers;
+    const pBudget = await promptNumber(ctx, "Per-worker budget ceiling (USD, blank = no limit)", parallel.budget_ceiling);
+    if (pBudget !== undefined && pBudget !== "clear")
+        parallel.budget_ceiling = pBudget;
+    else if (pBudget === "clear")
+        delete parallel.budget_ceiling;
+    const pMerge = await promptEnum(ctx, "Parallel merge strategy", parallel.merge_strategy, ["per-slice", "per-milestone"]);
+    if (pMerge !== undefined)
+        parallel.merge_strategy = pMerge;
+    const pAuto = await promptEnum(ctx, "Auto-merge mode", parallel.auto_merge, ["auto", "confirm", "manual"]);
+    if (pAuto !== undefined)
+        parallel.auto_merge = pAuto;
+    const pWorkerModel = await promptString(ctx, "Worker model override (e.g. claude-haiku-4-5)", parallel.worker_model);
+    if (pWorkerModel !== undefined) {
+        if (pWorkerModel)
+            parallel.worker_model = pWorkerModel;
+        else
+            delete parallel.worker_model;
+    }
+    if (Object.keys(parallel).length > 0)
+        prefs.parallel = parallel;
+    else if (prefs.parallel !== undefined)
+        delete prefs.parallel;
+    // slice_parallel: slice-level
+    const sp = prefs.slice_parallel ?? {};
+    const spEnabled = await promptBoolean(ctx, "Slice-level parallel execution", sp.enabled, false);
+    if (spEnabled !== undefined)
+        sp.enabled = spEnabled;
+    const spWorkers = await promptInteger(ctx, "Slice max workers", sp.max_workers, "2");
+    if (spWorkers !== undefined && spWorkers !== "clear")
+        sp.max_workers = spWorkers;
+    else if (spWorkers === "clear")
+        delete sp.max_workers;
+    if (Object.keys(sp).length > 0)
+        prefs.slice_parallel = sp;
+    else if (prefs.slice_parallel !== undefined)
+        delete prefs.slice_parallel;
+}
+async function configureVerification(ctx, prefs) {
+    await editStringListField(ctx, prefs, "verification_commands", "Verification commands");
+    const autoFix = await promptBoolean(ctx, "Auto-fix on verification failure", prefs.verification_auto_fix);
+    if (autoFix !== undefined)
+        prefs.verification_auto_fix = autoFix;
+    const maxRetries = await promptInteger(ctx, "Verification max retries", prefs.verification_max_retries, "2");
+    applyNumber(prefs, "verification_max_retries", maxRetries);
+    const ev = await promptBoolean(ctx, "Enhanced verification (master toggle)", prefs.enhanced_verification, true);
+    if (ev !== undefined)
+        prefs.enhanced_verification = ev;
+    const evPre = await promptBoolean(ctx, "Enhanced verification — pre-execution checks", prefs.enhanced_verification_pre, true);
+    if (evPre !== undefined)
+        prefs.enhanced_verification_pre = evPre;
+    const evPost = await promptBoolean(ctx, "Enhanced verification — post-execution checks", prefs.enhanced_verification_post, true);
+    if (evPost !== undefined)
+        prefs.enhanced_verification_post = evPost;
+    const evStrict = await promptBoolean(ctx, "Enhanced verification — strict mode (fail on any issue)", prefs.enhanced_verification_strict, false);
+    if (evStrict !== undefined)
+        prefs.enhanced_verification_strict = evStrict;
+    // safety_harness
+    const sh = prefs.safety_harness ?? {};
+    const shFields = [
+        { key: "enabled", label: "Safety harness enabled" },
+        { key: "evidence_collection", label: "Collect tool evidence" },
+        { key: "file_change_validation", label: "Validate file change descriptions" },
+        { key: "evidence_cross_reference", label: "Cross-reference evidence across tools" },
+        { key: "destructive_command_warnings", label: "Warn on destructive commands" },
+        { key: "content_validation", label: "Validate written content" },
+        { key: "checkpoints", label: "Create safety checkpoints" },
+        { key: "auto_rollback", label: "Auto-rollback on safety violation" },
+    ];
+    for (const field of shFields) {
+        const val = await promptBoolean(ctx, `Safety harness — ${field.label}`, sh[field.key]);
+        if (val !== undefined)
+            sh[field.key] = val;
+    }
+    const cap = await promptNumber(ctx, "Safety harness timeout scale cap", sh.timeout_scale_cap);
+    if (cap !== undefined && cap !== "clear")
+        sh.timeout_scale_cap = cap;
+    else if (cap === "clear")
+        delete sh.timeout_scale_cap;
+    if (Object.keys(sh).length > 0)
+        prefs.safety_harness = sh;
+    else if (prefs.safety_harness !== undefined)
+        delete prefs.safety_harness;
+}
+async function configureDiscuss(ctx, prefs) {
+    const prep = await promptBoolean(ctx, "Discuss — run preparation phase", prefs.discuss_preparation, true);
+    if (prep !== undefined)
+        prefs.discuss_preparation = prep;
+    const web = await promptBoolean(ctx, "Discuss — web research during preparation", prefs.discuss_web_research, true);
+    if (web !== undefined)
+        prefs.discuss_web_research = web;
+    const depth = await promptEnum(ctx, "Discuss preparation depth", prefs.discuss_depth, ["quick", "standard", "thorough"], "standard");
+    if (depth !== undefined)
+        prefs.discuss_depth = depth;
+}
+async function configureContextCodebase(ctx, prefs) {
+    const sel = await promptEnum(ctx, "Context selection mode", prefs.context_selection, ["full", "smart"]);
+    if (sel !== undefined)
+        prefs.context_selection = sel;
+    // context_management nested
+    const cm = prefs.context_management ?? {};
+    const mask = await promptBoolean(ctx, "Observation masking (hide stale tool outputs)", cm.observation_masking, true);
+    if (mask !== undefined)
+        cm.observation_masking = mask;
+    const maskTurns = await promptInteger(ctx, "Observation mask turns (1–50)", cm.observation_mask_turns, "8");
+    if (maskTurns !== undefined && maskTurns !== "clear")
+        cm.observation_mask_turns = maskTurns;
+    else if (maskTurns === "clear")
+        delete cm.observation_mask_turns;
+    const thresh = await promptNumber(ctx, "Compaction threshold percent (0.5–0.95)", cm.compaction_threshold_percent, "0.70");
+    if (thresh !== undefined && thresh !== "clear")
+        cm.compaction_threshold_percent = thresh;
+    else if (thresh === "clear")
+        delete cm.compaction_threshold_percent;
+    const toolMax = await promptInteger(ctx, "Tool result max chars (200–10000)", cm.tool_result_max_chars, "800");
+    if (toolMax !== undefined && toolMax !== "clear")
+        cm.tool_result_max_chars = toolMax;
+    else if (toolMax === "clear")
+        delete cm.tool_result_max_chars;
+    if (Object.keys(cm).length > 0)
+        prefs.context_management = cm;
+    else if (prefs.context_management !== undefined)
+        delete prefs.context_management;
+    const override = await promptInteger(ctx, "Context window override (tokens, blank = use model default)", prefs.context_window_override);
+    applyNumber(prefs, "context_window_override", override);
+    // codebase map
+    const cb = prefs.codebase ?? {};
+    const currentExcludes = Array.isArray(cb.exclude_patterns) ? cb.exclude_patterns : [];
+    const excludesInput = await ctx.ui.input(`Codebase map — extra exclude patterns (comma- or newline-separated, blank to keep)${currentExcludes.length ? ` (current: ${currentExcludes.join(", ")})` : ""}:`, currentExcludes.join(", "));
+    if (excludesInput !== null && excludesInput !== undefined) {
+        const parsed = parseStringList(excludesInput);
+        if (parsed.length > 0)
+            cb.exclude_patterns = parsed;
+        else if (currentExcludes.length > 0 && excludesInput.trim() === "")
+            delete cb.exclude_patterns;
+    }
+    const maxFiles = await promptInteger(ctx, "Codebase map — max files", cb.max_files, "500");
+    if (maxFiles !== undefined && maxFiles !== "clear")
+        cb.max_files = maxFiles;
+    else if (maxFiles === "clear")
+        delete cb.max_files;
+    const collapse = await promptInteger(ctx, "Codebase map — collapse threshold", cb.collapse_threshold, "20");
+    if (collapse !== undefined && collapse !== "clear")
+        cb.collapse_threshold = collapse;
+    else if (collapse === "clear")
+        delete cb.collapse_threshold;
+    if (Object.keys(cb).length > 0)
+        prefs.codebase = cb;
+    else if (prefs.codebase !== undefined)
+        delete prefs.codebase;
+}
+async function configureHooks(ctx, prefs) {
+    // reactive_execution
+    const re = prefs.reactive_execution ?? {};
+    const reEnabled = await promptBoolean(ctx, "Reactive (graph-parallel) task execution", re.enabled, false);
+    if (reEnabled !== undefined)
+        re.enabled = reEnabled;
+    const reMax = await promptInteger(ctx, "Reactive max parallel (1–8)", re.max_parallel, "3");
+    if (reMax !== undefined && reMax !== "clear")
+        re.max_parallel = Math.max(1, Math.min(8, reMax));
+    else if (reMax === "clear")
+        delete re.max_parallel;
+    const reModel = await promptString(ctx, "Reactive subagent model override", re.subagent_model);
+    if (reModel !== undefined) {
+        if (reModel)
+            re.subagent_model = reModel;
+        else
+            delete re.subagent_model;
+    }
+    if (Object.keys(re).length > 0) {
+        // isolation_mode is currently only "same-tree"; set it when enabled to satisfy the schema.
+        if (re.enabled === true && !re.isolation_mode)
+            re.isolation_mode = "same-tree";
+        prefs.reactive_execution = re;
+    }
+    else if (prefs.reactive_execution !== undefined) {
+        delete prefs.reactive_execution;
+    }
+    // gate_evaluation
+    const ge = prefs.gate_evaluation ?? {};
+    const geEnabled = await promptBoolean(ctx, "Parallel gate evaluation during planning", ge.enabled, false);
+    if (geEnabled !== undefined)
+        ge.enabled = geEnabled;
+    const currentSliceGates = Array.isArray(ge.slice_gates) ? ge.slice_gates : [];
+    const sgInput = await ctx.ui.input(`Slice gates to evaluate (comma-separated, blank keeps)${currentSliceGates.length ? ` (current: ${currentSliceGates.join(", ")})` : " (default: Q3,Q4)"}:`, currentSliceGates.join(", "));
+    if (sgInput !== null && sgInput !== undefined) {
+        const parsed = parseStringList(sgInput);
+        if (parsed.length > 0)
+            ge.slice_gates = parsed;
+        else if (currentSliceGates.length > 0 && sgInput.trim() === "")
+            delete ge.slice_gates;
+    }
+    const geTask = await promptBoolean(ctx, "Evaluate task-level gates (Q5/Q6/Q7)", ge.task_gates, true);
+    if (geTask !== undefined)
+        ge.task_gates = geTask;
+    if (Object.keys(ge).length > 0)
+        prefs.gate_evaluation = ge;
+    else if (prefs.gate_evaluation !== undefined)
+        delete prefs.gate_evaluation;
+    // post_unit_hooks[]
+    await configureHookList(ctx, prefs, "post_unit_hooks", "Post-unit hooks", "after");
+    // pre_dispatch_hooks[]
+    await configureHookList(ctx, prefs, "pre_dispatch_hooks", "Pre-dispatch hooks", "before");
+}
+async function configureHookList(ctx, prefs, key, label, triggerField) {
+    let hooks = Array.isArray(prefs[key]) ? [...prefs[key]] : [];
+    while (true) {
+        const summary = hooks.length === 0 ? "(none)" : `${hooks.length} hook(s)`;
+        const labels = hooks.map((h, i) => `#${i + 1} ${h.name ?? "(unnamed)"}${h.enabled === false ? " [disabled]" : ""}`);
+        const choice = await ctx.ui.select(`${label} — ${summary}`, [...labels, "Add hook", "Done"]);
+        const pick = typeof choice === "string" ? choice : "";
+        if (!pick || pick === "Done")
+            break;
+        if (pick === "Add hook") {
+            const nameInput = await ctx.ui.input("Hook name (unique identifier):", "");
+            const name = typeof nameInput === "string" ? nameInput.trim() : "";
+            if (!name)
+                continue;
+            const triggerInput = await ctx.ui.input(`Unit types this hook ${triggerField === "after" ? "runs after" : "intercepts before"} (comma-separated, e.g. execute-task):`, "");
+            const triggers = triggerInput ? parseStringList(triggerInput) : [];
+            if (triggers.length === 0) {
+                ctx.ui.notify("Hook discarded — trigger list cannot be empty.", "warning");
+                continue;
+            }
+            const hook = { name, [triggerField]: triggers, enabled: true };
+            if (key === "post_unit_hooks") {
+                const promptInput = await ctx.ui.input("Hook prompt (sent to LLM; supports {milestoneId}, {sliceId}, {taskId}):", "");
+                if (promptInput)
+                    hook.prompt = promptInput;
+            }
+            else {
+                const actionChoice = await ctx.ui.select("Action:", ["modify", "skip", "replace"]);
+                if (actionChoice)
+                    hook.action = actionChoice;
+            }
+            hooks.push(hook);
+        }
+        else if (pick.startsWith("#")) {
+            const idx = Number(pick.slice(1, pick.indexOf(" "))) - 1;
+            if (idx < 0 || idx >= hooks.length)
+                continue;
+            const editChoice = await ctx.ui.select(`Hook #${idx + 1}: ${hooks[idx].name ?? ""}`, ["Toggle enabled", "Edit prompt/action", "Edit model override", "Delete hook", "Cancel"]);
+            const ec = typeof editChoice === "string" ? editChoice : "";
+            if (!ec || ec === "Cancel")
+                continue;
+            if (ec === "Delete hook") {
+                hooks = hooks.filter((_, i) => i !== idx);
+            }
+            else if (ec === "Toggle enabled") {
+                hooks[idx].enabled = hooks[idx].enabled === false;
+            }
+            else if (ec === "Edit prompt/action") {
+                if (key === "post_unit_hooks") {
+                    const newPrompt = await promptString(ctx, "Prompt", hooks[idx].prompt);
+                    if (newPrompt !== undefined && newPrompt)
+                        hooks[idx].prompt = newPrompt;
+                }
+                else {
+                    const newAction = await promptEnum(ctx, "Action", hooks[idx].action, ["modify", "skip", "replace"]);
+                    if (newAction !== undefined)
+                        hooks[idx].action = newAction;
+                }
+            }
+            else if (ec === "Edit model override") {
+                const m = await promptString(ctx, "Model override (blank to clear)", hooks[idx].model);
+                if (m !== undefined) {
+                    if (m)
+                        hooks[idx].model = m;
+                    else
+                        delete hooks[idx].model;
+                }
+            }
+        }
+    }
+    if (hooks.length > 0)
+        prefs[key] = hooks;
+    else if (prefs[key] !== undefined)
+        delete prefs[key];
+}
+async function configureUoK(ctx, prefs) {
+    const uok = prefs.uok ?? {};
+    const enabled = await promptBoolean(ctx, "UoK (Unified Orchestration Kernel) enabled", uok.enabled);
+    if (enabled !== undefined)
+        uok.enabled = enabled;
+    const subsections = ["legacy_fallback", "gates", "model_policy", "execution_graph", "audit_unified", "plan_v2"];
+    for (const sub of subsections) {
+        const existing = uok[sub] ?? {};
+        const val = await promptBoolean(ctx, `UoK — ${sub.replace(/_/g, " ")} enabled`, existing.enabled);
+        if (val !== undefined) {
+            existing.enabled = val;
+            uok[sub] = existing;
+        }
+        else if (Object.keys(existing).length > 0) {
+            uok[sub] = existing;
+        }
+    }
+    // gitops has extra fields
+    const gitops = uok.gitops ?? {};
+    const gitopsEnabled = await promptBoolean(ctx, "UoK — gitops enabled", gitops.enabled);
+    if (gitopsEnabled !== undefined)
+        gitops.enabled = gitopsEnabled;
+    const turnAction = await promptEnum(ctx, "UoK gitops — turn action", gitops.turn_action, ["commit", "snapshot", "status-only"]);
+    if (turnAction !== undefined)
+        gitops.turn_action = turnAction;
+    const turnPush = await promptBoolean(ctx, "UoK gitops — turn push", gitops.turn_push);
+    if (turnPush !== undefined)
+        gitops.turn_push = turnPush;
+    if (Object.keys(gitops).length > 0)
+        uok.gitops = gitops;
+    if (Object.keys(uok).length > 0)
+        prefs.uok = uok;
+    else if (prefs.uok !== undefined)
+        delete prefs.uok;
+}
+async function configureIntegrations(ctx, prefs) {
+    // Language
+    const lang = await promptString(ctx, "Response language (e.g. Chinese, zh, German — blank to clear)", prefs.language);
+    if (lang !== undefined) {
+        if (lang)
+            prefs.language = lang;
+        else
+            delete prefs.language;
+    }
+    // Search provider
+    const search = await promptEnum(ctx, "Search provider", prefs.search_provider, ["auto", "brave", "tavily", "ollama", "native"], "auto");
+    if (search !== undefined)
+        prefs.search_provider = search;
+    // cmux
+    const cmux = prefs.cmux ?? {};
+    for (const field of ["enabled", "notifications", "sidebar", "splits", "browser"]) {
+        const val = await promptBoolean(ctx, `cmux — ${field}`, cmux[field]);
+        if (val !== undefined)
+            cmux[field] = val;
+    }
+    if (Object.keys(cmux).length > 0)
+        prefs.cmux = cmux;
+    else if (prefs.cmux !== undefined)
+        delete prefs.cmux;
+    // remote_questions
+    await configureRemoteQuestions(ctx, prefs);
+    // github sync
+    await configureGitHubSync(ctx, prefs);
+}
+async function configureRemoteQuestions(ctx, prefs) {
+    const existing = prefs.remote_questions ?? {};
+    const channel = await promptEnum(ctx, "Remote questions channel", existing.channel, ["slack", "discord", "telegram"]);
+    const channelId = await promptString(ctx, "Remote questions channel_id", existing.channel_id);
+    const timeout = await promptInteger(ctx, "Remote questions timeout (minutes, 1–30)", existing.timeout_minutes, "10");
+    const poll = await promptInteger(ctx, "Remote questions poll interval (seconds, 2–30)", existing.poll_interval_seconds, "5");
+    if (channel !== undefined)
+        existing.channel = channel;
+    if (channelId !== undefined) {
+        if (channelId)
+            existing.channel_id = channelId;
+        else
+            delete existing.channel_id;
+    }
+    applyNumber(existing, "timeout_minutes", timeout);
+    applyNumber(existing, "poll_interval_seconds", poll);
+    // Required pair: channel + channel_id. If either is missing, keep whatever existed unchanged.
+    if (existing.channel && existing.channel_id) {
+        prefs.remote_questions = existing;
+    }
+    else if (!existing.channel && !existing.channel_id) {
+        if (prefs.remote_questions !== undefined)
+            delete prefs.remote_questions;
+    }
+    else {
+        // Partial config — hold it so user can finish, but warn.
+        ctx.ui.notify("remote_questions requires both channel and channel_id; keeping partial config.", "warning");
+        prefs.remote_questions = existing;
+    }
+}
+async function configureGitHubSync(ctx, prefs) {
+    const gh = prefs.github ?? {};
+    const enabled = await promptBoolean(ctx, "GitHub sync enabled", gh.enabled, false);
+    if (enabled !== undefined)
+        gh.enabled = enabled;
+    const repo = await promptString(ctx, "GitHub repo (owner/repo, blank = auto-detect from git remote)", gh.repo);
+    if (repo !== undefined) {
+        if (repo)
+            gh.repo = repo;
+        else
+            delete gh.repo;
+    }
+    const project = await promptInteger(ctx, "GitHub Projects v2 number (blank = none)", gh.project);
+    if (project !== undefined && project !== "clear")
+        gh.project = project;
+    else if (project === "clear")
+        delete gh.project;
+    // labels
+    const currentLabels = Array.isArray(gh.labels) ? gh.labels : [];
+    const labelsInput = await ctx.ui.input(`GitHub default labels (comma-separated)${currentLabels.length ? ` (current: ${currentLabels.join(", ")})` : ""}:`, currentLabels.join(", "));
+    if (labelsInput !== null && labelsInput !== undefined) {
+        const parsed = parseStringList(labelsInput);
+        if (parsed.length > 0)
+            gh.labels = parsed;
+        else if (currentLabels.length > 0 && labelsInput.trim() === "")
+            delete gh.labels;
+    }
+    const autoLink = await promptBoolean(ctx, "GitHub — auto-link commits with Resolves #N", gh.auto_link_commits, true);
+    if (autoLink !== undefined)
+        gh.auto_link_commits = autoLink;
+    const slicePrs = await promptBoolean(ctx, "GitHub — create per-slice draft PRs", gh.slice_prs, true);
+    if (slicePrs !== undefined)
+        gh.slice_prs = slicePrs;
+    if (gh.enabled === true || Object.keys(gh).length > 1)
+        prefs.github = gh;
+    else if (prefs.github !== undefined && Object.keys(gh).length === 0)
+        delete prefs.github;
+    else if (Object.keys(gh).length > 0)
+        prefs.github = gh;
+}
 export async function configureMode(ctx, prefs) {
     const currentMode = prefs.mode;
     const modeChoice = await ctx.ui.select(`Workflow mode${currentMode ? ` (current: ${currentMode})` : ""}:`, [
@@ -576,11 +1466,32 @@ export async function configureMode(ctx, prefs) {
     }
 }
 async function configureAdvanced(ctx, prefs) {
-    const currentUnique = prefs.unique_milestone_ids;
-    const uniqueChoice = await ctx.ui.select(`Unique milestone IDs${currentUnique !== undefined ? ` (current: ${currentUnique})` : ""}:`, ["true", "false", "(keep current)"]);
-    if (uniqueChoice && uniqueChoice !== "(keep current)") {
-        prefs.unique_milestone_ids = uniqueChoice === "true";
-    }
+    const unique = await promptBoolean(ctx, "Unique milestone IDs", prefs.unique_milestone_ids);
+    if (unique !== undefined)
+        prefs.unique_milestone_ids = unique;
+    const autoViz = await promptBoolean(ctx, "Auto-visualize milestones (open HTML visualizer)", prefs.auto_visualize);
+    if (autoViz !== undefined)
+        prefs.auto_visualize = autoViz;
+    const autoReport = await promptBoolean(ctx, "Auto-generate milestone HTML report", prefs.auto_report, true);
+    if (autoReport !== undefined)
+        prefs.auto_report = autoReport;
+    const forensics = await promptBoolean(ctx, "Forensics dedup (search GitHub before filing)", prefs.forensics_dedup, false);
+    if (forensics !== undefined)
+        prefs.forensics_dedup = forensics;
+    const tokenCost = await promptBoolean(ctx, "Show token cost in footer", prefs.show_token_cost, false);
+    if (tokenCost !== undefined)
+        prefs.show_token_cost = tokenCost;
+    const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, ["full", "small", "min", "off"], "full");
+    if (widget !== undefined)
+        prefs.widget_mode = widget;
+    const experimental = prefs.experimental ?? {};
+    const rtk = await promptBoolean(ctx, "Experimental: RTK shell-command compression", experimental.rtk, false);
+    if (rtk !== undefined)
+        experimental.rtk = rtk;
+    if (Object.keys(experimental).length > 0)
+        prefs.experimental = experimental;
+    else if (prefs.experimental !== undefined)
+        delete prefs.experimental;
 }
 // ─── Main wizard with category menu ─────────────────────────────────────────
 export async function handlePrefsWizard(ctx, scope, prefill, opts) {
@@ -608,6 +1519,14 @@ export async function handlePrefsWizard(ctx, scope, prefill, opts) {
             `Skills          ${summaries.skills}`,
             `Budget          ${summaries.budget}`,
             `Notifications   ${summaries.notifications}`,
+            `Phases          ${summaries.phases}`,
+            `Parallelism     ${summaries.parallelism}`,
+            `Verification    ${summaries.verification}`,
+            `Discuss         ${summaries.discuss}`,
+            `Context         ${summaries.context}`,
+            `Hooks           ${summaries.hooks}`,
+            `UoK             ${summaries.uok}`,
+            `Integrations    ${summaries.integrations}`,
             `Advanced        ${summaries.advanced}`,
             `── Save & Exit ──`,
         ];
@@ -629,6 +1548,22 @@ export async function handlePrefsWizard(ctx, scope, prefill, opts) {
             await configureBudget(ctx, prefs);
         else if (choice.startsWith("Notifications"))
             await configureNotifications(ctx, prefs);
+        else if (choice.startsWith("Phases"))
+            await configurePhases(ctx, prefs);
+        else if (choice.startsWith("Parallelism"))
+            await configureParallelism(ctx, prefs);
+        else if (choice.startsWith("Verification"))
+            await configureVerification(ctx, prefs);
+        else if (choice.startsWith("Discuss"))
+            await configureDiscuss(ctx, prefs);
+        else if (choice.startsWith("Context"))
+            await configureContextCodebase(ctx, prefs);
+        else if (choice.startsWith("Hooks"))
+            await configureHooks(ctx, prefs);
+        else if (choice.startsWith("UoK"))
+            await configureUoK(ctx, prefs);
+        else if (choice.startsWith("Integrations"))
+            await configureIntegrations(ctx, prefs);
         else if (choice.startsWith("Advanced"))
             await configureAdvanced(ctx, prefs);
     }
@@ -732,11 +1667,21 @@ export function serializePreferencesToFrontmatter(prefs) {
         "skill_staleness_days", "auto_supervisor", "uat_dispatch", "unique_milestone_ids",
         "budget_ceiling", "budget_enforcement", "context_pause_threshold",
         "notifications", "cmux", "remote_questions", "git",
+        "stale_commit_threshold_minutes",
         "post_unit_hooks", "pre_dispatch_hooks",
-        "dynamic_routing", "uok", "token_profile", "phases", "parallel",
+        "dynamic_routing", "uok", "token_profile", "service_tier", "flat_rate_providers",
+        "phases", "parallel", "slice_parallel",
+        "reactive_execution", "gate_evaluation",
         "auto_visualize", "auto_report",
         "verification_commands", "verification_auto_fix", "verification_max_retries",
-        "search_provider", "context_selection", "language",
+        "enhanced_verification", "enhanced_verification_pre",
+        "enhanced_verification_post", "enhanced_verification_strict",
+        "safety_harness",
+        "discuss_preparation", "discuss_web_research", "discuss_depth",
+        "search_provider", "context_selection", "context_management", "context_window_override",
+        "codebase", "widget_mode", "forensics_dedup", "show_token_cost",
+        "github", "experimental",
+        "language",
     ];
     const seen = new Set();
     for (const key of orderedKeys) {