flanders 0.8.0 → 0.10.0

package/lib/commands/Install.js

@@ -6,6 +6,8 @@ const FlandersConfig_1 = require("../workspace/FlandersConfig");
 const PromptHelper_1 = require("../ui/PromptHelper");
 const skillArtifacts_1 = require("./skillArtifacts");
 const InstallModelProbe_1 = require("./InstallModelProbe");
+const toolNames_1 = require("../toolNames");
+const fastMode_1 = require("../fastMode");
 async function promptChoice(ask, args) {
     try {
         return await (0, PromptHelper_1.askChoice)(ask, args);
@@ -28,6 +30,17 @@ async function promptText(ask, args) {
         throw e;
     }
 }
+async function promptMultiChoice(ask, args) {
+    try {
+        return await (0, PromptHelper_1.askMultiChoice)(ask, args);
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+            return null;
+        }
+        throw e;
+    }
+}
 function extractFlagValue(rawArgs, flag) {
     const prefix = flag + "=";
     for (const arg of rawArgs) {
@@ -44,10 +57,43 @@ function validateClosedSet(value, allowed, flagName) {
     return `Invalid value for ${flagName}: "${value}". Allowed values: ${allowed.join(", ")}.\n`;
 }
 const CODEX_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
+function validateEffortForTool(value, tool, flagName) {
+    if (value === "") {
+        return null;
+    }
+    if (tool === "codex") {
+        return validateClosedSet(value, CODEX_EFFORT_LEVELS, flagName);
+    }
+    return null;
+}
+function parseSkillsToolList(value) {
+    const invalid = {
+        ok: false,
+        diagnostic: `Invalid value for --skills-tool: "${value}". Expected a comma-separated list of distinct names from: ${toolNames_1.TOOL_NAMES.join(", ")}.\n`
+    };
+    const seen = new Set();
+    const tools = [];
+    for (const part of value.split(",")) {
+        if (!toolNames_1.TOOL_NAMES.includes(part) || seen.has(part)) {
+            return invalid;
+        }
+        seen.add(part);
+        tools.push(part);
+    }
+    return { ok: true, tools };
+}
+const TOOL_CHOICE_OPTIONS = [
+    { label: "claude", description: "Use Claude Code" },
+    { label: "codex", description: "Use Codex CLI" }
+];
+const SKILLS_TOOL_DESTINATIONS = {
+    claude: { project: ".claude/skills/", global: "~/.claude/skills/" },
+    codex: { project: ".codex/prompts/", global: "~/.codex/prompts/" }
+};
 const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 const CLAUDE_MODEL_FAMILIES = [
     {
-        family: "Opus",
+        name: "Opus",
         entries: [
             { label: "Latest Opus", value: "opus" },
             { label: "Latest Opus [1m context]", value: "opus[1m]" },
@@ -60,10 +106,11 @@ const CLAUDE_MODEL_FAMILIES = [
         ]
     },
     {
-        family: "Sonnet",
+        name: "Sonnet",
         entries: [
             { label: "Latest Sonnet", value: "sonnet" },
             { label: "Latest Sonnet [1m context]", value: "sonnet[1m]" },
+            { label: "Sonnet 5", value: "claude-sonnet-5" },
             { label: "Sonnet 4.6", value: "claude-sonnet-4-6" },
             { label: "Sonnet 4.6 [1m context]", value: "claude-sonnet-4-6[1m]" },
             { label: "Sonnet 4.5", value: "claude-sonnet-4-5" },
@@ -71,14 +118,14 @@ const CLAUDE_MODEL_FAMILIES = [
         ]
     },
     {
-        family: "Haiku",
+        name: "Haiku",
         entries: [
             { label: "Latest Haiku", value: "haiku" },
             { label: "Haiku 4.5", value: "claude-haiku-4-5-20251001" }
         ]
     },
     {
-        family: "Fable",
+        name: "Fable",
         entries: [
             { label: "Latest Fable", value: "fable" },
             { label: "Fable 5", value: "claude-fable-5" }
@@ -88,9 +135,38 @@ const CLAUDE_MODEL_FAMILIES = [
 const CLAUDE_CROSS_FAMILY_ALIASES = [
     { label: "Best (auto-pick)", value: "best" }
 ];
-const CLAUDE_BACK_LABEL = "← back";
+const MODEL_BACK_LABEL = "← back";
 const REVIEWER_INDEXED_RE = /^--reviewer-(\d+)-(tool|model|effort)=/;
 const REVIEWER_OPTIONAL_INDEXED_RE = /^--reviewer-(\d+)-optional$/;
+const REVIEWER_FAST_INDEXED_RE = /^--reviewer-(\d+)-fast$/;
+function validateFastFlagsForReviewerCount(fastReviewerIndices, reviewerCount) {
+    if (fastReviewerIndices !== undefined) {
+        for (const idx of fastReviewerIndices) {
+            if (idx > reviewerCount) {
+                return `Invalid reviewer flag: --reviewer-${idx}-fast references reviewer ${idx}, beyond the configured reviewer list of ${reviewerCount}.\n`;
+            }
+        }
+    }
+    return null;
+}
+function fastFlagEligibilityError(tool, model, flagName) {
+    const reason = tool === "claude"
+        ? `the model "${model}" does not support Claude Code fast mode`
+        : `the ${tool} tool has no fast mode`;
+    return `Invalid flag ${flagName}: ${reason}.\n`;
+}
+function knownFastFlagError(tool, model, flagName) {
+    if (tool === undefined) {
+        return null;
+    }
+    if (tool !== "claude") {
+        return fastFlagEligibilityError(tool, "", flagName);
+    }
+    if (model === undefined) {
+        return null;
+    }
+    return (0, fastMode_1.modelSupportsFastMode)(model) ? null : fastFlagEligibilityError(tool, model, flagName);
+}
 function validateWeightedFlagsForReviewerCount(reviewerMinimum, optionalReviewerIndices, reviewerCount) {
     if (reviewerCount === 1) {
         if (reviewerMinimum !== undefined) {
@@ -132,14 +208,14 @@ function parseInstallFlags(rawArgs) {
         answers.scope = "global";
     const skillsTool = extractFlagValue(rawArgs, "--skills-tool");
     if (skillsTool !== undefined) {
-        const error = validateClosedSet(skillsTool, ["claude", "codex", "both"], "--skills-tool");
-        if (error)
-            return { ok: false, diagnostic: error };
-        answers.skillsTool = skillsTool;
+        const result = parseSkillsToolList(skillsTool);
+        if (!result.ok)
+            return { ok: false, diagnostic: result.diagnostic };
+        answers.skillsTools = result.tools;
     }
     const workerTool = extractFlagValue(rawArgs, "--worker-tool");
     if (workerTool !== undefined) {
-        const error = validateClosedSet(workerTool, ["claude", "codex"], "--worker-tool");
+        const error = validateClosedSet(workerTool, toolNames_1.TOOL_NAMES, "--worker-tool");
         if (error)
             return { ok: false, diagnostic: error };
         answers.workerTool = workerTool;
@@ -150,11 +226,9 @@ function parseInstallFlags(rawArgs) {
     }
     const workerEffort = extractFlagValue(rawArgs, "--worker-effort");
     if (workerEffort !== undefined) {
-        if (workerEffort !== "" && answers.workerTool === "codex") {
-            const error = validateClosedSet(workerEffort, CODEX_EFFORT_LEVELS, "--worker-effort");
-            if (error)
-                return { ok: false, diagnostic: error };
-        }
+        const error = validateEffortForTool(workerEffort, answers.workerTool, "--worker-effort");
+        if (error)
+            return { ok: false, diagnostic: error };
         answers.workerEffort = workerEffort;
     }
     const reviewerIndices = new Map();
@@ -162,7 +236,7 @@ function parseInstallFlags(rawArgs) {
     const reviewer1Model = extractFlagValue(rawArgs, "--reviewer-model");
     const reviewer1Effort = extractFlagValue(rawArgs, "--reviewer-effort");
     if (reviewer1Tool !== undefined) {
-        const error = validateClosedSet(reviewer1Tool, ["claude", "codex"], "--reviewer-tool");
+        const error = validateClosedSet(reviewer1Tool, toolNames_1.TOOL_NAMES, "--reviewer-tool");
         if (error)
             return { ok: false, diagnostic: error };
         if (!reviewerIndices.has(1))
@@ -176,11 +250,9 @@ function parseInstallFlags(rawArgs) {
     }
     if (reviewer1Effort !== undefined) {
         const tool1 = (_a = reviewerIndices.get(1)) === null || _a === void 0 ? void 0 : _a.tool;
-        if (reviewer1Effort !== "" && tool1 === "codex") {
-            const error = validateClosedSet(reviewer1Effort, CODEX_EFFORT_LEVELS, "--reviewer-effort");
-            if (error)
-                return { ok: false, diagnostic: error };
-        }
+        const error = validateEffortForTool(reviewer1Effort, tool1, "--reviewer-effort");
+        if (error)
+            return { ok: false, diagnostic: error };
         if (!reviewerIndices.has(1))
             reviewerIndices.set(1, {});
         reviewerIndices.get(1).effort = reviewer1Effort;
@@ -199,7 +271,7 @@ function parseInstallFlags(rawArgs) {
             reviewerIndices.set(idx, {});
         const entry = reviewerIndices.get(idx);
         if (field === "tool") {
-            const error = validateClosedSet(value, ["claude", "codex"], `--reviewer-${idx}-tool`);
+            const error = validateClosedSet(value, toolNames_1.TOOL_NAMES, `--reviewer-${idx}-tool`);
             if (error)
                 return { ok: false, diagnostic: error };
             entry.tool = value;
@@ -212,8 +284,8 @@ function parseInstallFlags(rawArgs) {
         }
     }
     for (const [idx, entry] of reviewerIndices) {
-        if (entry.effort !== undefined && entry.effort !== "" && entry.tool === "codex") {
-            const error = validateClosedSet(entry.effort, CODEX_EFFORT_LEVELS, `--reviewer-${idx}-effort`);
+        if (entry.effort !== undefined) {
+            const error = validateEffortForTool(entry.effort, entry.tool, `--reviewer-${idx}-effort`);
             if (error)
                 return { ok: false, diagnostic: error };
         }
@@ -243,14 +315,40 @@ function parseInstallFlags(rawArgs) {
             continue;
         }
         const idx = Number(match[1]);
-        if (idx < 1) {
-            return { ok: false, diagnostic: `Invalid reviewer flag: "${arg}". --reviewer-N-optional requires N >= 1.\n` };
+        if (idx < 2) {
+            return { ok: false, diagnostic: `Invalid reviewer flag: "${arg}". Reviewer 1 uses --reviewer-optional; --reviewer-N-optional requires N >= 2.\n` };
         }
         optionalIndices.add(idx);
     }
     if (optionalIndices.size > 0) {
         answers.optionalReviewerIndices = [...optionalIndices].sort((a, b) => a - b);
     }
+    if (rawArgs.includes("--worker-fast")) {
+        answers.workerFast = true;
+        const workerFastError = knownFastFlagError(answers.workerTool, answers.workerModel, "--worker-fast");
+        if (workerFastError !== null) {
+            return { ok: false, diagnostic: workerFastError };
+        }
+    }
+    const fastIndices = new Set();
+    for (const arg of rawArgs) {
+        if (arg === "--reviewer-fast") {
+            fastIndices.add(1);
+            continue;
+        }
+        const match = arg.match(REVIEWER_FAST_INDEXED_RE);
+        if (match === null) {
+            continue;
+        }
+        const idx = Number(match[1]);
+        if (idx < 2) {
+            return { ok: false, diagnostic: `Invalid reviewer flag: "${arg}". Reviewer 1 uses --reviewer-fast; --reviewer-N-fast requires N >= 2.\n` };
+        }
+        fastIndices.add(idx);
+    }
+    if (fastIndices.size > 0) {
+        answers.fastReviewerIndices = [...fastIndices].sort((a, b) => a - b);
+    }
     const minimumRaw = extractFlagValue(rawArgs, "--reviewer-minimum");
     if (minimumRaw !== undefined) {
         if (!/^\d+$/.test(minimumRaw)) {
@@ -263,6 +361,20 @@ function parseInstallFlags(rawArgs) {
         if (diagnostic !== null) {
             return { ok: false, diagnostic };
         }
+        const fastDiagnostic = validateFastFlagsForReviewerCount(answers.fastReviewerIndices, answers.reviewers.length);
+        if (fastDiagnostic !== null) {
+            return { ok: false, diagnostic: fastDiagnostic };
+        }
+        if (answers.fastReviewerIndices !== undefined) {
+            for (const idx of answers.fastReviewerIndices) {
+                const supplied = answers.reviewers[idx - 1];
+                const flagName = idx === 1 ? "--reviewer-fast" : `--reviewer-${idx}-fast`;
+                const reviewerFastError = knownFastFlagError(supplied.tool, supplied.model, flagName);
+                if (reviewerFastError !== null) {
+                    return { ok: false, diagnostic: reviewerFastError };
+                }
+            }
+        }
     }
     return { ok: true, answers };
 }
@@ -325,27 +437,27 @@ class Install {
         }
         return option.label;
     }
-    async _resolveClaudeModel(roleLabel, headerLabel, contexts, preselect) {
+    async _resolveGroupedModel(roleLabel, headerLabel, groups, crossAliases, contexts, preselect) {
         const question = `Which model should ${roleLabel} use?`;
         let topDefault;
         let customDefault;
-        let preselectedFamily;
+        let preselectedGroup;
         let preselectedEntryLabel;
         if (preselect !== undefined) {
             if (preselect === "") {
                 topDefault = "default configured model";
             }
             else {
-                const alias = CLAUDE_CROSS_FAMILY_ALIASES.find(a => a.value === preselect);
+                const alias = crossAliases.find(a => a.value === preselect);
                 if (alias) {
                     topDefault = alias.label;
                 }
                 else {
-                    const family = CLAUDE_MODEL_FAMILIES.find(f => f.entries.some(e => e.value === preselect));
-                    if (family) {
-                        topDefault = family.family;
-                        preselectedFamily = family;
-                        preselectedEntryLabel = family.entries.find(e => e.value === preselect).label;
+                    const group = groups.find(g => g.entries.some(e => e.value === preselect));
+                    if (group) {
+                        topDefault = group.name;
+                        preselectedGroup = group;
+                        preselectedEntryLabel = group.entries.find(e => e.value === preselect).label;
                     }
                     else {
                         topDefault = "enter a custom value…";
@@ -356,8 +468,8 @@ class Install {
         }
         topLevel: for (;;) {
             const topOptions = [
-                ...CLAUDE_MODEL_FAMILIES.map(family => ({ label: family.family })),
-                ...CLAUDE_CROSS_FAMILY_ALIASES.map(alias => ({ label: alias.label })),
+                ...groups.map(group => ({ label: group.name })),
+                ...crossAliases.map(alias => ({ label: alias.label })),
                 { label: "default configured model" },
                 { label: "enter a custom value…" }
             ];
@@ -390,19 +502,19 @@ class Install {
                 }
                 return text;
             }
-            const crossFamily = CLAUDE_CROSS_FAMILY_ALIASES.find(alias => alias.label === top.label);
-            if (crossFamily) {
-                return crossFamily.value;
+            const crossAlias = crossAliases.find(alias => alias.label === top.label);
+            if (crossAlias) {
+                return crossAlias.value;
             }
-            const family = CLAUDE_MODEL_FAMILIES.find(f => f.family === top.label);
+            const group = groups.find(g => g.name === top.label);
             for (;;) {
-                const familyOptions = family.entries.map(entry => ({ label: entry.label }));
-                familyOptions.push({ label: CLAUDE_BACK_LABEL });
+                const groupOptions = group.entries.map(entry => ({ label: entry.label }));
+                groupOptions.push({ label: MODEL_BACK_LABEL });
                 const choice = await promptChoice(contexts.ask, {
                     header: headerLabel,
-                    question: `Which ${family.family} model should ${roleLabel} use?`,
-                    options: familyOptions,
-                    defaultLabel: family === preselectedFamily ? preselectedEntryLabel : undefined
+                    question: `Which ${group.name} model should ${roleLabel} use?`,
+                    options: groupOptions,
+                    defaultLabel: group === preselectedGroup ? preselectedEntryLabel : undefined
                 });
                 if (!choice) {
                     return null;
@@ -410,14 +522,28 @@ class Install {
                 if (this._disposed) {
                     return null;
                 }
-                if (choice.label === CLAUDE_BACK_LABEL) {
+                if (choice.label === MODEL_BACK_LABEL) {
                     continue topLevel;
                 }
-                const entry = family.entries.find(e => e.label === choice.label);
+                const entry = group.entries.find(e => e.label === choice.label);
                 return entry.value;
             }
         }
     }
+    async _resolveFreeTextModel(roleLabel, contexts, preselect) {
+        const text = await promptText(contexts.ask, {
+            question: `Which model should ${roleLabel} use?`,
+            placeholder: "leave empty for the default configured model",
+            default: preselect
+        });
+        if (text === null) {
+            return null;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        return text;
+    }
     async _resolveRoleModel(roleLabel, headerLabel, tool, suppliedModel, contexts, preselect) {
         if (suppliedModel !== undefined) {
             return suppliedModel;
@@ -426,7 +552,7 @@ class Install {
             return null;
         }
         if (tool === "claude") {
-            return await this._resolveClaudeModel(roleLabel, headerLabel, contexts, preselect);
+            return await this._resolveGroupedModel(roleLabel, headerLabel, CLAUDE_MODEL_FAMILIES, CLAUDE_CROSS_FAMILY_ALIASES, contexts, preselect);
         }
         if (!this._modelProbeCache.has(tool)) {
             const result = await (0, InstallModelProbe_1.probeModelList)(contexts.script);
@@ -465,18 +591,7 @@ class Install {
             }
             return option.label === "default configured model" ? "" : option.label;
         }
-        const text = await promptText(contexts.ask, {
-            question: `Which model should ${roleLabel} use?`,
-            placeholder: "leave empty for the default configured model",
-            default: preselect
-        });
-        if (text === null) {
-            return null;
-        }
-        if (this._disposed) {
-            return null;
-        }
-        return text;
+        return await this._resolveFreeTextModel(roleLabel, contexts, preselect);
     }
     async _resolveRoleEffort(roleLabel, headerLabel, tool, suppliedEffort, contexts, preselect) {
         if (suppliedEffort !== undefined) {
@@ -508,7 +623,36 @@ class Install {
         }
         return await this._resolveCuratedChoice(headerLabel, `What effort level should ${roleLabel} use?`, CLAUDE_EFFORT_LEVELS, "default configured effort", "enter a custom value…", "leave empty for the default configured effort", contexts, preselect);
     }
-    async _resolveReviewer(idx, supplied, contexts, storedReviewer) {
+    async _resolveRoleFast(roleLabel, headerLabel, tool, model, fastFlag, flagName, contexts, storedFast) {
+        const eligible = tool === "claude" && (0, fastMode_1.modelSupportsFastMode)(model);
+        if (fastFlag) {
+            if (!eligible) {
+                contexts.output.writeError(fastFlagEligibilityError(tool, model, flagName));
+                return null;
+            }
+            return true;
+        }
+        if (!eligible) {
+            return false;
+        }
+        const option = await promptChoice(contexts.ask, {
+            header: headerLabel,
+            question: `Should ${roleLabel} run with Claude Code's fast mode enabled, neighbor?`,
+            options: [
+                { label: "no", description: "Standard mode — fast mode off" },
+                { label: "yes", description: "Fast mode — Claude Code's higher-speed, higher-cost configuration" }
+            ],
+            defaultLabel: storedFast === true ? "yes" : "no"
+        });
+        if (!option) {
+            return null;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        return option.label === "yes";
+    }
+    async _resolveReviewer(idx, supplied, fastFlag, contexts, storedReviewer) {
         const ordinal = idx === 1 ? "" : ` ${idx}`;
         const roleLabel = `reviewer${ordinal}`;
         let tool;
@@ -522,10 +666,7 @@ class Install {
             const option = await promptChoice(contexts.ask, {
                 header: `Reviewer${ordinal} tool`,
                 question: `Which AI tool should ${roleLabel} use?`,
-                options: [
-                    { label: "claude", description: "Use Claude Code" },
-                    { label: "codex", description: "Use Codex CLI" }
-                ],
+                options: TOOL_CHOICE_OPTIONS,
                 defaultLabel: storedReviewer === null || storedReviewer === void 0 ? void 0 : storedReviewer.tool
             });
             if (!option) {
@@ -536,6 +677,13 @@ class Install {
             }
             tool = option.label;
         }
+        if ((supplied === null || supplied === void 0 ? void 0 : supplied.effort) !== undefined) {
+            const effortError = validateEffortForTool(supplied.effort, tool, idx === 1 ? "--reviewer-effort" : `--reviewer-${idx}-effort`);
+            if (effortError !== null) {
+                contexts.output.writeError(effortError);
+                return null;
+            }
+        }
         const model = await this._resolveRoleModel(roleLabel, `Reviewer${ordinal} model`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.model, contexts, storedReviewer === null || storedReviewer === void 0 ? void 0 : storedReviewer.model);
         if (model === null) {
             return null;
@@ -544,10 +692,14 @@ class Install {
         if (effort === null) {
             return null;
         }
-        return { tool, model, effort };
+        const fast = await this._resolveRoleFast(roleLabel, `Reviewer${ordinal} fast`, tool, model, fastFlag, idx === 1 ? "--reviewer-fast" : `--reviewer-${idx}-fast`, contexts, storedReviewer === null || storedReviewer === void 0 ? void 0 : storedReviewer.fast);
+        if (fast === null) {
+            return null;
+        }
+        return { tool, model, effort, fast };
     }
     async _run(rawArgs, options, contexts) {
-        var _a;
+        var _a, _b;
         try {
             const parsed = parseInstallFlags(rawArgs);
             if (!parsed.ok) {
@@ -555,30 +707,29 @@ class Install {
                 return 1;
             }
             const answers = parsed.answers;
-            let skillsTool;
-            if (answers.skillsTool !== undefined) {
-                skillsTool = answers.skillsTool;
+            let skillsTools;
+            if (answers.skillsTools !== undefined) {
+                skillsTools = answers.skillsTools;
             }
             else {
                 if (this._disposed) {
                     return 1;
                 }
-                const option = await promptChoice(contexts.ask, {
+                const picked = await promptMultiChoice(contexts.ask, {
                     header: "Skills tool",
                     question: "Which AI tool(s) should the skills be installed for, neighbor?",
                     options: [
                         { label: "claude", description: "Install skills for Claude Code" },
-                        { label: "codex", description: "Install skills for Codex CLI" },
-                        { label: "both", description: "Install skills for both Claude Code and Codex CLI" }
+                        { label: "codex", description: "Install skills for Codex CLI" }
                     ]
                 });
-                if (!option) {
+                if (!picked) {
                     return 1;
                 }
                 if (this._disposed) {
                     return 1;
                 }
-                skillsTool = option.label;
+                skillsTools = picked.map(o => o.label);
             }
             let mode;
             if (answers.scope) {
@@ -588,20 +739,8 @@ class Install {
                 if (this._disposed) {
                     return 1;
                 }
-                let projectDescription;
-                let globalDescription;
-                if (skillsTool === "claude") {
-                    projectDescription = "Install in .claude/skills/ relative to CWD";
-                    globalDescription = "Install in ~/.claude/skills/";
-                }
-                else if (skillsTool === "codex") {
-                    projectDescription = "Install in .codex/prompts/ relative to CWD";
-                    globalDescription = "Install in ~/.codex/prompts/";
-                }
-                else {
-                    projectDescription = "Install in .claude/skills/ and .codex/prompts/ relative to CWD";
-                    globalDescription = "Install in ~/.claude/skills/ and ~/.codex/prompts/";
-                }
+                const projectDescription = `Install in ${skillsTools.map(t => SKILLS_TOOL_DESTINATIONS[t].project).join(" and ")} relative to CWD`;
+                const globalDescription = `Install in ${skillsTools.map(t => SKILLS_TOOL_DESTINATIONS[t].global).join(" and ")}`;
                 const option = await promptChoice(contexts.ask, {
                     header: "Install destination",
                     question: "Where should Flanders skills be installed?",
@@ -637,10 +776,7 @@ class Install {
                 const option = await promptChoice(contexts.ask, {
                     header: "Worker tool, neighborino",
                     question: "Which AI tool should the worker use?",
-                    options: [
-                        { label: "claude", description: "Use Claude Code" },
-                        { label: "codex", description: "Use Codex CLI" }
-                    ],
+                    options: TOOL_CHOICE_OPTIONS,
                     defaultLabel: storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.worker.tool
                 });
                 if (!option) {
@@ -651,6 +787,13 @@ class Install {
                 }
                 workerTool = option.label;
             }
+            if (answers.workerEffort !== undefined) {
+                const effortError = validateEffortForTool(answers.workerEffort, workerTool, "--worker-effort");
+                if (effortError !== null) {
+                    contexts.output.writeError(effortError);
+                    return 1;
+                }
+            }
             const workerModel = await this._resolveRoleModel("the worker", "Worker model", workerTool, answers.workerModel, contexts, storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.worker.model);
             if (workerModel === null) {
                 return 1;
@@ -659,12 +802,17 @@ class Install {
             if (workerEffort === null) {
                 return 1;
             }
+            const workerFast = await this._resolveRoleFast("the worker", "Worker fast", workerTool, workerModel, answers.workerFast === true, "--worker-fast", contexts, storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.worker.fast);
+            if (workerFast === null) {
+                return 1;
+            }
             const suppliedReviewers = answers.reviewers;
+            const fastReviewerSet = new Set((_a = answers.fastReviewerIndices) !== null && _a !== void 0 ? _a : []);
             const storedReviewers = storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.reviewers;
             const reviewers = [];
             if (suppliedReviewers && suppliedReviewers.length > 0) {
                 for (let i = 0; i < suppliedReviewers.length; i++) {
-                    const reviewer = await this._resolveReviewer(i + 1, suppliedReviewers[i], contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[i]);
+                    const reviewer = await this._resolveReviewer(i + 1, suppliedReviewers[i], fastReviewerSet.has(i + 1), contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[i]);
                     if (reviewer === null) {
                         return 1;
                     }
@@ -674,7 +822,7 @@ class Install {
             else {
                 let idx = 1;
                 for (;;) {
-                    const reviewer = await this._resolveReviewer(idx, undefined, contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[idx - 1]);
+                    const reviewer = await this._resolveReviewer(idx, undefined, fastReviewerSet.has(idx), contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[idx - 1]);
                     if (reviewer === null) {
                         return 1;
                     }
@@ -712,6 +860,11 @@ class Install {
                     contexts.output.writeError(diagnostic);
                     return 1;
                 }
+                const fastDiagnostic = validateFastFlagsForReviewerCount(answers.fastReviewerIndices, reviewers.length);
+                if (fastDiagnostic !== null) {
+                    contexts.output.writeError(fastDiagnostic);
+                    return 1;
+                }
             }
             let minimumReviews;
             const reviewerConfigs = [];
@@ -770,7 +923,7 @@ class Install {
                             const reviewer = reviewers[i];
                             const modelLabel = reviewer.model === "" ? "default configured model" : reviewer.model;
                             const effortLabel = reviewer.effort === "" ? "default configured effort" : reviewer.effort;
-                            const optionalDefault = ((_a = storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[i]) === null || _a === void 0 ? void 0 : _a.optional) === true ? "yes" : "no";
+                            const optionalDefault = ((_b = storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[i]) === null || _b === void 0 ? void 0 : _b.optional) === true ? "yes" : "no";
                             const optionalOption = await promptChoice(contexts.ask, {
                                 header: `Reviewer ${i + 1} optional`,
                                 question: `Is reviewer ${i + 1} (${reviewer.tool} · ${modelLabel} · ${effortLabel}) optional?`,
@@ -800,14 +953,7 @@ class Install {
                 ? contexts.platform.homedir()
                 : options.projectRoot;
             const writtenPaths = [];
-            const tools = [];
-            if (skillsTool === "claude" || skillsTool === "both") {
-                tools.push("claude");
-            }
-            if (skillsTool === "codex" || skillsTool === "both") {
-                tools.push("codex");
-            }
-            for (const tool of tools) {
+            for (const tool of skillsTools) {
                 const result = await (0, skillArtifacts_1.writeSkillArtifacts)(contexts.fs, scopeRoot, tool, () => this._disposed);
                 if (!result.ok) {
                     if (result.diagnostic !== null) {
@@ -821,7 +967,7 @@ class Install {
                 return 1;
             }
             const config = {
-                worker: { tool: workerTool, model: workerModel, effort: workerEffort },
+                worker: { tool: workerTool, model: workerModel, effort: workerEffort, fast: workerFast },
                 reviewers: reviewerConfigs,
                 minimumReviews
             };