qlogicagent 2.6.1 → 2.9.0

package/dist/types/config/config.d.ts

@@ -12,6 +12,6 @@ export interface AgentConfig {
  * Parse CLI arguments into AgentConfig.
  *
  * Supports:
- *   --verbose / -v   Enable verbose logging
+ *  verbose / -v   Enable verbose logging
  */
 export declare function parseCliArgs(argv: string[]): AgentConfig;

package/dist/types/index.d.ts

@@ -10,7 +10,7 @@ export type { AgentConfig } from "./config/config.js";
 export type { Transport } from "./cli/transport.js";
 export { StdioTransport } from "./cli/transport.js";
 export { StdioServer, type StdioServerConfig } from "./cli/stdio-server.js";
-export { ProviderRegistry, createLLMClient, } from "./llm/index.js";
-export type { LLMTransport, LLMRequest, LLMChunk } from "./llm/index.js";
+export { ProviderRegistry, createLLMClient, } from "@qlogic/provider-core";
+export type { LLMTransport, LLMRequest, LLMChunk } from "@qlogic/provider-core";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";
 export { buildSkillInstruction, } from "./orchestration/index.js";

package/dist/types/llm/index.d.ts

@@ -1,31 +1 @@
-/**
- * LLM Provider layer — public API surface.
- *
- * Provides: ProviderDef + LLMTransport + ProviderRegistry + LLMClient factory
- */
-export type { ProviderDef, ModelInfo, TransportType, AuthType, MediaCapability, MediaCapabilities, VideoCapabilities, ImageCapabilities, MusicCapabilities, TtsCapabilities, ThreeDCapabilities, SttCapabilities, EmbeddingCapabilities, VideoUnderstandingCapabilities, ImageUnderstandingCapabilities, VoiceCloneCapabilities, RerankCapabilities, DocumentParsingCapabilities, RealtimeAudioCapabilities, VideoOperation, ImageOperation, MusicOperation, TtsOperation, ThreeDOperation } from "./provider-def.js";
-export type { LLMTransport, LLMRequest, LLMChunk, AccumulatedToolCall, } from "./transport.js";
-export { accumulateToolCalls } from "./transport.js";
-export type { MediaTransport, MediaRequest, MediaResult, MediaType } from "./media-transport.js";
-export { MediaClient, type MediaClientConfig, type ResolvedMediaModel } from "./media-client.js";
-export { ProviderRegistry } from "./provider-registry.js";
-export { BUILTIN_PROVIDERS } from "./builtin-providers.js";
-export { ModelCatalog } from "./model-catalog.js";
-export type { LLMClientConfig, LLMClient } from "./llm-client.js";
-export { createLLMClient } from "./llm-client.js";
-export { OpenAIChatTransport } from "./transports/openai-chat.js";
-export { AnthropicMessagesTransport } from "./transports/anthropic-messages.js";
-export { GeminiGenerateContentTransport } from "./transports/gemini-generatecontent.js";
-export { VolcengineMediaTransport } from "./transports/volcengine-media.js";
-export { OpenAIMediaTransport } from "./transports/openai-media.js";
-export { MiniMaxMediaTransport } from "./transports/minimax-media.js";
-export { GeminiMediaTransport, type GeminiMediaConfig } from "./transports/gemini-media.js";
-export { GeminiLyriaRealtimeSession, generateRealtimeMusic } from "./transports/gemini-lyria-realtime.js";
-export type { WeightedPrompt, MusicGenerationConfig, MusicScale, MusicGenerationMode, LyriaRealtimeConfig, LyriaRealtimeSessionOptions, AudioChunk } from "./transports/gemini-lyria-realtime.js";
-export { RealtimeTransport } from "./transports/realtime-transport.js";
-export type { RealtimeConfig, RealtimeTool, RealtimeEvent, RealtimeUsage } from "./transports/realtime-transport.js";
-export { GeminiCacheAPI } from "./transports/gemini-cache-api.js";
-export type { GeminiCachedContent, GeminiCacheCreateOptions } from "./transports/gemini-cache-api.js";
-export { GeminiFileAPI } from "./transports/gemini-file-api.js";
-export type { GeminiFileInfo } from "./transports/gemini-file-api.js";
-export { isDebugTransportEnabled, createDebugTransport } from "./debug-transport.js";
+export * from "@qlogic/provider-core";

package/dist/types/orchestration/dag-scheduler.d.ts

@@ -3,6 +3,8 @@
  *
  * Manages a directed acyclic graph of tasks with dependencies.
  * Ensures tasks only execute when all prerequisites are satisfied.
+ *
+ * Supports dynamic mutations: leader can add/remove/retry tasks at runtime.
  */
 import type { ProductTaskDef, ProductTaskStatus } from "../runtime/infra/acp-types.js";
 export interface TaskNode {
@@ -68,5 +70,49 @@ export declare class DagScheduler {
         startedAt?: number;
         completedAt?: number;
     }>): void;
+    /**
+     * Add a new task to the DAG at runtime.
+     * Used by leader agent when it discovers new work is needed.
+     * Validates that the addition doesn't create cycles.
+     */
+    addTask(task: ProductTaskDef): void;
+    /**
+     * Add multiple tasks atomically. All-or-nothing.
+     */
+    addTasks(tasks: ProductTaskDef[]): void;
+    /**
+     * Remove a pending task from the DAG.
+     * Cannot remove running/completed tasks.
+     * Removes the task from other tasks' dependsOn lists.
+     */
+    removeTask(taskId: string): void;
+    /**
+     * Retry a failed task: reset it to pending for re-execution.
+     * Optionally update the prompt (leader may refine instructions).
+     */
+    retryTask(taskId: string, newPrompt?: string): void;
+    /**
+     * Update a pending task's prompt (leader refines instructions before execution).
+     */
+    updateTaskPrompt(taskId: string, prompt: string): void;
+    /**
+     * Re-assign a pending task to a different instance.
+     */
+    reassignTask(taskId: string, newAssignee: string): void;
+    /**
+     * Add a dependency edge. Validates no cycle is introduced.
+     */
+    addDependency(taskId: string, dependsOnTaskId: string): void;
+    /**
+     * Get statistics for progress tracking.
+     */
+    getProgress(): {
+        total: number;
+        completed: number;
+        running: number;
+        failed: number;
+        pending: number;
+        paused: number;
+    };
     private validateDag;
 }

package/dist/types/orchestration/index.d.ts

@@ -3,7 +3,7 @@ export { classifyError, isRetryableCategory, type ErrorCategory, } from "./error
 export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, MicroCompactStrategy, postCompactFileRecovery, type PostCompactRecoveryConfig, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, type AdaptiveBudgetConfig, type AsyncCompressionStrategy, type CacheAwareCompressionConfig, type CompressibleMessage, type CompressionEvent, type CompressionMetrics, type CompressionMetricsSnapshot, type CompressionResult, type CompressionStrategy, type CompressionTier, type ContextEngine, type HeadTailProtectionConfig, type IncrementalCompactConfig, type SummarizeFn, } from "./context/context-compression.js";
 export { snipCompactIfNeeded, type SnipResult, } from "./context/context-compression.js";
 export { applyCollapsesIfNeeded as applyContextCollapsesIfNeeded, recoverFromOverflow as recoverContextCollapseFromOverflow, createCollapseStore, type CollapseStore, type CollapseStage, } from "./context/context-collapse.js";
-export { buildSkillInstruction, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.js";
+export { buildSkillInstruction, recordPatternAndCheckThreshold, getPatternStats, buildToolSignature, type SkillCreateInstruction, type SkillImproveInstruction, type SkillInstruction, type SkillTurnResult, } from "./skill-improvement.js";
 export { applyToolChoicePolicy, type ApplyToolChoicePolicyInput, type ApplyToolChoicePolicyResult, } from "./tool-loop/tool-choice-policy.js";
 export { repairOpenAiChatConversation, type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiToolCall, } from "./tool-loop/conversation-repair.js";
 export { advanceToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, type RepairToolLoopStateResult, type ToolLoopRepairAction, type ToolLoopState, } from "./tool-loop/tool-loop-state.js";

package/dist/types/orchestration/product-planner.d.ts

@@ -0,0 +1,146 @@
+/**
+ * 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 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 { ProductPlanParams, ProductPlan, ProductConfirmParams } from "../runtime/infra/acp-types.js";
+export type PlanningPhase = "planning" | "awaiting_confirmation" | "confirmed" | "executing" | "paused" | "completed" | "cancelled";
+export interface PlanningMessage {
+    role: "leader" | "user";
+    content: string;
+    timestamp: string;
+}
+export interface PlanningSession {
+    productId: string;
+    goal: string;
+    cwd: string;
+    leaderAgentId: string;
+    leaderMemberId?: string;
+    phase: PlanningPhase;
+    plan?: ProductPlan;
+    /** Multi-turn conversation history during planning. */
+    dialogue: PlanningMessage[];
+    budget?: {
+        maxTotalTokens?: number;
+        maxDuration?: number;
+    };
+    createdAt: string;
+    /** Last checkpoint timestamp for durable execution. */
+    lastCheckpoint?: string;
+}
+export interface PlannerCallbacks {
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+    /** Leader produced a structured plan — client presents to user. */
+    onPlanReady?: (productId: string, plan: ProductPlan) => void;
+    /** Planning failed. */
+    onPlanFailed?: (productId: string, error: string) => void;
+    /** Streaming text from leader during planning dialogue. */
+    onPlanningDelta?: (productId: string, text: string) => void;
+    /** Leader sent a message to user (multi-turn). */
+    onLeaderMessage?: (productId: string, message: string) => void;
+    /** Leader dynamically mutated the DAG during execution. */
+    onDagMutated?: (productId: string, mutation: DagMutation) => void;
+}
+/** Describes a DAG mutation performed by the leader. */
+export interface DagMutation {
+    type: "add_task" | "remove_task" | "retry_task" | "reassign_task" | "update_prompt";
+    taskId: string;
+    details?: Record<string, unknown>;
+}
+export declare class ProductPlanner {
+    private processManager;
+    private acpDetector;
+    private configStore;
+    private callbacks;
+    private sessions;
+    constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: PlannerCallbacks);
+    /**
+     * Start an interactive planning session (Phase 1).
+     * Spawns the leader agent and begins multi-turn dialogue.
+     */
+    plan(params: ProductPlanParams): Promise<{
+        productId: string;
+        plan: ProductPlan;
+    }>;
+    /**
+     * Send a user message to the leader (works in planning and execution phases).
+     * Returns the leader's response and optionally a finalized plan.
+     */
+    message(productId: string, content: string): Promise<{
+        response: string;
+        plan?: ProductPlan;
+        mutations?: DagMutation[];
+    }>;
+    /**
+     * Confirm the plan → transition to execution (Phase 2 → Phase 3).
+     */
+    confirm(params: ProductConfirmParams): Promise<{
+        productId: string;
+        ok: true;
+    }>;
+    /** Transition session to executing phase. Called after ProductOrchestrator.create(). */
+    markExecuting(productId: string): void;
+    /** Mark as completed. */
+    markCompleted(productId: string): void;
+    /** Get planning session by ID. */
+    getSession(productId: string): PlanningSession | undefined;
+    /** Cancel and kill leader process. */
+    cancel(productId: string): Promise<void>;
+    /** List active sessions. */
+    listSessions(): PlanningSession[];
+    /**
+     * Ask leader to evaluate execution state and propose DAG mutations.
+     * Called by ProductOrchestrator when tasks fail or progress stalls.
+     */
+    consultLeader(productId: string, context: {
+        progress: {
+            total: number;
+            completed: number;
+            running: number;
+            failed: number;
+        };
+        failedTasks?: Array<{
+            taskId: string;
+            error: string;
+        }>;
+    }): Promise<DagMutation[]>;
+    /**
+     * Serialize session for checkpoint persistence (durable execution).
+     */
+    serializeSession(productId: string): PlanningSession | null;
+    /**
+     * Restore session from checkpoint (crash recovery).
+     */
+    restoreSession(data: PlanningSession): void;
+    private handlePlanningMessage;
+    private handleExecutionMessage;
+    private sendToLeader;
+    private tryParsePlan;
+    private parseDagMutations;
+}

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

@@ -3,6 +3,8 @@
  * 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
@@ -47,6 +49,40 @@ 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.
@@ -68,6 +104,8 @@ export interface SkillCreationContext {
     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.
@@ -80,6 +118,7 @@ export interface SkillCreationContext {
  * - 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;

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

@@ -1,14 +1,22 @@
 /**
- * Solo Mode Evaluator — parallel N-agent PK with leader evaluation.
+ * 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
- *   3. On completion, collect each agent's resultText + git diff
- *   4. Leader agent evaluates all results → picks winner
- *   5. solo.select → merge winning worktree, clean up others
+ *      (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
  *
- * Degradation: if K agents fail but ≥1 succeeds, evaluation still proceeds.
+ * 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";
@@ -50,6 +58,18 @@ export declare class SoloEvaluator {
      * 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>;
     /** 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. */
@@ -63,7 +83,7 @@ export declare class SoloEvaluator {
     /** 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 leader agent (first successful).
+     * Build an evaluation prompt and send to the user-chosen evaluator agent.
      * Returns evaluation result.
      */
     private evaluate;

package/dist/types/orchestration/solo-persistence.d.ts

@@ -24,6 +24,11 @@ export interface PersistedSoloState {
             outputTokens: number;
         };
         error?: string;
+        turns?: Array<{
+            role: "user" | "agent";
+            content: string;
+            timestamp: number;
+        }>;
     }>;
     evaluation?: SoloEvaluation;
     createdAt: number;

package/dist/types/orchestration/tool-cascade.d.ts

@@ -23,14 +23,14 @@
  *
  * ```ts
  * import { cascadeWebSearch } from "./tool-cascade.js";
- * import { ZhipuToolAPI } from "../llm/transports/zhipu-tool-api.js";
+ * import { ZhipuToolAPI } from "@qlogic/provider-core/transports/zhipu-tool-api";
  *
  * const providerApi = new ZhipuToolAPI({ baseUrl, apiKey });
  * const cascadedSearch = cascadeWebSearch(providerApi, fallbackSearchFn);
  * const tool = createWebSearchTool({ search: cascadedSearch });
  * ```
  */
-import type { ProviderToolAPI } from "../llm/provider-tool-api.js";
+import type { ProviderToolAPI } from "@qlogic/provider-core";
 import type { WebSearchToolDeps } from "../skills/tools/web-search-tool.js";
 /**
  * Cascade web search: provider-native search → host fallback.