qlogicagent 2.13.3 → 2.13.5

package/dist/orchestration/skill-improvement.js

@@ -0,0 +1,243 @@
+/**
+ * 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

@@ -0,0 +1,124 @@
+/**
+ * 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;
+}