flanders 0.1.0 → 0.3.0

package/lib/commands/Install.js

@@ -1,82 +1,673 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Install = void 0;
-const fsUtils_1 = require("../fsUtils");
-const skills_1 = require("../skills");
+exports.stripYamlFrontmatter = stripYamlFrontmatter;
+exports.parseInstallFlags = parseInstallFlags;
+const FlandersConfig_1 = require("../workspace/FlandersConfig");
+const PromptHelper_1 = require("../ui/PromptHelper");
+const fsUtils_1 = require("../system/fsUtils");
+const skills_1 = require("../prompts/skills");
+const InstallModelProbe_1 = require("./InstallModelProbe");
 const SKILLS = [
-    { name: "flanders-contract", folder: "flanders-contract", body: skills_1.contractSkillBody },
-    { name: "flanders-plan", folder: "flanders-plan", body: skills_1.planSkillBody },
-    { name: "flanders-rule", folder: "flanders-rule", body: skills_1.ruleSkillBody }
+    { name: "flanders-spec", body: skills_1.specSkillBody },
+    { name: "flanders-plan", body: skills_1.planSkillBody },
+    { name: "flanders-work", body: skills_1.workSkillBody }
 ];
+function stripYamlFrontmatter(body) {
+    if (!body.startsWith("---\n") && !body.startsWith("---\r\n")) {
+        return body;
+    }
+    const newlineAfterOpener = body.indexOf("\n") + 1;
+    const closerIndex = body.indexOf("\n---\n", newlineAfterOpener);
+    if (closerIndex === -1) {
+        const closerCrlf = body.indexOf("\n---\r\n", newlineAfterOpener);
+        if (closerCrlf === -1) {
+            return body;
+        }
+        return body.slice(closerCrlf + "\n---\r\n".length);
+    }
+    return body.slice(closerIndex + "\n---\n".length);
+}
+async function promptChoice(ask, args) {
+    try {
+        return await (0, PromptHelper_1.askChoice)(ask, args);
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === "AbortError") {
+            return null;
+        }
+        throw e;
+    }
+}
+async function promptText(ask, args) {
+    try {
+        return await (0, PromptHelper_1.askText)(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) {
+        if (arg.startsWith(prefix)) {
+            return arg.slice(prefix.length);
+        }
+    }
+    return undefined;
+}
+function validateClosedSet(value, allowed, flagName) {
+    if (allowed.includes(value)) {
+        return null;
+    }
+    return `Invalid value for ${flagName}: "${value}". Allowed values: ${allowed.join(", ")}.\n`;
+}
+const CODEX_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
+const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+const CLAUDE_MODEL_FAMILIES = [
+    {
+        family: "Opus",
+        entries: [
+            { label: "Latest Opus", value: "opus" },
+            { label: "Latest Opus [1m context]", value: "opus[1m]" },
+            { label: "Opus 4.8", value: "claude-opus-4-8" },
+            { label: "Opus 4.8 [1m context]", value: "claude-opus-4-8[1m]" },
+            { label: "Opus 4.7", value: "claude-opus-4-7" },
+            { label: "Opus 4.7 [1m context]", value: "claude-opus-4-7[1m]" },
+            { label: "Opus 4.6", value: "claude-opus-4-6" },
+            { label: "Opus 4.6 [1m context]", value: "claude-opus-4-6[1m]" }
+        ]
+    },
+    {
+        family: "Sonnet",
+        entries: [
+            { label: "Latest Sonnet", value: "sonnet" },
+            { label: "Latest Sonnet [1m context]", value: "sonnet[1m]" },
+            { 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" },
+            { label: "Sonnet 4.5 [1m context]", value: "claude-sonnet-4-5[1m]" }
+        ]
+    },
+    {
+        family: "Haiku",
+        entries: [
+            { label: "Latest Haiku", value: "haiku" },
+            { label: "Haiku 4.5", value: "claude-haiku-4-5-20251001" }
+        ]
+    },
+    {
+        family: "Fable",
+        entries: [
+            { label: "Latest Fable", value: "fable" },
+            { label: "Fable 5", value: "claude-fable-5" }
+        ]
+    }
+];
+const CLAUDE_CROSS_FAMILY_ALIASES = [
+    { label: "Best (auto-pick)", value: "best" }
+];
+const CLAUDE_BACK_LABEL = "← back";
+const REVIEWER_INDEXED_RE = /^--reviewer-(\d+)-(tool|model|effort)=/;
+function parseInstallFlags(rawArgs) {
+    var _a;
+    const hasGlobal = rawArgs.includes("--global");
+    const hasProject = rawArgs.includes("--project");
+    if (hasGlobal && hasProject) {
+        return { ok: false, diagnostic: "Conflicting flags: --global and --project cannot be used together.\n" };
+    }
+    const answers = {};
+    if (hasProject)
+        answers.scope = "project";
+    if (hasGlobal)
+        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 workerTool = extractFlagValue(rawArgs, "--worker-tool");
+    if (workerTool !== undefined) {
+        const error = validateClosedSet(workerTool, ["claude", "codex"], "--worker-tool");
+        if (error)
+            return { ok: false, diagnostic: error };
+        answers.workerTool = workerTool;
+    }
+    const workerModel = extractFlagValue(rawArgs, "--worker-model");
+    if (workerModel !== undefined) {
+        answers.workerModel = workerModel;
+    }
+    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 };
+        }
+        answers.workerEffort = workerEffort;
+    }
+    const reviewerIndices = new Map();
+    const reviewer1Tool = extractFlagValue(rawArgs, "--reviewer-tool");
+    const reviewer1Model = extractFlagValue(rawArgs, "--reviewer-model");
+    const reviewer1Effort = extractFlagValue(rawArgs, "--reviewer-effort");
+    if (reviewer1Tool !== undefined) {
+        const error = validateClosedSet(reviewer1Tool, ["claude", "codex"], "--reviewer-tool");
+        if (error)
+            return { ok: false, diagnostic: error };
+        if (!reviewerIndices.has(1))
+            reviewerIndices.set(1, {});
+        reviewerIndices.get(1).tool = reviewer1Tool;
+    }
+    if (reviewer1Model !== undefined) {
+        if (!reviewerIndices.has(1))
+            reviewerIndices.set(1, {});
+        reviewerIndices.get(1).model = reviewer1Model;
+    }
+    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 };
+        }
+        if (!reviewerIndices.has(1))
+            reviewerIndices.set(1, {});
+        reviewerIndices.get(1).effort = reviewer1Effort;
+    }
+    for (const arg of rawArgs) {
+        const match = arg.match(REVIEWER_INDEXED_RE);
+        if (!match)
+            continue;
+        const idx = Number(match[1]);
+        if (idx < 2) {
+            return { ok: false, diagnostic: `Invalid reviewer flag: "${arg}". Reviewer 1 uses --reviewer-tool/-model/-effort; --reviewer-N-* requires N >= 2.\n` };
+        }
+        const field = match[2];
+        const value = arg.slice(arg.indexOf("=") + 1);
+        if (!reviewerIndices.has(idx))
+            reviewerIndices.set(idx, {});
+        const entry = reviewerIndices.get(idx);
+        if (field === "tool") {
+            const error = validateClosedSet(value, ["claude", "codex"], `--reviewer-${idx}-tool`);
+            if (error)
+                return { ok: false, diagnostic: error };
+            entry.tool = value;
+        }
+        else if (field === "model") {
+            entry.model = value;
+        }
+        else {
+            entry.effort = value;
+        }
+    }
+    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 (error)
+                return { ok: false, diagnostic: error };
+        }
+    }
+    if (reviewerIndices.size > 0) {
+        const sortedIndices = [...reviewerIndices.keys()].sort((a, b) => a - b);
+        const maxIdx = sortedIndices[sortedIndices.length - 1];
+        for (let i = 1; i <= maxIdx; i++) {
+            if (!reviewerIndices.has(i)) {
+                return { ok: false, diagnostic: `Reviewer flag indices are not contiguous: missing reviewer ${i}. Indexed reviewer flags must form a contiguous run starting at reviewer 1.\n` };
+            }
+        }
+        const list = [];
+        for (let i = 1; i <= maxIdx; i++) {
+            list.push(reviewerIndices.get(i));
+        }
+        answers.reviewers = list;
+    }
+    return { ok: true, answers };
+}
 class Install {
     constructor(rawArgs, _options, _contexts) {
         this._disposed = false;
+        this._modelProbeCache = new Map();
         this._runPromise = this._run(rawArgs, _options, _contexts);
         this._runPromise.catch(() => { });
     }
     result() {
         return this._runPromise;
     }
+    async _resolveCuratedChoice(headerLabel, question, curatedValues, defaultLabel, customLabel, customPlaceholder, contexts) {
+        const options = curatedValues.map(v => ({ label: v }));
+        options.push({ label: defaultLabel });
+        options.push({ label: customLabel });
+        const option = await promptChoice(contexts.ask, {
+            header: headerLabel,
+            question,
+            options
+        });
+        if (!option) {
+            return null;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        if (option.label === defaultLabel) {
+            return "";
+        }
+        if (option.label === customLabel) {
+            const text = await promptText(contexts.ask, {
+                question,
+                placeholder: customPlaceholder
+            });
+            if (text === null) {
+                return null;
+            }
+            if (this._disposed) {
+                return null;
+            }
+            return text;
+        }
+        return option.label;
+    }
+    async _resolveClaudeModel(roleLabel, headerLabel, contexts) {
+        const question = `Which model should ${roleLabel} use?`;
+        topLevel: for (;;) {
+            const topOptions = [
+                ...CLAUDE_MODEL_FAMILIES.map(family => ({ label: family.family })),
+                ...CLAUDE_CROSS_FAMILY_ALIASES.map(alias => ({ label: alias.label })),
+                { label: "default configured model" },
+                { label: "enter a custom value…" }
+            ];
+            const top = await promptChoice(contexts.ask, {
+                header: headerLabel,
+                question,
+                options: topOptions
+            });
+            if (!top) {
+                return null;
+            }
+            if (this._disposed) {
+                return null;
+            }
+            if (top.label === "default configured model") {
+                return "";
+            }
+            if (top.label === "enter a custom value…") {
+                const text = await promptText(contexts.ask, {
+                    question,
+                    placeholder: "leave empty for the default configured model"
+                });
+                if (text === null) {
+                    return null;
+                }
+                if (this._disposed) {
+                    return null;
+                }
+                return text;
+            }
+            const crossFamily = CLAUDE_CROSS_FAMILY_ALIASES.find(alias => alias.label === top.label);
+            if (crossFamily) {
+                return crossFamily.value;
+            }
+            const family = CLAUDE_MODEL_FAMILIES.find(f => f.family === top.label);
+            for (;;) {
+                const familyOptions = family.entries.map(entry => ({ label: entry.label }));
+                familyOptions.push({ label: CLAUDE_BACK_LABEL });
+                const choice = await promptChoice(contexts.ask, {
+                    header: headerLabel,
+                    question: `Which ${family.family} model should ${roleLabel} use?`,
+                    options: familyOptions
+                });
+                if (!choice) {
+                    return null;
+                }
+                if (this._disposed) {
+                    return null;
+                }
+                if (choice.label === CLAUDE_BACK_LABEL) {
+                    continue topLevel;
+                }
+                const entry = family.entries.find(e => e.label === choice.label);
+                return entry.value;
+            }
+        }
+    }
+    async _resolveRoleModel(roleLabel, headerLabel, tool, suppliedModel, contexts) {
+        if (suppliedModel !== undefined) {
+            return suppliedModel;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        if (tool === "claude") {
+            return await this._resolveClaudeModel(roleLabel, headerLabel, contexts);
+        }
+        if (!this._modelProbeCache.has(tool)) {
+            const result = await (0, InstallModelProbe_1.probeModelList)(contexts.script);
+            if (this._disposed) {
+                return null;
+            }
+            this._modelProbeCache.set(tool, result);
+            if (result.kind === "not-started") {
+                contexts.output.writeError(`Could not start codex to list models: ${result.reason}\n`);
+            }
+        }
+        const probeResult = this._modelProbeCache.get(tool);
+        if (probeResult.kind === "list") {
+            const options = probeResult.models.map(m => ({ label: m }));
+            options.push({ label: "default configured model" });
+            const option = await promptChoice(contexts.ask, {
+                header: headerLabel,
+                question: `Which model should ${roleLabel} use?`,
+                options
+            });
+            if (!option) {
+                return null;
+            }
+            if (this._disposed) {
+                return null;
+            }
+            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"
+        });
+        if (text === null) {
+            return null;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        return text;
+    }
+    async _resolveRoleEffort(roleLabel, headerLabel, tool, suppliedEffort, contexts) {
+        if (suppliedEffort !== undefined) {
+            return suppliedEffort;
+        }
+        if (this._disposed) {
+            return null;
+        }
+        if (tool === "codex") {
+            const options = CODEX_EFFORT_LEVELS.map(e => ({ label: e }));
+            options.push({ label: "default configured effort" });
+            const option = await promptChoice(contexts.ask, {
+                header: headerLabel,
+                question: `What effort level should ${roleLabel} use?`,
+                options
+            });
+            if (!option) {
+                return null;
+            }
+            if (this._disposed) {
+                return null;
+            }
+            return option.label === "default configured effort" ? "" : option.label;
+        }
+        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);
+    }
+    async _resolveReviewer(idx, supplied, contexts) {
+        const ordinal = idx === 1 ? "" : ` ${idx}`;
+        const roleLabel = `reviewer${ordinal}`;
+        let tool;
+        if ((supplied === null || supplied === void 0 ? void 0 : supplied.tool) !== undefined) {
+            tool = supplied.tool;
+        }
+        else {
+            if (this._disposed) {
+                return null;
+            }
+            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" }
+                ]
+            });
+            if (!option) {
+                return null;
+            }
+            if (this._disposed) {
+                return null;
+            }
+            tool = option.label;
+        }
+        const model = await this._resolveRoleModel(roleLabel, `Reviewer${ordinal} model`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.model, contexts);
+        if (model === null) {
+            return null;
+        }
+        const effort = await this._resolveRoleEffort(roleLabel, `Reviewer${ordinal} effort`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.effort, contexts);
+        if (effort === null) {
+            return null;
+        }
+        return { tool, model, effort };
+    }
     async _run(rawArgs, options, contexts) {
         try {
-            const hasGlobal = rawArgs.includes("--global");
-            const hasProject = rawArgs.includes("--project");
-            if (hasGlobal && hasProject) {
-                contexts.output.writeError("Conflicting flags: --global and --project cannot be used together.\n");
+            const parsed = parseInstallFlags(rawArgs);
+            if (!parsed.ok) {
+                contexts.output.writeError(parsed.diagnostic);
                 return 1;
             }
-            let mode;
-            if (hasGlobal) {
-                mode = "global";
+            const answers = parsed.answers;
+            let skillsTool;
+            if (answers.skillsTool !== undefined) {
+                skillsTool = answers.skillsTool;
             }
-            else if (hasProject) {
-                mode = "project";
+            else {
+                if (this._disposed) {
+                    return 1;
+                }
+                const option = await promptChoice(contexts.ask, {
+                    header: "Skills tool",
+                    question: "Which AI tool(s) should the skills be installed for?",
+                    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" }
+                    ]
+                });
+                if (!option) {
+                    return 1;
+                }
+                if (this._disposed) {
+                    return 1;
+                }
+                skillsTool = option.label;
+            }
+            let mode;
+            if (answers.scope) {
+                mode = answers.scope;
             }
             else {
                 if (this._disposed) {
                     return 1;
                 }
-                const picked = await this._promptDestination(contexts);
+                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 option = await promptChoice(contexts.ask, {
+                    header: "Install destination",
+                    question: "Where should Flanders skills be installed?",
+                    options: [
+                        { label: "project", description: projectDescription },
+                        { label: "global", description: globalDescription }
+                    ]
+                });
+                if (!option) {
+                    return 1;
+                }
+                if (this._disposed) {
+                    return 1;
+                }
+                mode = option.label;
+            }
+            let workerTool;
+            if (answers.workerTool !== undefined) {
+                workerTool = answers.workerTool;
+            }
+            else {
                 if (this._disposed) {
                     return 1;
                 }
-                if (!picked) {
+                const option = await promptChoice(contexts.ask, {
+                    header: "Worker tool",
+                    question: "Which AI tool should the worker use?",
+                    options: [
+                        { label: "claude", description: "Use Claude Code" },
+                        { label: "codex", description: "Use Codex CLI" }
+                    ]
+                });
+                if (!option) {
                     return 1;
                 }
-                mode = picked;
+                if (this._disposed) {
+                    return 1;
+                }
+                workerTool = option.label;
+            }
+            const workerModel = await this._resolveRoleModel("the worker", "Worker model", workerTool, answers.workerModel, contexts);
+            if (workerModel === null) {
+                return 1;
+            }
+            const workerEffort = await this._resolveRoleEffort("the worker", "Worker effort", workerTool, answers.workerEffort, contexts);
+            if (workerEffort === null) {
+                return 1;
+            }
+            const suppliedReviewers = answers.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);
+                    if (reviewer === null) {
+                        return 1;
+                    }
+                    reviewers.push(reviewer);
+                }
             }
-            const skillsRoot = mode === "global"
-                ? (0, fsUtils_1.joinPath)(contexts.platform.homedir(), ".claude/skills")
-                : (0, fsUtils_1.joinPath)(options.projectRoot, ".claude/skills");
+            else {
+                let idx = 1;
+                for (;;) {
+                    const reviewer = await this._resolveReviewer(idx, undefined, contexts);
+                    if (reviewer === null) {
+                        return 1;
+                    }
+                    reviewers.push(reviewer);
+                    if (this._disposed) {
+                        return 1;
+                    }
+                    const more = await promptChoice(contexts.ask, {
+                        header: "Configure another reviewer?",
+                        question: "Configure another reviewer?",
+                        options: [
+                            { label: "no", description: "Stop adding reviewers" },
+                            { label: "yes", description: "Configure another reviewer in the ordered list" }
+                        ]
+                    });
+                    if (!more) {
+                        return 1;
+                    }
+                    if (this._disposed) {
+                        return 1;
+                    }
+                    if (more.label === "no") {
+                        break;
+                    }
+                    idx++;
+                }
+            }
+            const scopeRoot = mode === "global"
+                ? contexts.platform.homedir()
+                : options.projectRoot;
             for (const skill of SKILLS) {
                 if (!skill.body) {
                     contexts.output.writeError(`Skill "${skill.name}" has no content.\n`);
                     return 1;
                 }
             }
+            const writeClaude = skillsTool === "claude" || skillsTool === "both";
+            const writeCodex = skillsTool === "codex" || skillsTool === "both";
             const writtenPaths = [];
-            for (const skill of SKILLS) {
-                if (this._disposed) {
-                    return 1;
+            if (writeClaude) {
+                const claudeSkillsRoot = (0, fsUtils_1.joinPath)(scopeRoot, ".claude/skills");
+                for (const skill of SKILLS) {
+                    if (this._disposed) {
+                        return 1;
+                    }
+                    const skillFolder = (0, fsUtils_1.joinPath)(claudeSkillsRoot, skill.name);
+                    try {
+                        await contexts.fs.mkdir(skillFolder, { recursive: true });
+                    }
+                    catch {
+                        contexts.output.writeError(`Cannot create destination: ${skillFolder}\n`);
+                        return 1;
+                    }
+                    const filePath = (0, fsUtils_1.joinPath)(skillFolder, "SKILL.md");
+                    try {
+                        await contexts.fs.writeFile(filePath, skill.body);
+                        writtenPaths.push(filePath);
+                    }
+                    catch {
+                        contexts.output.writeError(`Cannot write file: ${filePath}\n`);
+                        return 1;
+                    }
                 }
-                const skillFolder = (0, fsUtils_1.joinPath)(skillsRoot, skill.folder);
+            }
+            if (writeCodex) {
+                const codexPromptsRoot = (0, fsUtils_1.joinPath)(scopeRoot, ".codex/prompts");
                 try {
-                    await contexts.fs.mkdir(skillFolder, { recursive: true });
+                    await contexts.fs.mkdir(codexPromptsRoot, { recursive: true });
                 }
                 catch {
-                    contexts.output.writeError(`Cannot create destination: ${skillFolder}\n`);
+                    contexts.output.writeError(`Cannot create destination: ${codexPromptsRoot}\n`);
                     return 1;
                 }
-                const filePath = (0, fsUtils_1.joinPath)(skillFolder, "SKILL.md");
-                try {
-                    await contexts.fs.writeFile(filePath, skill.body);
-                    writtenPaths.push(filePath);
-                }
-                catch {
-                    contexts.output.writeError(`Cannot write file: ${filePath}\n`);
-                    return 1;
+                for (const skill of SKILLS) {
+                    if (this._disposed) {
+                        return 1;
+                    }
+                    const filePath = (0, fsUtils_1.joinPath)(codexPromptsRoot, `${skill.name}.md`);
+                    try {
+                        await contexts.fs.writeFile(filePath, stripYamlFrontmatter(skill.body));
+                        writtenPaths.push(filePath);
+                    }
+                    catch {
+                        contexts.output.writeError(`Cannot write file: ${filePath}\n`);
+                        return 1;
+                    }
                 }
             }
+            if (this._disposed) {
+                return 1;
+            }
+            const config = {
+                worker: { tool: workerTool, model: workerModel, effort: workerEffort },
+                reviewers
+            };
+            const configWrittenPath = await (0, FlandersConfig_1.write)(contexts.fs, {
+                scope: mode,
+                projectRoot: options.projectRoot,
+                homeDir: contexts.platform.homedir(),
+                config
+            });
+            if (this._disposed) {
+                return 1;
+            }
+            writtenPaths.push(configWrittenPath);
             for (const p of writtenPaths) {
                 contexts.output.write(`${p}\n`);
             }
@@ -89,21 +680,6 @@ class Install {
             return 1;
         }
     }
-    async _promptDestination(contexts) {
-        const [answer] = await contexts.ask.askChoices([{
-                header: "Install destination",
-                question: "Where should Flanders skills be installed?",
-                options: [
-                    { label: "project", description: "Install in .claude/skills/ relative to CWD" },
-                    { label: "global", description: "Install in ~/.claude/skills/" }
-                ],
-                multiSelect: false
-            }]);
-        if (!answer || answer.picked.length === 0) {
-            return null;
-        }
-        return answer.picked[0].label;
-    }
     async dispose() {
         if (this._disposed) {
             try {