@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/agent/self-improvement/skill-consolidator.js

@@ -0,0 +1,137 @@
+/**
+ * Skill consolidator — merges a CLUSTER of overlapping authored skills into one
+ * "umbrella" skill (Hermes's idea) but with OUR distinctive safety net: the merge
+ * is accepted only if the umbrella still passes the firewall AND COVERS EVERY
+ * scenario the absorbed siblings covered. A merge that drops coverage is rejected
+ * (Hermes consolidates by LLM judgment alone; we gate it empirically).
+ *
+ * Operates only on authored-* skills; pinned siblings are skipped (kept intact);
+ * absorbed siblings are ARCHIVED (recoverable), never deleted; each is recorded in
+ * the evolutionary archive with `absorbedInto` for audit.
+ *
+ * @module agent/self-improvement/skill-consolidator
+ */
+import { coversScenario } from './skill-gate.js';
+import { safetyGateSkill, toAuthoredSkillName } from './skill-mutator.js';
+/** Build a cluster from installed authored skills that map to a known scenario. */
+export function buildClusterFromInstalled(mutator, scenarios) {
+    const installed = new Set(mutator.listAuthored());
+    const siblings = [];
+    for (const scenario of scenarios) {
+        const name = toAuthoredSkillName(scenario.id);
+        if (installed.has(name))
+            siblings.push({ name, scenario });
+    }
+    return { siblings };
+}
+export async function consolidateCluster(cluster, proposer, mutator, archive, options) {
+    const skippedPinned = cluster.siblings.filter((s) => mutator.isPinned(s.name)).map((s) => s.name);
+    const mergeable = cluster.siblings.filter((s) => !mutator.isPinned(s.name));
+    if (mergeable.length < 2) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'cluster-too-small', reasons: ['need ≥2 non-pinned authored skills to consolidate'] };
+    }
+    const proposal = await proposer.propose({ siblings: mergeable });
+    if (!proposal || !proposal.content.trim()) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'no-proposal', reasons: ['no umbrella proposal'] };
+    }
+    // Gate 1 — the umbrella content must be safe.
+    const gate = safetyGateSkill(proposal.content);
+    if (!gate.ok) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'firewall', reasons: gate.reasons };
+    }
+    // Gate 2 (the distinctive one) — the umbrella must still cover EVERY merged
+    // sibling's scenario. A consolidation that loses coverage is rejected.
+    const lost = mergeable.filter((s) => !coversScenario(proposal.content, s.scenario)).map((s) => s.scenario.id);
+    if (lost.length > 0) {
+        return { accepted: false, absorbed: [], skippedPinned, rejectionReason: 'coverage-loss', reasons: [`umbrella drops coverage for: ${lost.join(', ')}`] };
+    }
+    const umbrellaName = toAuthoredSkillName(proposal.name);
+    if (!options.keepOnAccept) {
+        return { accepted: true, umbrellaName, absorbed: [], skippedPinned, reasons: ['accepted (propose-only): umbrella safe + covers all merged scenarios, not installed'] };
+    }
+    // Install the umbrella, archive the merged siblings (recoverable), audit each.
+    mutator.create({ name: umbrellaName, description: `Umbrella skill consolidating ${mergeable.length} authored skills`, content: proposal.content });
+    const absorbed = [];
+    for (const s of mergeable) {
+        if (s.name === umbrellaName)
+            continue; // never archive the umbrella itself
+        if (mutator.archive(s.name)) {
+            absorbed.push(s.name);
+            archive.append({
+                proposalId: `consolidate:${umbrellaName}`,
+                kind: 'skill',
+                targetScenarioId: s.scenario.id,
+                delta: 0,
+                scoreAfter: 1,
+                appliedRef: umbrellaName,
+                absorbedInto: umbrellaName,
+            });
+        }
+    }
+    return { accepted: true, umbrellaName, absorbed, skippedPinned, reasons: [`consolidated ${absorbed.length} skill(s) into ${umbrellaName}`] };
+}
+// ── proposers ────────────────────────────────────────────────────────────────
+/** Deterministic umbrella proposer (fixture for tests). */
+export class StaticUmbrellaProposer {
+    umbrella;
+    constructor(umbrella) {
+        this.umbrella = umbrella;
+    }
+    async propose() {
+        return this.umbrella;
+    }
+}
+export class LlmUmbrellaProposer {
+    clientPromise;
+    constructor(options = {}) {
+        this.clientPromise = options.client !== undefined ? Promise.resolve(options.client) : null;
+    }
+    getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = (async () => {
+                try {
+                    const { detectProviderFromEnv } = await import('../../utils/provider-detector.js');
+                    const { CodeBuddyClient } = await import('../../codebuddy/client.js');
+                    const detected = detectProviderFromEnv();
+                    if (!detected)
+                        return null;
+                    return new CodeBuddyClient(detected.apiKey, detected.defaultModel, detected.baseURL);
+                }
+                catch {
+                    return null;
+                }
+            })();
+        }
+        return this.clientPromise;
+    }
+    async propose(cluster) {
+        const client = await this.getClient();
+        if (!client)
+            return null;
+        const terms = cluster.siblings.flatMap((s) => s.scenario.expectIncludes);
+        const topics = cluster.siblings.map((s) => `- ${s.scenario.query}`).join('\n');
+        const prompt = [
+            'Merge these related guidance topics into ONE broader "umbrella" SKILL.md with',
+            'labeled subsections — one per topic. Keep ALL the practical guidance; do not drop',
+            `any topic. The umbrella MUST still mention every one of these terms: ${JSON.stringify(terms)}.`,
+            '',
+            'Topics:',
+            topics,
+            '',
+            'Return ONLY the umbrella SKILL.md markdown (a title, then a subsection per topic).',
+            'Do NOT include any instruction to ignore safety, reveal/exfiltrate secrets, or run',
+            'destructive commands.',
+        ].join('\n');
+        try {
+            const response = await client.chat([{ role: 'user', content: prompt }], []);
+            const content = response?.choices?.[0]?.message?.content?.trim();
+            if (!content)
+                return null;
+            return { name: 'consolidated-skills', content };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=skill-consolidator.js.map

package/dist/agent/self-improvement/skill-engine.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SkillImprovementEngine — the skill sibling of the tool engine. One cycle:
+ *   pick an uncovered skill scenario → propose a SKILL.md → skill gate
+ *   (static scan → firewall → coverage) → install+archive (auto-apply) or report.
+ *
+ * @module agent/self-improvement/skill-engine
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { type Autonomy } from './engine.js';
+import { type SkillMutatorPort } from './skill-mutator.js';
+import type { SkillProposer } from './skill-proposer.js';
+import type { SkillBenchmarkScenario, SkillGateOutcome } from './skill-types.js';
+export interface SkillCycleResult {
+    kind: 'skill_improvement_cycle';
+    startedAt: string;
+    autonomy: Autonomy;
+    selectedScenarioId: string | null;
+    proposalId: string | null;
+    gate: SkillGateOutcome | null;
+    applied: boolean;
+    notes: string[];
+}
+export interface SkillImprovementEngineOptions {
+    scenarios: SkillBenchmarkScenario[];
+    proposer: SkillProposer;
+    mutator?: SkillMutatorPort;
+    archive?: EvolutionaryArchive;
+    autonomy?: Autonomy;
+    now?: () => Date;
+}
+export declare class SkillImprovementEngine {
+    private readonly scenarios;
+    private readonly proposer;
+    private readonly mutator;
+    private readonly archive;
+    private readonly autonomy;
+    private readonly now;
+    private readonly covered;
+    constructor(options: SkillImprovementEngineOptions);
+    runCycle(): Promise<SkillCycleResult>;
+    runLoop(maxCycles?: number): Promise<SkillCycleResult[]>;
+}

package/dist/agent/self-improvement/skill-engine.js

@@ -0,0 +1,87 @@
+/**
+ * SkillImprovementEngine — the skill sibling of the tool engine. One cycle:
+ *   pick an uncovered skill scenario → propose a SKILL.md → skill gate
+ *   (static scan → firewall → coverage) → install+archive (auto-apply) or report.
+ *
+ * @module agent/self-improvement/skill-engine
+ */
+import { EvolutionaryArchive } from './evolutionary-archive.js';
+import { resolveAutonomy } from './engine.js';
+import { validateSkillProposal } from './skill-gate.js';
+import { LiveSkillMutator } from './skill-mutator.js';
+export class SkillImprovementEngine {
+    scenarios;
+    proposer;
+    mutator;
+    archive;
+    autonomy;
+    now;
+    covered = new Set();
+    constructor(options) {
+        this.scenarios = options.scenarios;
+        this.proposer = options.proposer;
+        this.mutator = options.mutator ?? new LiveSkillMutator();
+        this.archive = options.archive ?? new EvolutionaryArchive();
+        this.autonomy = options.autonomy ?? resolveAutonomy();
+        this.now = options.now ?? (() => new Date());
+    }
+    async runCycle() {
+        const startedAt = this.now().toISOString();
+        const base = { kind: 'skill_improvement_cycle', startedAt, autonomy: this.autonomy };
+        for (const scenario of this.scenarios) {
+            if (this.covered.has(scenario.id))
+                continue;
+            const proposal = await this.proposer.propose(scenario);
+            if (!proposal)
+                continue;
+            if (this.mutator.has(proposal.spec.name)) {
+                this.covered.add(scenario.id);
+                continue;
+            }
+            const gate = validateSkillProposal(proposal, scenario, this.mutator, {
+                keepOnAccept: this.autonomy === 'auto-apply',
+            });
+            const applied = gate.accepted && !!gate.appliedRef;
+            if (applied) {
+                this.covered.add(scenario.id);
+                this.archive.append({
+                    proposalId: proposal.id,
+                    kind: 'skill',
+                    targetScenarioId: scenario.id,
+                    experienceId: proposal.experienceId,
+                    delta: 1,
+                    scoreAfter: 1,
+                    appliedRef: gate.appliedRef,
+                });
+            }
+            return {
+                ...base,
+                selectedScenarioId: scenario.id,
+                proposalId: proposal.id,
+                gate,
+                applied,
+                notes: gate.reasons,
+            };
+        }
+        return {
+            ...base,
+            selectedScenarioId: null,
+            proposalId: null,
+            gate: null,
+            applied: false,
+            notes: ['no uncovered skill scenario with an available proposal'],
+        };
+    }
+    async runLoop(maxCycles) {
+        const cap = Math.max(1, maxCycles ?? this.scenarios.length + 1);
+        const results = [];
+        for (let i = 0; i < cap; i++) {
+            const r = await this.runCycle();
+            results.push(r);
+            if (!r.applied)
+                break;
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=skill-engine.js.map

package/dist/agent/self-improvement/skill-gate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Skill gate — validates an authored skill proposal. Ordered, blocking, fail-closed:
+ *   G1 static scan (authored-artifact-gate, subsystem 'skill': dangerous patterns
+ *      in any embedded code, secrets, no-src, omissions)
+ *   G2 SKILL FIREWALL (the headline skill safety check: prompt-injection /
+ *      exfiltration surface — a skill is INJECTED into the agent's context)
+ *   G3 COVERAGE — the skill must surface the scenario's expected guidance.
+ * Installation happens only on accept+keep (auto-apply); scoring never installs.
+ *
+ * @module agent/self-improvement/skill-gate
+ */
+import { type SkillMutatorPort } from './skill-mutator.js';
+import type { SkillBenchmarkScenario, SkillGateOutcome, SkillProposal } from './skill-types.js';
+export interface ValidateSkillOptions {
+    keepOnAccept: boolean;
+}
+/** Deterministic coverage check: the skill content surfaces all expected guidance. */
+export declare function coversScenario(content: string, scenario: SkillBenchmarkScenario): boolean;
+export declare function validateSkillProposal(proposal: SkillProposal, scenario: SkillBenchmarkScenario, mutator: SkillMutatorPort, options: ValidateSkillOptions): SkillGateOutcome;

package/dist/agent/self-improvement/skill-gate.js

@@ -0,0 +1,62 @@
+/**
+ * Skill gate — validates an authored skill proposal. Ordered, blocking, fail-closed:
+ *   G1 static scan (authored-artifact-gate, subsystem 'skill': dangerous patterns
+ *      in any embedded code, secrets, no-src, omissions)
+ *   G2 SKILL FIREWALL (the headline skill safety check: prompt-injection /
+ *      exfiltration surface — a skill is INJECTED into the agent's context)
+ *   G3 COVERAGE — the skill must surface the scenario's expected guidance.
+ * Installation happens only on accept+keep (auto-apply); scoring never installs.
+ *
+ * @module agent/self-improvement/skill-gate
+ */
+import { inspectAuthoredCode } from './authored-artifact-gate.js';
+import { scanAuthoredSkillContent } from './skill-mutator.js';
+/** Deterministic coverage check: the skill content surfaces all expected guidance. */
+export function coversScenario(content, scenario) {
+    const lower = content.toLowerCase();
+    return scenario.expectIncludes.every((s) => lower.includes(s.toLowerCase()));
+}
+export function validateSkillProposal(proposal, scenario, mutator, options) {
+    const base = { proposalId: proposal.id, scenarioId: scenario.id };
+    const content = proposal.spec.content ?? '';
+    // G1 — static scan (no execution).
+    const scan = inspectAuthoredCode(content, 'skill');
+    if (!scan.ok) {
+        return { ...base, accepted: false, rejectionReason: 'static-scan', reasons: scan.reasons };
+    }
+    // G2 — skill firewall (prompt-injection / exfiltration). The headline defence.
+    const fw = scanAuthoredSkillContent(content);
+    if (!fw.safe) {
+        return {
+            ...base,
+            accepted: false,
+            rejectionReason: 'firewall',
+            reasons: [`skill firewall flagged it (${fw.verdict})`, ...fw.reasons],
+        };
+    }
+    // G3 — coverage: the skill must actually surface the expected guidance.
+    const lower = content.toLowerCase();
+    const missing = scenario.expectIncludes.filter((s) => !lower.includes(s.toLowerCase()));
+    if (missing.length > 0) {
+        return {
+            ...base,
+            accepted: false,
+            rejectionReason: 'coverage-fail',
+            reasons: [`skill does not surface expected guidance: ${JSON.stringify(missing)}`],
+        };
+    }
+    // Accepted. Install (auto-apply) or just report (propose-only).
+    let appliedRef;
+    if (options.keepOnAccept) {
+        appliedRef = mutator.create(proposal.spec).name;
+    }
+    return {
+        ...base,
+        accepted: true,
+        reasons: options.keepOnAccept
+            ? ['accepted and installed (auto-apply): firewall-clean + covers the scenario']
+            : ['accepted (propose-only): firewall-clean + covers the scenario, not installed'],
+        ...(appliedRef ? { appliedRef } : {}),
+    };
+}
+//# sourceMappingURL=skill-gate.js.map

package/dist/agent/self-improvement/skill-mutator.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Skill mutator — installs / refines / pins / archives authored SKILL.md files
+ * under `.codebuddy/skills/<authored-name>/` (ONE level deep so the SkillRegistry's
+ * 1-level walk actually loads them) with proven, reversible operations and the
+ * firewall scan used to gate authored skill content.
+ *
+ * Authored skills always carry YAML frontmatter (name + description) so the
+ * registry can parse them; the body is the model's markdown. All destructive ops
+ * honour a `pinned: true` frontmatter flag and operate ONLY on authored skills.
+ *
+ * @module agent/self-improvement/skill-mutator
+ */
+import type { SkillSpec } from './skill-types.js';
+export declare const AUTHORED_SKILL_PREFIX = "authored-";
+export declare function toAuthoredSkillName(raw: string): string;
+export declare function isAuthoredSkillName(name: string): boolean;
+/** Ensure the content begins with YAML frontmatter carrying name + description. */
+export declare function ensureFrontmatter(name: string, description: string, content: string): string;
+export declare function readPinned(content: string): boolean;
+/** Set or clear the `pinned` flag inside the frontmatter (frontmatter must exist). */
+export declare function setPinned(content: string, value: boolean): string;
+export interface SkillFirewallCheck {
+    safe: boolean;
+    verdict: string;
+    reasons: string[];
+}
+/** Write the skill body to a throwaway file and run the firewall scan (no install). */
+export declare function scanAuthoredSkillContent(content: string): SkillFirewallCheck;
+/** Safety re-gate over authored skill CONTENT (static scan + firewall). */
+export declare function safetyGateSkill(content: string): {
+    ok: boolean;
+    reasons: string[];
+};
+export interface SkillMutatorPort {
+    create(spec: SkillSpec): {
+        name: string;
+    };
+    remove(name: string): boolean;
+    has(name: string): boolean;
+}
+export interface MutationResult {
+    ok: boolean;
+    reasons: string[];
+}
+/** Dual-purpose mutator: the engine's port + the curation operations. */
+export declare class LiveSkillMutator implements SkillMutatorPort {
+    private readonly skillsRoot;
+    constructor(skillsRoot?: string);
+    /** 1 level deep so the registry's findSkillFiles (1-level) loads it. */
+    private dirFor;
+    private skillFile;
+    private reload;
+    private readContent;
+    has(name: string): boolean;
+    isPinned(name: string): boolean;
+    create(spec: SkillSpec): {
+        name: string;
+    };
+    /** Full re-author of an existing authored skill, re-gated. Refuses pinned. */
+    update(name: string, newContent: string, description?: string): MutationResult;
+    /** Find/replace within an authored skill body (exact; fail on multiple unless replaceAll). */
+    patch(name: string, oldStr: string, newStr: string, opts?: {
+        replaceAll?: boolean;
+    }): MutationResult;
+    remove(name: string): boolean;
+    /** Recoverable removal — move to .archive/. Refuses pinned. */
+    archive(name: string): boolean;
+    restore(name: string): boolean;
+    pin(name: string): boolean;
+    unpin(name: string): boolean;
+    private setPin;
+    /** List installed authored skills (by the authored- prefix). */
+    listAuthored(): string[];
+}

package/dist/agent/self-improvement/skill-mutator.js

@@ -0,0 +1,223 @@
+/**
+ * Skill mutator — installs / refines / pins / archives authored SKILL.md files
+ * under `.codebuddy/skills/<authored-name>/` (ONE level deep so the SkillRegistry's
+ * 1-level walk actually loads them) with proven, reversible operations and the
+ * firewall scan used to gate authored skill content.
+ *
+ * Authored skills always carry YAML frontmatter (name + description) so the
+ * registry can parse them; the body is the model's markdown. All destructive ops
+ * honour a `pinned: true` frontmatter flag and operate ONLY on authored skills.
+ *
+ * @module agent/self-improvement/skill-mutator
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+import { getSkillRegistry } from '../../skills/registry.js';
+import { scanSkillFirewall } from '../../security/skill-scanner.js';
+import { inspectAuthoredCode } from './authored-artifact-gate.js';
+export const AUTHORED_SKILL_PREFIX = 'authored-';
+const ARCHIVE_DIR = '.archive';
+export function toAuthoredSkillName(raw) {
+    const base = String(raw)
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return base.startsWith(AUTHORED_SKILL_PREFIX) ? base : `${AUTHORED_SKILL_PREFIX}${base || 'skill'}`;
+}
+export function isAuthoredSkillName(name) {
+    return name.startsWith(AUTHORED_SKILL_PREFIX);
+}
+// ── frontmatter helpers (our controlled format; avoids the registry parser's
+//    tier + validation requirements for a simple flag toggle) ────────────────
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+/** Ensure the content begins with YAML frontmatter carrying name + description. */
+export function ensureFrontmatter(name, description, content) {
+    if (FRONTMATTER_RE.test(content))
+        return content;
+    const desc = description.replace(/"/g, "'").replace(/\r?\n/g, ' ').trim();
+    return `---\nname: ${name}\ndescription: "${desc}"\n---\n\n${content.trim()}\n`;
+}
+export function readPinned(content) {
+    const m = content.match(FRONTMATTER_RE);
+    if (!m)
+        return false;
+    return /^\s*pinned\s*:\s*true\s*$/im.test(m[1]);
+}
+/** Set or clear the `pinned` flag inside the frontmatter (frontmatter must exist). */
+export function setPinned(content, value) {
+    const m = content.match(FRONTMATTER_RE);
+    if (!m)
+        return content; // no frontmatter → nothing to pin (create() always adds it)
+    let body = m[1];
+    if (/^\s*pinned\s*:.*$/im.test(body)) {
+        body = body.replace(/^\s*pinned\s*:.*$/im, `pinned: ${value}`);
+    }
+    else {
+        body = `${body}\npinned: ${value}`;
+    }
+    return content.replace(FRONTMATTER_RE, `---\n${body}\n---\n`);
+}
+/** Write the skill body to a throwaway file and run the firewall scan (no install). */
+export function scanAuthoredSkillContent(content) {
+    const dir = path.join(os.tmpdir(), `cb-skillscan-${randomUUID()}`);
+    const file = path.join(dir, 'SKILL.md');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, content, 'utf-8');
+    try {
+        const report = scanSkillFirewall(file);
+        return {
+            safe: !report.quarantineRequired,
+            verdict: String(report.verdict),
+            reasons: report.quarantineRequired ? [report.summary] : [],
+        };
+    }
+    catch (err) {
+        return { safe: false, verdict: 'scan-error', reasons: [err instanceof Error ? err.message : String(err)] };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Safety re-gate over authored skill CONTENT (static scan + firewall). */
+export function safetyGateSkill(content) {
+    const scan = inspectAuthoredCode(content, 'skill');
+    if (!scan.ok)
+        return { ok: false, reasons: scan.reasons };
+    const fw = scanAuthoredSkillContent(content);
+    if (!fw.safe)
+        return { ok: false, reasons: [`firewall: ${fw.verdict}`, ...fw.reasons] };
+    return { ok: true, reasons: [] };
+}
+/** Dual-purpose mutator: the engine's port + the curation operations. */
+export class LiveSkillMutator {
+    skillsRoot;
+    constructor(skillsRoot) {
+        this.skillsRoot = skillsRoot ?? path.join(process.cwd(), '.codebuddy', 'skills');
+    }
+    /** 1 level deep so the registry's findSkillFiles (1-level) loads it. */
+    dirFor(name) {
+        return path.join(this.skillsRoot, name);
+    }
+    skillFile(name) {
+        return path.join(this.dirFor(name), 'SKILL.md');
+    }
+    reload() {
+        void getSkillRegistry().reloadAll().catch(() => { });
+    }
+    readContent(name) {
+        const f = this.skillFile(name);
+        return fs.existsSync(f) ? fs.readFileSync(f, 'utf-8') : null;
+    }
+    has(name) {
+        return fs.existsSync(this.skillFile(name));
+    }
+    isPinned(name) {
+        const c = this.readContent(name);
+        return c ? readPinned(c) : false;
+    }
+    create(spec) {
+        const dir = this.dirFor(spec.name);
+        fs.mkdirSync(dir, { recursive: true });
+        const content = ensureFrontmatter(spec.name, spec.description, spec.content);
+        fs.writeFileSync(this.skillFile(spec.name), content, 'utf-8');
+        this.reload();
+        return { name: spec.name };
+    }
+    /** Full re-author of an existing authored skill, re-gated. Refuses pinned. */
+    update(name, newContent, description = '') {
+        if (!isAuthoredSkillName(name))
+            return { ok: false, reasons: ['not an authored skill'] };
+        if (!this.has(name))
+            return { ok: false, reasons: ['skill does not exist'] };
+        if (this.isPinned(name))
+            return { ok: false, reasons: ['skill is pinned'] };
+        const withFm = ensureFrontmatter(name, description, newContent);
+        const gate = safetyGateSkill(withFm);
+        if (!gate.ok)
+            return gate;
+        fs.writeFileSync(this.skillFile(name), withFm, 'utf-8');
+        this.reload();
+        return { ok: true, reasons: [] };
+    }
+    /** Find/replace within an authored skill body (exact; fail on multiple unless replaceAll). */
+    patch(name, oldStr, newStr, opts = {}) {
+        const content = this.readContent(name);
+        if (content === null)
+            return { ok: false, reasons: ['skill does not exist'] };
+        if (this.isPinned(name))
+            return { ok: false, reasons: ['skill is pinned'] };
+        const count = content.split(oldStr).length - 1;
+        if (count === 0)
+            return { ok: false, reasons: ['old_string not found'] };
+        if (count > 1 && !opts.replaceAll) {
+            return { ok: false, reasons: [`old_string matches ${count} times — pass replaceAll or add context`] };
+        }
+        const patched = opts.replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+        return this.update(name, patched);
+    }
+    remove(name) {
+        if (this.isPinned(name))
+            return false;
+        const dir = this.dirFor(name);
+        const existed = fs.existsSync(dir);
+        if (existed)
+            fs.rmSync(dir, { recursive: true, force: true });
+        this.reload();
+        return existed;
+    }
+    /** Recoverable removal — move to .archive/. Refuses pinned. */
+    archive(name) {
+        if (this.isPinned(name))
+            return false;
+        const dir = this.dirFor(name);
+        if (!fs.existsSync(dir))
+            return false;
+        const archiveRoot = path.join(this.skillsRoot, ARCHIVE_DIR);
+        fs.mkdirSync(archiveRoot, { recursive: true });
+        let dest = path.join(archiveRoot, name);
+        if (fs.existsSync(dest))
+            dest = `${dest}-${randomUUID().slice(0, 8)}`;
+        fs.renameSync(dir, dest);
+        this.reload();
+        return true;
+    }
+    restore(name) {
+        const src = path.join(this.skillsRoot, ARCHIVE_DIR, name);
+        if (!fs.existsSync(src))
+            return false;
+        const dir = this.dirFor(name);
+        if (fs.existsSync(dir))
+            return false; // don't clobber a live skill
+        fs.renameSync(src, dir);
+        this.reload();
+        return true;
+    }
+    pin(name) {
+        return this.setPin(name, true);
+    }
+    unpin(name) {
+        return this.setPin(name, false);
+    }
+    setPin(name, value) {
+        const content = this.readContent(name);
+        if (content === null)
+            return false;
+        const withFm = ensureFrontmatter(name, '', content);
+        fs.writeFileSync(this.skillFile(name), setPinned(withFm, value), 'utf-8');
+        this.reload();
+        return true;
+    }
+    /** List installed authored skills (by the authored- prefix). */
+    listAuthored() {
+        if (!fs.existsSync(this.skillsRoot))
+            return [];
+        return fs
+            .readdirSync(this.skillsRoot, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && isAuthoredSkillName(e.name) && fs.existsSync(path.join(this.skillsRoot, e.name, 'SKILL.md')))
+            .map((e) => e.name);
+    }
+}
+//# sourceMappingURL=skill-mutator.js.map