@poolzin/pool-bot 2026.4.30 → 2026.4.31

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.4.30",
-  "commit": "5f9af9dece19adb17df979c3289aaaa316cc0b89",
-  "builtAt": "2026-04-04T22:23:55.184Z"
+  "version": "2026.4.31",
+  "commit": "4486adc8409ed1305aa5fee2a37117ff7cab5aab",
+  "builtAt": "2026-04-04T22:45:58.617Z"
 }

package/dist/cli/config-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-cli.d.ts","sourceRoot":"","sources":["../../src/cli/config-cli.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,eAAe,CAAC;AAyXhE,wBAAsB,YAAY,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,iBA4B9F;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,iBAqBhF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QAiOjD"}
+{"version":3,"file":"config-cli.d.ts","sourceRoot":"","sources":["../../src/cli/config-cli.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,OAAO,EAAE,KAAK,UAAU,EAAkB,MAAM,eAAe,CAAC;AA6XhE,wBAAsB,YAAY,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,iBA4B9F;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,iBAqBhF;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,QAkSjD"}

package/dist/cli/config-cli.js

@@ -6,6 +6,10 @@ import { formatDocsLink } from "../terminal/links.js";
 import { formatCliCommand } from "./command-format.js";
 import { theme } from "../terminal/theme.js";
 import { shortenHomePath } from "../utils.js";
+import { evolveSkill, findSkill } from "../infra/skill-evolution.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { callGatewayFromCli } from "./gateway-rpc.js";
+import { loadConfig } from "../config/config.js";
 function generateConfigJsonSchema() {
     return {
         $schema: "http://json-schema.org/draft-07/schema#",
@@ -633,4 +637,56 @@ export function registerConfigCli(program) {
             defaultRuntime.exit(1);
         }
     });
+    cmd
+        .command("evolve-skill")
+        .description("Evolve a skill file using LLM-based optimization (GEPA-inspired)")
+        .argument("<skill>", "Skill name or path to evolve")
+        .option("-n, --iterations <n>", "Number of optimization iterations", "5")
+        .option("--dry-run", "Show improvements without writing", false)
+        .action(async (skillName, opts) => {
+        try {
+            const cfg = loadConfig();
+            const agentId = resolveDefaultAgentId(cfg);
+            const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+            const skillsDir = `${workspaceDir}/skills`;
+            let skillPath = null;
+            // Check if it's a direct path
+            if (skillName.includes("/") || skillName.includes("\\")) {
+                skillPath = skillName;
+            }
+            else {
+                skillPath = findSkill(skillName, skillsDir);
+            }
+            if (!skillPath) {
+                defaultRuntime.error(danger(`Skill '${skillName}' not found in ${skillsDir}`));
+                defaultRuntime.exit(1);
+                return;
+            }
+            const iterations = parseInt(opts.iterations, 10) || 5;
+            const dryRun = opts.dryRun === true;
+            defaultRuntime.log(info(`Evolving skill: ${skillPath}`));
+            defaultRuntime.log(info(`Iterations: ${iterations}, Dry run: ${dryRun}`));
+            // LLM call via gateway
+            const llmCall = async (prompt, systemPrompt) => {
+                const result = await callGatewayFromCli("agent.chat", {}, {
+                    message: prompt,
+                    systemPrompt,
+                    model: cfg.agents?.defaults?.model?.primary,
+                });
+                return result?.reply ?? "";
+            };
+            const result = await evolveSkill({ skillPath, llmCall, config: { iterations, dryRun } });
+            if (result.improved && result.bestCandidate) {
+                defaultRuntime.log(info(`✅ Improved! ${result.original.name}: ${result.bestCandidate.score.toFixed(3)} (was baseline)`));
+            }
+            else {
+                defaultRuntime.log(info(`No improvement found for ${result.original.name}`));
+            }
+            defaultRuntime.exit(0);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
 }

package/dist/infra/skill-evolution.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Self-evolving skill optimizer for PoolBot.
+ *
+ * Inspired by Hermes Agent Self-Evolution (DSPy + GEPA).
+ * Uses the agent's own LLM to propose and evaluate skill improvements.
+ *
+ * Flow:
+ * 1. Load a skill file (SKILL.md or similar)
+ * 2. Generate improvement candidates via LLM
+ * 3. Evaluate candidates via LLM judge
+ * 4. Save the best candidate if it beats the baseline
+ */
+export type SkillArtifact = {
+    path: string;
+    name: string;
+    content: string;
+    size: number;
+};
+export type EvalTask = {
+    input: string;
+    expectedBehavior: string;
+};
+export type EvalResult = {
+    correctness: number;
+    procedureFollowing: number;
+    conciseness: number;
+    lengthPenalty: number;
+    feedback: string;
+};
+export type CandidateScore = {
+    variant: string;
+    score: number;
+    eval: EvalResult;
+};
+export type EvolutionConfig = {
+    /** Max iterations (default: 5) */
+    iterations?: number;
+    /** Max skill size in chars (default: 15000) */
+    maxSize?: number;
+    /** Dry run — don't write changes (default: false) */
+    dryRun?: boolean;
+};
+export type LLMCallFn = (prompt: string, systemPrompt: string) => Promise<string>;
+export declare function loadSkill(path: string): SkillArtifact;
+export declare function findSkill(skillName: string, skillsDir: string): string | null;
+export declare function generateCandidates(skill: SkillArtifact, count: number, llmCall: LLMCallFn): Promise<string[]>;
+export declare function evaluateCandidate(original: SkillArtifact, candidate: string, llmCall: LLMCallFn): Promise<EvalResult>;
+export declare function evolveSkill(params: {
+    skillPath: string;
+    llmCall: LLMCallFn;
+    config?: EvolutionConfig;
+}): Promise<{
+    original: SkillArtifact;
+    bestCandidate: CandidateScore | null;
+    improved: boolean;
+}>;
+//# sourceMappingURL=skill-evolution.d.ts.map

package/dist/infra/skill-evolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-evolution.d.ts","sourceRoot":"","sources":["../../src/infra/skill-evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAIF,MAAM,MAAM,SAAS,GAAG,CACtB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,KACjB,OAAO,CAAC,MAAM,CAAC,CAAC;AAIrB,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAOrD;AAED,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgB7E;AAoBD,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,SAAS,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB;AA6BD,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,GACjB,OAAO,CAAC,UAAU,CAAC,CAgCrB;AAUD,wBAAsB,WAAW,CAAC,MAAM,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B,GAAG,OAAO,CAAC;IACV,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC,CAiED"}

package/dist/infra/skill-evolution.js

@@ -0,0 +1,183 @@
+/**
+ * Self-evolving skill optimizer for PoolBot.
+ *
+ * Inspired by Hermes Agent Self-Evolution (DSPy + GEPA).
+ * Uses the agent's own LLM to propose and evaluate skill improvements.
+ *
+ * Flow:
+ * 1. Load a skill file (SKILL.md or similar)
+ * 2. Generate improvement candidates via LLM
+ * 3. Evaluate candidates via LLM judge
+ * 4. Save the best candidate if it beats the baseline
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("skill-evolution");
+// ── Skill Loading ──────────────────────────────────────────────────────
+export function loadSkill(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Skill file not found: ${path}`);
+    }
+    const content = readFileSync(path, "utf-8");
+    const name = path.split("/").pop()?.replace(/\.(md|txt|skill)$/, "") ?? "unknown";
+    return { path, name, content, size: content.length };
+}
+export function findSkill(skillName, skillsDir) {
+    if (!existsSync(skillsDir))
+        return null;
+    // Try exact match with common extensions
+    for (const ext of [".md", ".txt", ".skill", ""]) {
+        const candidate = join(skillsDir, `${skillName}${ext}`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    // Try subdirectory
+    const subdir = join(skillsDir, skillName);
+    if (existsSync(subdir)) {
+        for (const ext of [".md", ".txt", ".skill", ""]) {
+            const candidate = join(subdir, `SKILL${ext}`);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+// ── Candidate Generation ───────────────────────────────────────────────
+const GENERATE_VARIANTS_PROMPT = `You are an expert prompt engineer optimizing agent skill instructions.
+
+Current skill:
+\`\`\`
+{currentSkill}
+\`\`\`
+
+Generate {count} improved variants. Each variant should:
+1. Be clearer and more actionable
+2. Use specific, measurable language
+3. Include edge case handling
+4. Be concise (no unnecessary verbosity)
+5. Maintain the original skill's purpose
+
+Return ONLY the variants, numbered 1 to {count}, each wrapped in \`\`\` markers.`;
+export async function generateCandidates(skill, count, llmCall) {
+    const prompt = GENERATE_VARIANTS_PROMPT
+        .replace("{currentSkill}", skill.content)
+        .replace(/{count}/g, String(count));
+    const systemPrompt = "You are an expert prompt engineer. Generate improved skill variants. " +
+        "Return ONLY the numbered variants in code blocks. No explanations.";
+    const response = await llmCall(prompt, systemPrompt);
+    // Extract code blocks
+    const blocks = response.match(/```[\s\S]*?```/g) ?? [];
+    return blocks
+        .map((b) => b.replace(/^```[a-z]*\n?/i, "").replace(/```$/, "").trim())
+        .filter((b) => b.length > 0);
+}
+// ── Evaluation ─────────────────────────────────────────────────────────
+const EVALUATE_PROMPT = `You are an expert evaluator of agent skill instructions.
+
+Original skill:
+\`\`\`
+{originalSkill}
+\`\`\`
+
+Candidate variant:
+\`\`\`
+{candidateSkill}
+\`\`\`
+
+Evaluate the candidate on these dimensions (0.0 to 1.0 each):
+1. **correctness**: Does it cover the same ground as the original? Would it produce correct agent behavior?
+2. **clarity**: Is it clearer and less ambiguous than the original?
+3. **conciseness**: Is it appropriately concise without losing important details?
+
+Also provide a length penalty (0.0 to 1.0, where 0 = no penalty):
+- If the candidate is significantly longer than the original without proportional improvement, apply a penalty.
+
+Return your evaluation as JSON:
+{"correctness": 0.85, "clarity": 0.9, "conciseness": 0.8, "lengthPenalty": 0.1, "feedback": "Specific feedback"}
+
+Do NOT include any other text.`;
+export async function evaluateCandidate(original, candidate, llmCall) {
+    const prompt = EVALUATE_PROMPT
+        .replace("{originalSkill}", original.content)
+        .replace("{candidateSkill}", candidate);
+    const systemPrompt = "You are an expert evaluator. Score the candidate skill variant. " +
+        "Return ONLY a JSON object with correctness, clarity, conciseness, lengthPenalty, and feedback.";
+    const response = await llmCall(prompt, systemPrompt);
+    // Extract JSON
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+        log.warn("LLM judge did not return valid JSON, using fallback scores");
+        return {
+            correctness: 0.5,
+            procedureFollowing: 0.5,
+            conciseness: 0.5,
+            lengthPenalty: 0.2,
+            feedback: "LLM judge returned non-JSON response",
+        };
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+        correctness: typeof parsed.correctness === "number" ? parsed.correctness : 0.5,
+        procedureFollowing: typeof parsed.clarity === "number" ? parsed.clarity : 0.5,
+        conciseness: typeof parsed.conciseness === "number" ? parsed.conciseness : 0.5,
+        lengthPenalty: typeof parsed.lengthPenalty === "number" ? parsed.lengthPenalty : 0.0,
+        feedback: typeof parsed.feedback === "string" ? parsed.feedback : "No feedback provided",
+    };
+}
+function computeFitness(r) {
+    const raw = 0.5 * r.correctness + 0.3 * r.procedureFollowing + 0.2 * r.conciseness;
+    return Math.max(0, raw - r.lengthPenalty);
+}
+// ── Main Evolution Loop ────────────────────────────────────────────────
+export async function evolveSkill(params) {
+    const { skillPath, llmCall, config = {} } = params;
+    const iterations = config.iterations ?? 5;
+    const maxSize = config.maxSize ?? 15_000;
+    const dryRun = config.dryRun ?? false;
+    // 1. Load skill
+    const skill = loadSkill(skillPath);
+    log.info(`Evolving skill: ${skill.name} (${skill.size} chars, ${iterations} iterations)`);
+    if (skill.size > maxSize) {
+        log.warn(`Skill exceeds max size (${skill.size} > ${maxSize}), truncating for evolution`);
+    }
+    // 2. Evaluate baseline
+    const baselineEval = await evaluateCandidate(skill, skill.content, llmCall);
+    const baselineScore = computeFitness(baselineEval);
+    log.info(`Baseline fitness: ${baselineScore.toFixed(3)}`);
+    let bestCandidate = null;
+    // 3. Generate and evaluate candidates
+    for (let i = 0; i < iterations; i++) {
+        log.info(`Iteration ${i + 1}/${iterations}`);
+        const candidates = await generateCandidates(skill, 3, llmCall);
+        log.info(`Generated ${candidates.length} candidates`);
+        for (const candidate of candidates) {
+            if (candidate.length > maxSize) {
+                log.debug(`Candidate too long (${candidate.length} chars), skipping`);
+                continue;
+            }
+            const evalResult = await evaluateCandidate(skill, candidate, llmCall);
+            const score = computeFitness(evalResult);
+            if (!bestCandidate || score > bestCandidate.score) {
+                bestCandidate = { variant: candidate, score, eval: evalResult };
+                log.info(`New best: fitness=${score.toFixed(3)} (${evalResult.feedback.slice(0, 80)}...)`);
+            }
+        }
+    }
+    // 4. Check if best candidate beats baseline
+    const improved = bestCandidate !== null && bestCandidate.score > baselineScore;
+    if (improved && bestCandidate) {
+        log.info(`Improvement found! Baseline: ${baselineScore.toFixed(3)} → Best: ${bestCandidate.score.toFixed(3)} (+${((bestCandidate.score - baselineScore) * 100).toFixed(1)}%)`);
+        if (!dryRun) {
+            writeFileSync(skillPath, bestCandidate.variant, "utf-8");
+            log.info(`Skill updated: ${skillPath}`);
+        }
+        else {
+            log.info(`Dry run — would update: ${skillPath}`);
+        }
+    }
+    else {
+        log.info(`No improvement over baseline (${baselineScore.toFixed(3)})`);
+    }
+    return { original: skill, bestCandidate, improved };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.4.30",
+  "version": "2026.4.31",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",