qlogicagent 2.13.4 → 2.13.5

package/dist/orchestration/product-planner.js

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,31 @@
+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

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

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

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