qlogicagent 2.13.5 → 2.13.7

package/dist/orchestration/product-planner.js

@@ -1,379 +0,0 @@
-/**
- * Product Planner — Interactive multi-turn planning + persistent leader management.
- *
- * Architecture (aligned with CrewAI hierarchical + LangGraph durable execution):
- *
- * Phase 1 — PLANNING (multi-turn dialogue):
- *   1. product.plan → spawn leader agent → leader engages user in multi-turn dialogue
- *   2. Leader asks clarifying questions, proposes module decomposition
- *   3. User responds via product.message → leader refines plan
- *   4. Leader outputs structured plan → client presents to user
- *
- * Phase 2 — CONFIRMATION:
- *   5. product.confirm → user confirms/modifies plan → transition to execution
- *
- * Phase 3 — EXECUTION (leader as persistent manager):
- *   6. Leader manages DAG: dispatches tasks, monitors, handles failures
- *   7. Leader can dynamically mutate DAG: add/retry/reassign tasks
- *   8. User can intervene via product.message at any time
- *   9. Each state transition is checkpointed for crash recovery
- *
- * Key mechanisms from reference projects:
- *   - CrewAI: hierarchical process (manager auto-delegates/verifies)
- *   - CrewAI: checkpoint serialization (mid-task state)
- *   - LangGraph: durable execution (persist after each node)
- */
-import { randomUUID } from "node:crypto";
-// ── Planning Prompts ────────────────────────────────────────
-function buildInitialPlanningPrompt(goal, budget) {
-    const budgetNote = budget
-        ? `\n\nBudget constraints: ${budget.maxTotalTokens ? `max ${budget.maxTotalTokens} total tokens` : ""}${budget.maxDuration ? ` / max ${Math.round(budget.maxDuration / 60000)} minutes` : ""}`
-        : "";
-    return `You are a team leader agent managing a software development project.
-
-## Project Goal
-${goal}
-${budgetNote}
-
-## Your Role
-You are in the PLANNING phase. Engage the user in dialogue to:
-1. Understand the project requirements in detail
-2. Ask clarifying questions about scope, priorities, constraints
-3. Propose a module decomposition (数值/美术/程序/剧情/前端/后端 etc.)
-4. Once the user is satisfied, output the final structured plan
-
-## Conversation Guidelines
-- Ask ONE focused question at a time (don't overwhelm the user)
-- After 2-3 rounds of clarification, propose a high-level module breakdown
-- Once user confirms the breakdown, output the detailed execution plan
-
-When you're ready to output the final plan, use this EXACT JSON schema wrapped in a \`\`\`json code block:
-
-{
-  "name": "<project name>",
-  "modules": [{"name": "...", "description": "...", "suggestedAgentId": "..."}],
-  "instances": [{"name": "...", "agentId": "...", "role": "..."}],
-  "tasks": [{"taskId": "...", "assignee": "...", "prompt": "...", "dependsOn": ["..."]}],
-  "reasoning": "<decomposition strategy explanation>"
-}
-
-Start by greeting the user and asking your first clarifying question about the project.`;
-}
-function buildFollowUpPrompt(dialogue, userMessage) {
-    const history = dialogue.map(m => `[${m.role}]: ${m.content}`).join("\n\n");
-    return `${history}\n\n[user]: ${userMessage}\n\nContinue the planning conversation. If you have enough information, output the final structured plan in a \`\`\`json code block. Otherwise, ask your next clarifying question.`;
-}
-function buildExecutionManagementPrompt(context) {
-    let prompt = `You are the team leader agent in EXECUTION phase.
-
-## Current Progress
-- Total tasks: ${context.progress.total}
-- Completed: ${context.progress.completed}
-- Running: ${context.progress.running}
-- Failed: ${context.progress.failed}
-`;
-    if (context.failedTasks?.length) {
-        prompt += `\n## Failed Tasks (need your decision)\n`;
-        for (const ft of context.failedTasks) {
-            prompt += `- ${ft.taskId}: ${ft.error}\n`;
-        }
-        prompt += `\nFor each failed task, decide: retry (with refined prompt), reassign, add prerequisite tasks, or skip.\n`;
-    }
-    if (context.userMessage) {
-        prompt += `\n## User Message\nThe user says: "${context.userMessage}"\nRespond to the user and take appropriate action.\n`;
-    }
-    prompt += `\n## Available Actions (output as JSON)
-To mutate the DAG, output a \`\`\`json block with an array of mutations:
-[
-  {"type": "retry_task", "taskId": "...", "newPrompt": "..."},
-  {"type": "add_task", "task": {"taskId": "...", "assignee": "...", "prompt": "...", "dependsOn": [...]}},
-  {"type": "reassign_task", "taskId": "...", "newAssignee": "..."},
-  {"type": "remove_task", "taskId": "..."},
-  {"type": "update_prompt", "taskId": "...", "prompt": "..."}
-]
-
-If no action needed, just respond with a progress update message to the user.`;
-    return prompt;
-}
-// ── Product Planner ─────────────────────────────────────────
-export class ProductPlanner {
-    processManager;
-    acpDetector;
-    configStore;
-    callbacks;
-    sessions = new Map();
-    constructor(processManager, acpDetector, configStore, callbacks = {}) {
-        this.processManager = processManager;
-        this.acpDetector = acpDetector;
-        this.configStore = configStore;
-        this.callbacks = callbacks;
-    }
-    /**
-     * Start an interactive planning session (Phase 1).
-     * Spawns the leader agent and begins multi-turn dialogue.
-     */
-    async plan(params) {
-        const { goal, cwd, leaderAgentId, name, budget } = params;
-        const productId = `product-${randomUUID().slice(0, 8)}`;
-        const session = {
-            productId,
-            goal,
-            cwd,
-            leaderAgentId,
-            phase: "planning",
-            dialogue: [],
-            budget,
-            createdAt: new Date().toISOString(),
-        };
-        this.sessions.set(productId, session);
-        this.callbacks.log?.info(`[planner] started planning ${productId} with leader=${leaderAgentId}`);
-        // Spawn leader and get initial response
-        const response = await this.sendToLeader(session, buildInitialPlanningPrompt(goal, budget));
-        session.dialogue.push({
-            role: "leader",
-            content: response,
-            timestamp: new Date().toISOString(),
-        });
-        // Check if leader produced a plan in the first response (small projects)
-        const plan = this.tryParsePlan(response, session);
-        if (plan) {
-            session.plan = plan;
-            session.phase = "awaiting_confirmation";
-            if (name)
-                plan.name = name;
-            this.callbacks.onPlanReady?.(productId, plan);
-            return { productId, plan };
-        }
-        // Leader wants multi-turn dialogue — emit the message to user
-        this.callbacks.onLeaderMessage?.(productId, response);
-        this.callbacks.onPlanningDelta?.(productId, response);
-        // Return a placeholder plan signalling "in dialogue"
-        const pendingPlan = {
-            name: name ?? goal.slice(0, 50),
-            modules: [],
-            instances: [],
-            tasks: [],
-            reasoning: "Planning in progress — leader is asking clarifying questions. Use product.message to respond.",
-        };
-        return { productId, plan: pendingPlan };
-    }
-    /**
-     * Send a user message to the leader (works in planning and execution phases).
-     * Returns the leader's response and optionally a finalized plan.
-     */
-    async message(productId, content) {
-        const session = this.sessions.get(productId);
-        if (!session)
-            throw new Error(`Session ${productId} not found`);
-        session.dialogue.push({
-            role: "user",
-            content,
-            timestamp: new Date().toISOString(),
-        });
-        if (session.phase === "planning") {
-            return this.handlePlanningMessage(session, content);
-        }
-        else if (session.phase === "executing" || session.phase === "paused") {
-            return this.handleExecutionMessage(session, content);
-        }
-        else if (session.phase === "awaiting_confirmation") {
-            // User can still chat during confirmation phase (e.g. ask questions about plan)
-            return this.handlePlanningMessage(session, content);
-        }
-        else {
-            throw new Error(`Cannot message in phase "${session.phase}"`);
-        }
-    }
-    /**
-     * Confirm the plan → transition to execution (Phase 2 → Phase 3).
-     */
-    async confirm(params) {
-        const session = this.sessions.get(params.productId);
-        if (!session)
-            throw new Error(`Planning session ${params.productId} not found`);
-        if (session.phase !== "awaiting_confirmation") {
-            throw new Error(`Session ${params.productId} is in phase "${session.phase}", not "awaiting_confirmation"`);
-        }
-        session.phase = "confirmed";
-        session.lastCheckpoint = new Date().toISOString();
-        this.callbacks.log?.info(`[planner] confirmed ${params.productId}: ${params.instances.length} instances, ${params.tasks.length} tasks`);
-        return { productId: params.productId, ok: true };
-    }
-    /** Transition session to executing phase. Called after ProductOrchestrator.create(). */
-    markExecuting(productId) {
-        const session = this.sessions.get(productId);
-        if (session) {
-            session.phase = "executing";
-            session.lastCheckpoint = new Date().toISOString();
-        }
-    }
-    /** Mark as completed. */
-    markCompleted(productId) {
-        const session = this.sessions.get(productId);
-        if (session)
-            session.phase = "completed";
-    }
-    /** Get planning session by ID. */
-    getSession(productId) {
-        return this.sessions.get(productId);
-    }
-    /** Cancel and kill leader process. */
-    async cancel(productId) {
-        const session = this.sessions.get(productId);
-        if (!session)
-            return;
-        session.phase = "cancelled";
-        if (session.leaderMemberId) {
-            try {
-                await this.processManager.kill(session.leaderMemberId);
-            }
-            catch { /* ignore */ }
-        }
-        this.sessions.delete(productId);
-    }
-    /** List active sessions. */
-    listSessions() {
-        return [...this.sessions.values()];
-    }
-    /**
-     * Ask leader to evaluate execution state and propose DAG mutations.
-     * Called by ProductOrchestrator when tasks fail or progress stalls.
-     */
-    async consultLeader(productId, context) {
-        const session = this.sessions.get(productId);
-        if (!session)
-            return [];
-        const prompt = buildExecutionManagementPrompt(context);
-        const response = await this.sendToLeader(session, prompt);
-        session.dialogue.push({
-            role: "leader",
-            content: response,
-            timestamp: new Date().toISOString(),
-        });
-        return this.parseDagMutations(response);
-    }
-    /**
-     * Serialize session for checkpoint persistence (durable execution).
-     */
-    serializeSession(productId) {
-        return this.sessions.get(productId) ?? null;
-    }
-    /**
-     * Restore session from checkpoint (crash recovery).
-     */
-    restoreSession(data) {
-        this.sessions.set(data.productId, data);
-        // Note: leader process must be re-spawned on next sendToLeader call
-        data.leaderMemberId = undefined;
-    }
-    // ── Private ─────────────────────────────────────────────
-    async handlePlanningMessage(session, content) {
-        const prompt = buildFollowUpPrompt(session.dialogue.slice(0, -1), content);
-        const response = await this.sendToLeader(session, prompt);
-        session.dialogue.push({
-            role: "leader",
-            content: response,
-            timestamp: new Date().toISOString(),
-        });
-        const plan = this.tryParsePlan(response, session);
-        if (plan) {
-            session.plan = plan;
-            session.phase = "awaiting_confirmation";
-            this.callbacks.onPlanReady?.(session.productId, plan);
-            return { response, plan };
-        }
-        this.callbacks.onLeaderMessage?.(session.productId, response);
-        return { response };
-    }
-    async handleExecutionMessage(session, content) {
-        const prompt = buildExecutionManagementPrompt({
-            progress: { total: 0, completed: 0, running: 0, failed: 0 },
-            userMessage: content,
-        });
-        const response = await this.sendToLeader(session, prompt);
-        session.dialogue.push({
-            role: "leader",
-            content: response,
-            timestamp: new Date().toISOString(),
-        });
-        const mutations = this.parseDagMutations(response);
-        for (const m of mutations) {
-            this.callbacks.onDagMutated?.(session.productId, m);
-        }
-        return { response, mutations: mutations.length > 0 ? mutations : undefined };
-    }
-    async sendToLeader(session, prompt) {
-        // Ensure leader is spawned (re-spawn after crash recovery)
-        if (!session.leaderMemberId) {
-            const memberId = `${session.productId}:leader`;
-            const descriptor = this.acpDetector.buildExternalDescriptor(session.leaderAgentId);
-            if (!descriptor) {
-                throw new Error(`Leader agent ${session.leaderAgentId} is not available`);
-            }
-            await this.processManager.spawn({
-                memberId,
-                name: "product-leader",
-                cwd: session.cwd,
-                prompt,
-                external: descriptor,
-            });
-            session.leaderMemberId = memberId;
-        }
-        const response = await this.processManager.sendTask(session.leaderMemberId, prompt);
-        return typeof response === "string" ? response : JSON.stringify(response);
-    }
-    tryParsePlan(response, session) {
-        const fenceMatch = response.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
-        if (!fenceMatch)
-            return null;
-        try {
-            const parsed = JSON.parse(fenceMatch[1]);
-            if (!parsed.name || !Array.isArray(parsed.tasks) || parsed.tasks.length === 0) {
-                return null;
-            }
-            return {
-                name: parsed.name,
-                modules: (parsed.modules ?? []).map((m) => ({
-                    name: String(m.name ?? ""),
-                    description: String(m.description ?? ""),
-                    suggestedAgentId: m.suggestedAgentId ? String(m.suggestedAgentId) : undefined,
-                })),
-                instances: (parsed.instances ?? []).map((i) => ({
-                    name: String(i.name ?? ""),
-                    agentId: String(i.agentId ?? session.leaderAgentId),
-                    role: String(i.role ?? i.description ?? ""),
-                })),
-                tasks: parsed.tasks.map((t) => ({
-                    taskId: String(t.taskId ?? `task-${randomUUID().slice(0, 6)}`),
-                    assignee: String(t.assignee ?? ""),
-                    prompt: String(t.description ?? t.prompt ?? ""),
-                    dependsOn: Array.isArray(t.dependsOn) ? t.dependsOn.map(String) : undefined,
-                })),
-                reasoning: String(parsed.reasoning ?? ""),
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    parseDagMutations(response) {
-        const fenceMatch = response.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
-        if (!fenceMatch)
-            return [];
-        try {
-            const parsed = JSON.parse(fenceMatch[1]);
-            if (!Array.isArray(parsed))
-                return [];
-            return parsed
-                .filter((m) => m.type)
-                .map((m) => ({
-                type: String(m.type),
-                taskId: String(m.taskId ?? m.task?.taskId ?? ""),
-                details: m,
-            }));
-        }
-        catch {
-            return [];
-        }
-    }
-}

package/dist/orchestration/product-run-coordinator.d.ts

@@ -1,31 +0,0 @@
-import type { ProductConfirmParams, ProductPlan } from "../protocol/wire/acp-agent-management.js";
-import type { ProductOrchestrator } from "./agent-instance.js";
-import type { DagMutation, ProductPlanner } from "./product-planner.js";
-export interface ProductLeaderCoordinator {
-    consultLeader(productId: string, context: {
-        progress: {
-            total: number;
-            completed: number;
-            running: number;
-            failed: number;
-        };
-        failedTasks?: Array<{
-            taskId: string;
-            error: string;
-        }>;
-    }): Promise<DagMutation[]>;
-}
-export declare class ProductRunCoordinator {
-    private planner;
-    private orchestrator;
-    constructor(planner: ProductPlanner, orchestrator: ProductOrchestrator);
-    confirmAndStart(params: ProductConfirmParams): Promise<{
-        productId: string;
-        ok: true;
-    }>;
-    message(productId: string, content: string): Promise<{
-        response: string;
-        plan?: ProductPlan;
-        mutations?: DagMutation[];
-    }>;
-}

package/dist/orchestration/product-run-coordinator.js

@@ -1,31 +0,0 @@
-export class ProductRunCoordinator {
-    planner;
-    orchestrator;
-    constructor(planner, orchestrator) {
-        this.planner = planner;
-        this.orchestrator = orchestrator;
-    }
-    async confirmAndStart(params) {
-        const confirmResult = await this.planner.confirm(params);
-        const session = this.planner.getSession(params.productId);
-        if (!session)
-            return confirmResult;
-        await this.orchestrator.create({
-            productId: params.productId,
-            name: session.plan?.name ?? session.goal.slice(0, 50),
-            cwd: session.cwd,
-            instances: params.instances,
-            tasks: params.tasks,
-            budget: params.budget,
-        });
-        this.planner.markExecuting(params.productId);
-        return confirmResult;
-    }
-    async message(productId, content) {
-        const result = await this.planner.message(productId, content);
-        if (result.mutations?.length) {
-            this.orchestrator.applyDagMutations(productId, result.mutations);
-        }
-        return result;
-    }
-}

package/dist/orchestration/product-worktree.d.ts

@@ -1,12 +0,0 @@
-/**
- * Product Worktree — shared git worktree helpers for Solo and Product Mode.
- */
-/** Find the git repository root from a working directory. */
-export declare function findGitRoot(cwd: string): Promise<string | null>;
-/** Create an isolated git worktree. Returns the worktree path. */
-export declare function createWorktree(gitRoot: string, name: string, baseBranch?: string): Promise<string>;
-export declare function getWorktreeDiff(worktreePath: string): Promise<string>;
-/** Remove a git worktree. */
-export declare function removeWorktree(gitRoot: string, path: string): Promise<void>;
-/** Merge a worktree branch into the current branch. */
-export declare function mergeWorktree(gitRoot: string, worktreeBranch: string): Promise<string>;

package/dist/orchestration/product-worktree.js

@@ -1,69 +0,0 @@
-/**
- * Product Worktree — shared git worktree helpers for Solo and Product Mode.
- */
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { join } from "node:path";
-import { mkdir, rm } from "node:fs/promises";
-const execFileAsync = promisify(execFile);
-/** Find the git repository root from a working directory. */
-export async function findGitRoot(cwd) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" });
-        return stdout.trim();
-    }
-    catch {
-        return null;
-    }
-}
-/** Create an isolated git worktree. Returns the worktree path. */
-export async function createWorktree(gitRoot, name, baseBranch) {
-    const worktreeDir = join(gitRoot, ".worktrees");
-    await mkdir(worktreeDir, { recursive: true });
-    const path = join(worktreeDir, name);
-    const branch = `solo/${name}`;
-    const args = ["worktree", "add", "-B", branch, path];
-    if (baseBranch)
-        args.push(baseBranch);
-    else
-        args.push("HEAD");
-    await execFileAsync("git", args, { cwd: gitRoot, encoding: "utf8" });
-    return path;
-}
-/** Get the full unified diff from a worktree (staged + untracked), so the UI/evaluator see the
- *  actual line changes — not just a --stat summary. Capped to keep the UI + eval prompt bounded. */
-const MAX_DIFF_CHARS = 20_000;
-export async function getWorktreeDiff(worktreePath) {
-    try {
-        // Stage everything (incl. new/untracked files) so `git diff --cached` captures all changes.
-        await execFileAsync("git", ["add", "-A"], { cwd: worktreePath });
-        const { stdout } = await execFileAsync("git", ["diff", "--cached"], { cwd: worktreePath, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-        const diff = stdout.trimEnd();
-        return diff.length > MAX_DIFF_CHARS
-            ? `${diff.slice(0, MAX_DIFF_CHARS)}\n\n… (diff truncated at ${MAX_DIFF_CHARS} chars)`
-            : diff;
-    }
-    catch {
-        return "";
-    }
-}
-/** Remove a git worktree. */
-export async function removeWorktree(gitRoot, path) {
-    try {
-        await execFileAsync("git", ["worktree", "remove", "--force", path], {
-            cwd: gitRoot,
-            encoding: "utf8",
-        });
-    }
-    catch {
-        try {
-            await rm(path, { recursive: true, force: true });
-        }
-        catch { /* best effort */ }
-    }
-}
-/** Merge a worktree branch into the current branch. */
-export async function mergeWorktree(gitRoot, worktreeBranch) {
-    const { stdout } = await execFileAsync("git", ["merge", "--no-ff", worktreeBranch, "-m", `solo: merge ${worktreeBranch}`], { cwd: gitRoot, encoding: "utf8" });
-    return stdout.trim();
-}

package/dist/orchestration/skill-improvement.d.ts

@@ -1,129 +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 { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL } from "../runtime/config/tunable-defaults.js";
-export { MAX_SKILLS_PER_PROJECT, MAX_SKILLS_GLOBAL };
-export interface SkillTurnResult {
-    ok: boolean;
-    /** Number of tool invocations in this turn */
-    toolCallCount: number;
-    /** Number of distinct tool names used */
-    distinctToolCount: number;
-    /** Was a multi-step orchestration (≥2 rounds) used? */
-    multiStep: boolean;
-    /** Did the turn involve a sub-agent fork? */
-    hasSubAgent: boolean;
-    /** Optional user feedback signal (positive/negative/none) */
-    feedback?: "positive" | "negative" | null;
-    /** Skill name if an existing skill was used */
-    existingSkillName?: string | null;
-}
-export interface SkillCreateInstruction {
-    type: "skill.create";
-    /** Suggested skill name derived from tool usage pattern */
-    suggestedName: string;
-    /** Short description of what the skill does */
-    description: string;
-    /** Tool names involved */
-    tools: string[];
-    /** Number of orchestration steps */
-    stepCount: number;
-}
-export interface SkillImproveInstruction {
-    type: "skill.improve";
-    /** Existing skill to improve */
-    skillName: string;
-    /** Reason for improvement */
-    reason: string;
-}
-export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
-/**
- * Reset cooldown state (for testing).
- */
-export declare function resetSkillCreationCooldown(): void;
-interface PatternEntry {
-    /** Sorted tool signature (e.g. "bash+file_read+file_write") */
-    signature: string;
-    /** Number of times this pattern has been observed */
-    count: number;
-    /** First seen timestamp (ISO) */
-    firstSeen: string;
-    /** Last seen timestamp (ISO) */
-    lastSeen: string;
-    /** Whether a skill has already been created for this pattern */
-    promoted: boolean;
-}
-/**
- * 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 declare function recordPatternAndCheckThreshold(projectRoot: string, tools: string[]): boolean;
-/**
- * Mark a pattern as promoted (skill already created for it).
- * Called when a skill is created through other paths (e.g., manual).
- */
-export declare function markPatternPromoted(projectRoot: string, tools: string[]): void;
-/**
- * Get all tracked patterns for a project. Useful for diagnostics.
- */
-export declare function getPatternStats(projectRoot: string): PatternEntry[];
-/**
- * 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 declare function buildToolSignature(tools: string[]): string;
-/**
- * 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 declare function findDuplicateSkill(tools: string[], skillsDir: string): string | null;
-/**
- * Count active skills in a directory.
- */
-export declare function countSkillsInDir(skillsDir: string): number;
-/**
- * Context for proliferation checks.
- */
-export interface SkillCreationContext {
-    /** Project-level skills directory */
-    projectSkillsDir?: string;
-    /** User-level (global) skills directory */
-    globalSkillsDir?: string;
-    /** Tool names used in this turn */
-    tools: string[];
-    /** Optional suggested name */
-    suggestedName?: string;
-    /** Project root directory (required for pattern tracking) */
-    projectRoot?: string;
-}
-/**
- * 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 declare function shouldCreateSkill(result: SkillTurnResult, context?: SkillCreationContext): boolean;
-export declare function shouldImproveSkill(result: SkillTurnResult): boolean;
-/**
- * Build a skill instruction from a turn result, or null if none is warranted.
- * Updates cooldown timestamp on success.
- */
-export declare function buildSkillInstruction(result: SkillTurnResult, context: SkillCreationContext): SkillInstruction | null;