flanders 0.6.0 → 0.7.0

package/lib/commands/Install.js

@@ -1,33 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Install = void 0;
-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 skillArtifacts_1 = require("./skillArtifacts");
 const InstallModelProbe_1 = require("./InstallModelProbe");
-const SKILLS = [
-    { 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);
@@ -298,14 +276,29 @@ class Install {
     result() {
         return this._runPromise;
     }
-    async _resolveCuratedChoice(headerLabel, question, curatedValues, defaultLabel, customLabel, customPlaceholder, contexts) {
+    async _resolveCuratedChoice(headerLabel, question, curatedValues, defaultLabel, customLabel, customPlaceholder, contexts, preselect) {
         const options = curatedValues.map(v => ({ label: v }));
         options.push({ label: defaultLabel });
         options.push({ label: customLabel });
+        let preselectLabel;
+        let customDefault;
+        if (preselect !== undefined) {
+            if (preselect === "") {
+                preselectLabel = defaultLabel;
+            }
+            else if (curatedValues.includes(preselect)) {
+                preselectLabel = preselect;
+            }
+            else {
+                preselectLabel = customLabel;
+                customDefault = preselect;
+            }
+        }
         const option = await promptChoice(contexts.ask, {
             header: headerLabel,
             question,
-            options
+            options,
+            defaultLabel: preselectLabel
         });
         if (!option) {
             return null;
@@ -319,7 +312,8 @@ class Install {
         if (option.label === customLabel) {
             const text = await promptText(contexts.ask, {
                 question,
-                placeholder: customPlaceholder
+                placeholder: customPlaceholder,
+                default: customDefault
             });
             if (text === null) {
                 return null;
@@ -331,8 +325,35 @@ class Install {
         }
         return option.label;
     }
-    async _resolveClaudeModel(roleLabel, headerLabel, contexts) {
+    async _resolveClaudeModel(roleLabel, headerLabel, contexts, preselect) {
         const question = `Which model should ${roleLabel} use?`;
+        let topDefault;
+        let customDefault;
+        let preselectedFamily;
+        let preselectedEntryLabel;
+        if (preselect !== undefined) {
+            if (preselect === "") {
+                topDefault = "default configured model";
+            }
+            else {
+                const alias = CLAUDE_CROSS_FAMILY_ALIASES.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;
+                    }
+                    else {
+                        topDefault = "enter a custom value…";
+                        customDefault = preselect;
+                    }
+                }
+            }
+        }
         topLevel: for (;;) {
             const topOptions = [
                 ...CLAUDE_MODEL_FAMILIES.map(family => ({ label: family.family })),
@@ -343,7 +364,8 @@ class Install {
             const top = await promptChoice(contexts.ask, {
                 header: headerLabel,
                 question,
-                options: topOptions
+                options: topOptions,
+                defaultLabel: topDefault
             });
             if (!top) {
                 return null;
@@ -357,7 +379,8 @@ class Install {
             if (top.label === "enter a custom value…") {
                 const text = await promptText(contexts.ask, {
                     question,
-                    placeholder: "leave empty for the default configured model"
+                    placeholder: "leave empty for the default configured model",
+                    default: customDefault
                 });
                 if (text === null) {
                     return null;
@@ -378,7 +401,8 @@ class Install {
                 const choice = await promptChoice(contexts.ask, {
                     header: headerLabel,
                     question: `Which ${family.family} model should ${roleLabel} use?`,
-                    options: familyOptions
+                    options: familyOptions,
+                    defaultLabel: family === preselectedFamily ? preselectedEntryLabel : undefined
                 });
                 if (!choice) {
                     return null;
@@ -394,7 +418,7 @@ class Install {
             }
         }
     }
-    async _resolveRoleModel(roleLabel, headerLabel, tool, suppliedModel, contexts) {
+    async _resolveRoleModel(roleLabel, headerLabel, tool, suppliedModel, contexts, preselect) {
         if (suppliedModel !== undefined) {
             return suppliedModel;
         }
@@ -402,7 +426,7 @@ class Install {
             return null;
         }
         if (tool === "claude") {
-            return await this._resolveClaudeModel(roleLabel, headerLabel, contexts);
+            return await this._resolveClaudeModel(roleLabel, headerLabel, contexts, preselect);
         }
         if (!this._modelProbeCache.has(tool)) {
             const result = await (0, InstallModelProbe_1.probeModelList)(contexts.script);
@@ -418,10 +442,20 @@ class Install {
         if (probeResult.kind === "list") {
             const options = probeResult.models.map(m => ({ label: m }));
             options.push({ label: "default configured model" });
+            let modelDefaultLabel;
+            if (preselect !== undefined) {
+                if (preselect === "") {
+                    modelDefaultLabel = "default configured model";
+                }
+                else if (probeResult.models.includes(preselect)) {
+                    modelDefaultLabel = preselect;
+                }
+            }
             const option = await promptChoice(contexts.ask, {
                 header: headerLabel,
                 question: `Which model should ${roleLabel} use?`,
-                options
+                options,
+                defaultLabel: modelDefaultLabel
             });
             if (!option) {
                 return null;
@@ -433,7 +467,8 @@ class Install {
         }
         const text = await promptText(contexts.ask, {
             question: `Which model should ${roleLabel} use?`,
-            placeholder: "leave empty for the default configured model"
+            placeholder: "leave empty for the default configured model",
+            default: preselect
         });
         if (text === null) {
             return null;
@@ -443,7 +478,7 @@ class Install {
         }
         return text;
     }
-    async _resolveRoleEffort(roleLabel, headerLabel, tool, suppliedEffort, contexts) {
+    async _resolveRoleEffort(roleLabel, headerLabel, tool, suppliedEffort, contexts, preselect) {
         if (suppliedEffort !== undefined) {
             return suppliedEffort;
         }
@@ -453,10 +488,15 @@ class Install {
         if (tool === "codex") {
             const options = CODEX_EFFORT_LEVELS.map(e => ({ label: e }));
             options.push({ label: "default configured effort" });
+            let effortDefaultLabel;
+            if (preselect !== undefined) {
+                effortDefaultLabel = preselect === "" ? "default configured effort" : preselect;
+            }
             const option = await promptChoice(contexts.ask, {
                 header: headerLabel,
                 question: `What effort level should ${roleLabel} use?`,
-                options
+                options,
+                defaultLabel: effortDefaultLabel
             });
             if (!option) {
                 return null;
@@ -466,9 +506,9 @@ class Install {
             }
             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);
+        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) {
+    async _resolveReviewer(idx, supplied, contexts, storedReviewer) {
         const ordinal = idx === 1 ? "" : ` ${idx}`;
         const roleLabel = `reviewer${ordinal}`;
         let tool;
@@ -485,7 +525,8 @@ class Install {
                 options: [
                     { label: "claude", description: "Use Claude Code" },
                     { label: "codex", description: "Use Codex CLI" }
-                ]
+                ],
+                defaultLabel: storedReviewer === null || storedReviewer === void 0 ? void 0 : storedReviewer.tool
             });
             if (!option) {
                 return null;
@@ -495,17 +536,18 @@ class Install {
             }
             tool = option.label;
         }
-        const model = await this._resolveRoleModel(roleLabel, `Reviewer${ordinal} model`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.model, contexts);
+        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;
         }
-        const effort = await this._resolveRoleEffort(roleLabel, `Reviewer${ordinal} effort`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.effort, contexts);
+        const effort = await this._resolveRoleEffort(roleLabel, `Reviewer${ordinal} effort`, tool, supplied === null || supplied === void 0 ? void 0 : supplied.effort, contexts, storedReviewer === null || storedReviewer === void 0 ? void 0 : storedReviewer.effort);
         if (effort === null) {
             return null;
         }
         return { tool, model, effort };
     }
     async _run(rawArgs, options, contexts) {
+        var _a;
         try {
             const parsed = parseInstallFlags(rawArgs);
             if (!parsed.ok) {
@@ -523,7 +565,7 @@ class Install {
                 }
                 const option = await promptChoice(contexts.ask, {
                     header: "Skills tool",
-                    question: "Which AI tool(s) should the skills be installed for?",
+                    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" },
@@ -576,6 +618,14 @@ class Install {
                 }
                 mode = option.label;
             }
+            const storedConfig = await (0, FlandersConfig_1.readScope)(contexts.fs, {
+                scope: mode,
+                projectRoot: options.projectRoot,
+                homeDir: contexts.platform.homedir()
+            });
+            if (this._disposed) {
+                return 1;
+            }
             let workerTool;
             if (answers.workerTool !== undefined) {
                 workerTool = answers.workerTool;
@@ -585,12 +635,13 @@ class Install {
                     return 1;
                 }
                 const option = await promptChoice(contexts.ask, {
-                    header: "Worker tool",
+                    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" }
-                    ]
+                    ],
+                    defaultLabel: storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.worker.tool
                 });
                 if (!option) {
                     return 1;
@@ -600,19 +651,20 @@ class Install {
                 }
                 workerTool = option.label;
             }
-            const workerModel = await this._resolveRoleModel("the worker", "Worker model", workerTool, answers.workerModel, contexts);
+            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;
             }
-            const workerEffort = await this._resolveRoleEffort("the worker", "Worker effort", workerTool, answers.workerEffort, contexts);
+            const workerEffort = await this._resolveRoleEffort("the worker", "Worker effort", workerTool, answers.workerEffort, contexts, storedConfig === null || storedConfig === void 0 ? void 0 : storedConfig.worker.effort);
             if (workerEffort === null) {
                 return 1;
             }
             const suppliedReviewers = answers.reviewers;
+            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);
+                    const reviewer = await this._resolveReviewer(i + 1, suppliedReviewers[i], contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[i]);
                     if (reviewer === null) {
                         return 1;
                     }
@@ -622,7 +674,7 @@ class Install {
             else {
                 let idx = 1;
                 for (;;) {
-                    const reviewer = await this._resolveReviewer(idx, undefined, contexts);
+                    const reviewer = await this._resolveReviewer(idx, undefined, contexts, storedReviewers === null || storedReviewers === void 0 ? void 0 : storedReviewers[idx - 1]);
                     if (reviewer === null) {
                         return 1;
                     }
@@ -630,13 +682,17 @@ class Install {
                     if (this._disposed) {
                         return 1;
                     }
+                    const moreDefault = storedReviewers !== undefined
+                        ? (idx < storedReviewers.length ? "yes" : "no")
+                        : undefined;
                     const more = await promptChoice(contexts.ask, {
                         header: "Configure another reviewer?",
-                        question: "Configure another reviewer?",
+                        question: "Okely-dokely — care to configure another reviewer?",
                         options: [
                             { label: "no", description: "Stop adding reviewers" },
                             { label: "yes", description: "Configure another reviewer in the ordered list" }
-                        ]
+                        ],
+                        defaultLabel: moreDefault
                     });
                     if (!more) {
                         return 1;
@@ -665,6 +721,9 @@ class Install {
             }
             else {
                 const reviewerCount = reviewers.length;
+                const minimumDefault = storedConfig !== null
+                    ? Math.min(storedConfig.minimumReviews, reviewerCount)
+                    : reviewerCount;
                 if (answers.reviewerMinimum !== undefined) {
                     minimumReviews = answers.reviewerMinimum;
                 }
@@ -676,7 +735,8 @@ class Install {
                     while (chosen === null) {
                         const entry = await promptText(contexts.ask, {
                             question: "Minimum reviewers that must run to a verdict in each review round",
-                            placeholder: `1-${reviewerCount}, empty for ${reviewerCount}`
+                            placeholder: `1-${reviewerCount}, empty for ${minimumDefault}`,
+                            default: String(minimumDefault)
                         });
                         if (entry === null) {
                             return 1;
@@ -685,17 +745,12 @@ class Install {
                             return 1;
                         }
                         const trimmed = entry.trim();
-                        if (trimmed === "") {
-                            chosen = reviewerCount;
+                        const parsed = Number(trimmed);
+                        if (/^\d+$/.test(trimmed) && parsed >= 1 && parsed <= reviewerCount) {
+                            chosen = parsed;
                         }
                         else {
-                            const parsed = Number(trimmed);
-                            if (/^\d+$/.test(trimmed) && parsed >= 1 && parsed <= reviewerCount) {
-                                chosen = parsed;
-                            }
-                            else {
-                                contexts.output.write(`Enter an integer between 1 and ${reviewerCount}, or leave empty for ${reviewerCount}.\n`);
-                            }
+                            contexts.output.write(`Whoopsie — enter an integer between 1 and ${reviewerCount}, or leave empty for ${minimumDefault}.\n`);
                         }
                     }
                     minimumReviews = chosen;
@@ -715,13 +770,15 @@ 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 optionalOption = await promptChoice(contexts.ask, {
                                 header: `Reviewer ${i + 1} optional`,
                                 question: `Is reviewer ${i + 1} (${reviewer.tool} · ${modelLabel} · ${effortLabel}) optional?`,
                                 options: [
                                     { label: "no", description: "Required — always waits out its rate-limit waits; the round never completes without its verdict" },
                                     { label: "yes", description: "Optional — reviews exactly like a required reviewer; the only difference is the round abandons it while it is in a rate-limit wait, once every required reviewer is in and the minimum is met" }
-                                ]
+                                ],
+                                defaultLabel: optionalDefault
                             });
                             if (!optionalOption) {
                                 return 1;
@@ -742,63 +799,23 @@ class Install {
             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 = [];
-            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 tools = [];
+            if (skillsTool === "claude" || skillsTool === "both") {
+                tools.push("claude");
+            }
+            if (skillsTool === "codex" || skillsTool === "both") {
+                tools.push("codex");
+            }
+            for (const tool of tools) {
+                const result = await (0, skillArtifacts_1.writeSkillArtifacts)(contexts.fs, scopeRoot, tool, () => this._disposed);
+                if (!result.ok) {
+                    if (result.diagnostic !== null) {
+                        contexts.output.writeError(result.diagnostic);
                     }
-                    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;
-                    }
-                }
-            }
-            if (writeCodex) {
-                const codexPromptsRoot = (0, fsUtils_1.joinPath)(scopeRoot, ".codex/prompts");
-                try {
-                    await contexts.fs.mkdir(codexPromptsRoot, { recursive: true });
-                }
-                catch {
-                    contexts.output.writeError(`Cannot create destination: ${codexPromptsRoot}\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;
-                    }
-                }
+                writtenPaths.push(...result.writtenPaths);
             }
             if (this._disposed) {
                 return 1;

package/lib/commands/Update.d.ts

@@ -0,0 +1,19 @@
+import type { FsContext, OutputContext } from "../contexts";
+import type { PlatformContext } from "../workspace/Workspace";
+export type UpdateContexts = Readonly<{
+    fs: FsContext;
+    output: OutputContext;
+    platform: PlatformContext;
+}>;
+export type UpdateOptions = Readonly<{
+    projectRoot: string;
+}>;
+export declare class Update {
+    private _disposed;
+    private _runPromise;
+    constructor(rawArgs: readonly string[], options: UpdateOptions, contexts: UpdateContexts);
+    result(): Promise<number>;
+    private _isInstalled;
+    private _run;
+    dispose(): Promise<void>;
+}

package/lib/commands/Update.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Update = void 0;
+const skillArtifacts_1 = require("./skillArtifacts");
+class Update {
+    constructor(rawArgs, options, contexts) {
+        this._disposed = false;
+        this._runPromise = this._run(rawArgs, options, contexts);
+        this._runPromise.catch(() => { });
+    }
+    result() {
+        return this._runPromise;
+    }
+    async _isInstalled(fs, scopeRoot, tool) {
+        for (const path of (0, skillArtifacts_1.skillArtifactPaths)(scopeRoot, tool)) {
+            if (await fs.exists(path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async _run(rawArgs, options, contexts) {
+        try {
+            if (rawArgs.length > 0) {
+                contexts.output.writeError("The update command takes no arguments.\n");
+                return 1;
+            }
+            const homeDir = contexts.platform.homedir();
+            const destinations = [
+                { scopeRoot: options.projectRoot, tool: "claude" },
+                { scopeRoot: options.projectRoot, tool: "codex" },
+                { scopeRoot: homeDir, tool: "claude" },
+                { scopeRoot: homeDir, tool: "codex" }
+            ];
+            const writtenPaths = [];
+            let found = false;
+            for (const dest of destinations) {
+                if (this._disposed) {
+                    return 1;
+                }
+                if (!(await this._isInstalled(contexts.fs, dest.scopeRoot, dest.tool))) {
+                    continue;
+                }
+                found = true;
+                const result = await (0, skillArtifacts_1.writeSkillArtifacts)(contexts.fs, dest.scopeRoot, dest.tool, () => this._disposed);
+                if (!result.ok) {
+                    if (result.diagnostic !== null) {
+                        contexts.output.writeError(result.diagnostic);
+                    }
+                    return 1;
+                }
+                writtenPaths.push(...result.writtenPaths);
+            }
+            if (this._disposed) {
+                return 1;
+            }
+            if (!found) {
+                contexts.output.writeError("Well, hi-diddly-ho! There are no Flanders skills installed anywhere to refresh. Run npx flanders install to set them up first.\n");
+                return 1;
+            }
+            for (const p of writtenPaths) {
+                contexts.output.write(`${p}\n`);
+            }
+            return 0;
+        }
+        catch (e) {
+            if (!this._disposed) {
+                contexts.output.writeError(`${e instanceof Error ? e.message : String(e)}\n`);
+            }
+            return 1;
+        }
+    }
+    async dispose() {
+        if (this._disposed) {
+            try {
+                await this._runPromise;
+            }
+            catch {
+            }
+            return;
+        }
+        this._disposed = true;
+        try {
+            await this._runPromise;
+        }
+        catch {
+        }
+    }
+}
+exports.Update = Update;

package/lib/commands/skillArtifacts.d.ts

@@ -0,0 +1,18 @@
+import type { FsContext } from "../contexts";
+type SkillDef = Readonly<{
+    name: string;
+    body: string;
+}>;
+export declare const SKILLS: readonly SkillDef[];
+export declare function skillArtifactPath(scopeRoot: string, tool: "claude" | "codex", skillName: string): string;
+export declare function skillArtifactPaths(scopeRoot: string, tool: "claude" | "codex"): readonly string[];
+export declare function stripYamlFrontmatter(body: string): string;
+export type WriteSkillArtifactsResult = Readonly<{
+    ok: true;
+    writtenPaths: readonly string[];
+}> | Readonly<{
+    ok: false;
+    diagnostic: string | null;
+}>;
+export declare function writeSkillArtifacts(fs: FsContext, scopeRoot: string, tool: "claude" | "codex", isDisposed: () => boolean): Promise<WriteSkillArtifactsResult>;
+export {};