qlogicagent 2.13.5 → 2.13.6

package/dist/orchestration/skill-improvement.js

@@ -1,243 +0,0 @@
-/**
- * Skill self-learning: decides whether a completed turn should
- * trigger skill creation or improvement instructions.
- *
- * Guards against proliferation:
- * - Project-level pattern repetition: same workflow signature must appear
- *   ≥ SKILL_PATTERN_REPETITION_THRESHOLD times before triggering creation
- * - MAX_SKILLS_PER_PROJECT: hard cap on project-level skills
- * - Dedup check: compares tool-set signature against existing skills
- * - Cooldown: prevents rapid-fire creation within a session
- */
-import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL, MIN_TOOL_CALLS_FOR_SKILL, MIN_DISTINCT_TOOLS_FOR_SKILL, SKILL_CREATION_COOLDOWN_MS, SKILL_PATTERN_REPETITION_THRESHOLD, SKILL_PATTERN_MAX_AGE_MS, } from "../runtime/config/tunable-defaults.js";
-export { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL };
-// ── Session-level cooldown state ───────────────────────────────────
-let lastSkillCreationTime = 0;
-/**
- * Reset cooldown state (for testing).
- */
-export function resetSkillCreationCooldown() {
-    lastSkillCreationTime = 0;
-}
-const PATTERN_STORE_FILENAME = "skill-patterns.json";
-function getPatternStorePath(projectRoot) {
-    return join(projectRoot, ".qlogicagent", PATTERN_STORE_FILENAME);
-}
-function loadPatternStore(projectRoot) {
-    const p = getPatternStorePath(projectRoot);
-    try {
-        return JSON.parse(readFileSync(p, "utf8"));
-    }
-    catch {
-        return { version: 1, patterns: {} };
-    }
-}
-function savePatternStore(projectRoot, store) {
-    const p = getPatternStorePath(projectRoot);
-    mkdirSync(dirname(p), { recursive: true });
-    writeFileSync(p, JSON.stringify(store, null, 2), "utf8");
-}
-/**
- * Prune patterns older than SKILL_PATTERN_MAX_AGE_MS.
- */
-function pruneStalePatterns(store) {
-    const cutoff = Date.now() - SKILL_PATTERN_MAX_AGE_MS;
-    for (const [sig, entry] of Object.entries(store.patterns)) {
-        if (new Date(entry.lastSeen).getTime() < cutoff) {
-            delete store.patterns[sig];
-        }
-    }
-}
-/**
- * Record a workflow pattern observation and return whether it has reached
- * the repetition threshold (i.e., is now eligible for skill creation).
- *
- * @returns true if the pattern just reached the threshold on this observation
- */
-export function recordPatternAndCheckThreshold(projectRoot, tools) {
-    if (tools.length === 0)
-        return false;
-    const signature = buildToolSignature(tools);
-    const store = loadPatternStore(projectRoot);
-    pruneStalePatterns(store);
-    const now = new Date().toISOString();
-    let entry = store.patterns[signature];
-    if (!entry) {
-        entry = { signature, count: 0, firstSeen: now, lastSeen: now, promoted: false };
-        store.patterns[signature] = entry;
-    }
-    // Already promoted — don't trigger again
-    if (entry.promoted) {
-        savePatternStore(projectRoot, store);
-        return false;
-    }
-    entry.count++;
-    entry.lastSeen = now;
-    const reached = entry.count >= SKILL_PATTERN_REPETITION_THRESHOLD;
-    if (reached) {
-        entry.promoted = true;
-    }
-    savePatternStore(projectRoot, store);
-    return reached;
-}
-/**
- * Mark a pattern as promoted (skill already created for it).
- * Called when a skill is created through other paths (e.g., manual).
- */
-export function markPatternPromoted(projectRoot, tools) {
-    if (tools.length === 0)
-        return;
-    const signature = buildToolSignature(tools);
-    const store = loadPatternStore(projectRoot);
-    const entry = store.patterns[signature];
-    if (entry) {
-        entry.promoted = true;
-        savePatternStore(projectRoot, store);
-    }
-}
-/**
- * Get all tracked patterns for a project. Useful for diagnostics.
- */
-export function getPatternStats(projectRoot) {
-    const store = loadPatternStore(projectRoot);
-    return Object.values(store.patterns);
-}
-// ── Dedup logic ────────────────────────────────────────────────────
-/**
- * Build a normalized "tool signature" from sorted tool names.
- * Used for dedup — if an existing skill has the same tool signature,
- * we skip creation.
- */
-export function buildToolSignature(tools) {
-    return [...tools].sort().join("+");
-}
-/**
- * Check if an existing skill in skillsDir already covers the same tool set.
- * Returns the name of the conflicting skill, or null if none found.
- */
-export function findDuplicateSkill(tools, skillsDir) {
-    if (!existsSync(skillsDir))
-        return null;
-    const signature = buildToolSignature(tools);
-    try {
-        const entries = readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const skillMd = join(skillsDir, entry.name, "SKILL.md");
-            try {
-                const content = readFileSync(skillMd, "utf8");
-                // Extract tools from frontmatter: tools:\n  - tool1\n  - tool2
-                const toolsMatch = content.match(/^tools:\s*\n((?:\s+-\s+\S+\n?)+)/m);
-                if (toolsMatch) {
-                    const existingTools = toolsMatch[1]
-                        .split("\n")
-                        .map(l => l.replace(/^\s*-\s*/, "").trim())
-                        .filter(Boolean);
-                    if (buildToolSignature(existingTools) === signature) {
-                        return entry.name;
-                    }
-                }
-            }
-            catch { /* unreadable skill */ }
-        }
-    }
-    catch { /* dir unreadable */ }
-    return null;
-}
-/**
- * Count active skills in a directory.
- */
-export function countSkillsInDir(skillsDir) {
-    if (!existsSync(skillsDir))
-        return 0;
-    try {
-        return readdirSync(skillsDir, { withFileTypes: true })
-            .filter(e => e.isDirectory() && existsSync(join(skillsDir, e.name, "SKILL.md")))
-            .length;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Determine whether a completed turn should produce a skill instruction.
- *
- * A new skill is suggested when:
- * - The turn succeeded
- * - It involved multi-step orchestration
- * - It used ≥3 tool calls across ≥2 distinct tools
- * - No existing skill was already applied
- * - Cooldown has elapsed since last skill creation
- * - No duplicate skill exists (same tool signature)
- * - Project skill count < MAX_SKILLS_PER_PROJECT
- * - **Pattern repetition threshold reached** (≥3 occurrences at project level)
- */
-export function shouldCreateSkill(result, context) {
-    if (!result.ok)
-        return false;
-    if (result.existingSkillName)
-        return false;
-    if (!result.multiStep)
-        return false;
-    if (result.toolCallCount < MIN_TOOL_CALLS_FOR_SKILL)
-        return false;
-    if (result.distinctToolCount < MIN_DISTINCT_TOOLS_FOR_SKILL)
-        return false;
-    // Cooldown guard
-    const now = Date.now();
-    if (now - lastSkillCreationTime < SKILL_CREATION_COOLDOWN_MS)
-        return false;
-    // Proliferation guards (only if context provided)
-    if (context?.projectSkillsDir) {
-        // Max limit check
-        const count = countSkillsInDir(context.projectSkillsDir);
-        if (count >= MAX_SKILLS_PER_PROJECT)
-            return false;
-        // Dedup check
-        if (context.tools.length > 0) {
-            const dupe = findDuplicateSkill(context.tools, context.projectSkillsDir);
-            if (dupe)
-                return false;
-        }
-    }
-    // Project-level pattern repetition gate:
-    // Record this pattern and only allow creation if threshold is met.
-    if (context?.projectRoot && context.tools.length > 0) {
-        const thresholdReached = recordPatternAndCheckThreshold(context.projectRoot, context.tools);
-        if (!thresholdReached)
-            return false;
-    }
-    return true;
-}
-export function shouldImproveSkill(result) {
-    if (!result.existingSkillName)
-        return false;
-    return result.feedback === "negative";
-}
-/**
- * Build a skill instruction from a turn result, or null if none is warranted.
- * Updates cooldown timestamp on success.
- */
-export function buildSkillInstruction(result, context) {
-    if (shouldImproveSkill(result)) {
-        return {
-            type: "skill.improve",
-            skillName: result.existingSkillName,
-            reason: "negative user feedback on existing skill execution",
-        };
-    }
-    if (shouldCreateSkill(result, context)) {
-        lastSkillCreationTime = Date.now();
-        return {
-            type: "skill.create",
-            suggestedName: context.suggestedName ?? `auto-skill-${context.tools.slice(0, 3).join("-")}`,
-            description: `Multi-step orchestration using ${context.tools.join(", ")}`,
-            tools: context.tools,
-            stepCount: result.toolCallCount,
-        };
-    }
-    return null;
-}

package/dist/orchestration/solo-evaluator.d.ts

@@ -1,124 +0,0 @@
-/**
- * Solo Mode Evaluator — parallel N-agent PK with user-triggered evaluation.
- *
- * Flow:
- *   1. solo.start → create N isolated git worktrees, spawn N agents in parallel
- *   2. Each agent receives the same task prompt in its own worktree
- *      (all agents share initial config: memory/rules from project .qlogicagent/)
- *   3. On completion of initial task, agents enter "idle" state (process kept alive)
- *   4. User can send follow-up messages to individual agents via solo.message
- *   5. User triggers evaluation via solo.evaluate (or skips directly to solo.select)
- *   6. solo.select → merge winning worktree, clean up others
- *
- * Key design:
- *   - Solo = special project type (persisted in .qlogicagent/solos/)
- *   - Agents share the same initial config but operate in isolated worktrees
- *   - User controls the evaluation timing (not automatic)
- *   - Follow-up instructions to individual agents supported
- *
- * Degradation: if K agents fail but ≥1 succeeds, session remains interactive.
- */
-import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
-import type { AcpDetector } from "../runtime/infra/acp-detector.js";
-import type { AgentConfigStore } from "../runtime/infra/agent-config-store.js";
-import type { SoloState, SoloAgentState, SoloEvaluation, SoloStatus, SoloStartParams, SoloSelectParams, SoloSpec } from "../protocol/wire/acp-agent-management.js";
-export interface SoloCallbacks {
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-        debug?(msg: string): void;
-    };
-    onProgress?: (soloId: string, agentId: string, state: SoloAgentState, progress?: string) => void;
-    onEvaluation?: (soloId: string, evaluation: SoloEvaluation) => void;
-    /** Streaming text delta from a competing agent (forwarded from child process). */
-    onAgentDelta?: (soloId: string, agentId: string, text: string) => void;
-    /** File diff produced by a completed agent. */
-    onAgentDiff?: (soloId: string, agentId: string, files: {
-        path: string;
-        hunks: string;
-    }[]) => void;
-    /** Token usage report after agent completes. */
-    onAgentUsage?: (soloId: string, agentId: string, inputTokens: number, outputTokens: number) => void;
-    /**
-     * Race reached a terminal state WITHOUT an evaluation winner (all agents failed, or cancelled).
-     * The success path uses onEvaluation; this lets the host write back the plan project's planStatus
-     * (failed/cancelled) so 历史方案 is correct and recovery doesn't restore a dead run.
-     */
-    onTerminal?: (soloId: string, state: SoloState) => void;
-}
-/**
- * Assemble the prompt every competitor receives (Cut4). Shared context (rules/memory) + optional
- * <spec> block, then the body. Body = spec.rawTask when a Spec was built (the task captured during
- * specBuild), else the raw task. With neither sharedConfig nor spec the result is exactly `task`
- * (regression-safe vs the pre-Spec path).
- */
-export declare function buildEnrichedTask(task: string, sharedConfig: {
-    memory?: string[];
-    rules?: string[];
-    model?: string;
-} | undefined, spec: SoloSpec | undefined): string;
-/**
- * Build the judge prompt (Cut4). When the Spec defines acceptance criteria, the judge scores
- * per-criterion (满足/部分/不满足) instead of a subjective compare. The WINNER:/REASONING: output
- * markers are unchanged so parseEvaluationResponse still works — only the basis of REASONING upgrades.
- */
-export declare function buildEvaluationPrompt(originalTask: string, spec: SoloSpec | undefined, succeeded: ReadonlyArray<{
-    displayId: string;
-    resultText?: string;
-    diff?: string;
-}>): string;
-export declare class SoloEvaluator {
-    private processManager;
-    private acpDetector;
-    private configStore;
-    private callbacks;
-    private sessions;
-    constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: SoloCallbacks);
-    /** Persist current session data to disk (fire-and-forget). */
-    private persistSession;
-    /** Restore sessions from disk (call once at startup). */
-    restoreFromDisk(cwd?: string): Promise<number>;
-    /** Delete a solo session from memory and disk. */
-    deleteSolo(soloId: string): Promise<boolean>;
-    /**
-     * Start a Solo Mode PK session.
-     * Creates worktrees, spawns agents in parallel, waits for completion, then evaluates.
-     */
-    start(params: SoloStartParams): Promise<string>;
-    /**
-     * Send a follow-up message to a specific agent within a solo session.
-     * Agent must be in "idle" or "completed" state.
-     */
-    message(soloId: string, agentId: string, content: string, agentIndex?: number): Promise<{
-        resultText: string;
-    }>;
-    /**
-     * User-triggered evaluation — compare all completed/idle agents' results.
-     * The user chooses which agent in the session performs the evaluation comparison.
-     */
-    triggerEvaluation(soloId: string, evaluatorAgentId: string, evaluatorIndex?: number): Promise<SoloEvaluation>;
-    /** Map a spawned member back to its solo run + UI column id (for live delta forwarding). */
-    getMemberContext(memberId: string): {
-        soloId: string;
-        displayId: string;
-    } | null;
-    /** Get the current status of a solo session. */
-    getStatus(soloId: string): SoloStatus | null;
-    /** Cancel a running solo session. Kill all agents and clean up worktrees. */
-    cancel(soloId: string): Promise<void>;
-    /**
-     * Select a winner and merge their worktree into the main branch.
-     */
-    select(params: SoloSelectParams): Promise<string>;
-    /** List all solo sessions. */
-    listSessions(): SoloStatus[];
-    /** Delete a solo session, killing agents and cleaning up worktrees if still active. */
-    delete(soloId: string): Promise<void>;
-    /**
-     * Build an evaluation prompt and send to the user-chosen evaluator agent.
-     * Returns evaluation result.
-     */
-    private evaluate;
-    private parseEvaluationResponse;
-    private cleanupWorktrees;
-}