qlogicagent 2.6.1 → 2.7.0

package/dist/types/cli/tool-bootstrap.d.ts

@@ -41,6 +41,9 @@ export declare function setMediaClientConfig(client: MediaClient | undefined, ap
     provider: string;
     model: string;
 }>>, onMediaProgress?: (taskId: string, mediaType: string, percent: number, status: string, provider?: string) => void): void;
+/** Legacy no-op — workspace boundary is now always enforced for writes. */
+export declare function setBypassWorkspaceBoundary(_bypass: boolean): void;
+export declare function setBootstrapWorkdir(newWorkdir: string): void;
 export interface BootstrapConfig {
     workdir?: string;
     log?: AgentLogger;
@@ -56,8 +59,3 @@ export interface BootstrapConfig {
  * @alias initToolDeps — kept for backward compat with existing call sites.
  */
 export declare function getAllBaseTools(config?: BootstrapConfig): PortableTool[];
-/**
- * Update the working directory for all local tool deps.
- * Called when Gateway sends a new workdir via config.
- */
-export declare function setBootstrapWorkdir(newWorkdir: string): void;

package/dist/types/llm/model-catalog.d.ts

@@ -16,6 +16,21 @@
  * catalog arrives.
  */
 import type { ModelInfo } from "./provider-def.js";
+/** Embedding model metadata from models.dev catalog. */
+export interface EmbeddingModelInfo {
+    id: string;
+    name: string;
+    /** Provider-internal ID (e.g. "openai", "qwen") */
+    providerId: string;
+    /** Output vector dimensions (from limit.output) */
+    dimensions: number;
+    /** Max input context tokens */
+    maxInputTokens: number;
+    /** Cost per million input tokens (USD) */
+    costInput?: number;
+    /** Model family string from models.dev */
+    family: string;
+}
 export declare class ModelCatalog {
     private cache;
     private cacheDir;
@@ -40,6 +55,20 @@ export declare class ModelCatalog {
      * List all known provider ids from the catalog.
      */
     listProviderIds(): string[];
+    /**
+     * Get embedding models for a provider.
+     * Returns models sorted by cost (cheapest first, then largest dims).
+     */
+    getEmbeddingModels(providerId: string): EmbeddingModelInfo[];
+    /**
+     * Get the default embedding model for a provider.
+     * Picks the cheapest model with >=512 dimensions.
+     */
+    getDefaultEmbeddingModel(providerId: string): EmbeddingModelInfo | undefined;
+    /**
+     * Get all embedding models across all providers.
+     */
+    getAllEmbeddingModels(): Map<string, EmbeddingModelInfo[]>;
     /**
      * Force refresh from remote. Returns true if successful.
      */

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

@@ -6,7 +6,7 @@
  * transient errors with exponential backoff.
  */
 /** Default maximum number of retry attempts */
-export declare const DEFAULT_MAX_RETRIES = 3;
+export declare const DEFAULT_MAX_RETRIES = 2;
 /** Base delay for exponential backoff (doubles each attempt, capped at 30s) */
 export declare const RETRY_BASE_DELAY_MS = 1000;
 /** Maximum backoff delay */

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/protocol/methods.d.ts

@@ -9,7 +9,7 @@
 import type { ChatMessage, ToolDefinition } from "../agent/types.js";
 import type { TaskItem as TodoItem } from "../skills/tools/task-tool.js";
 import type { AgentDescriptor, AgentConfig, GatewayRpcMethodMap, RpcProjectInfo, RpcProjectType, RpcProjectStatus, SoloStatus, ProductStatus, ProductSummary } from "./wire/index.js";
-import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, ProductCreateParams, ProductIdParams, ProductDeleteParams } from "../runtime/infra/acp-types.js";
+import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, SoloMessageParams, SoloEvaluateParams, SoloEvaluation, ProductCreateParams, ProductPlanParams, ProductPlan, ProductConfirmParams, ProductMessageParams, ProductIdParams, ProductDeleteParams } from "../runtime/infra/acp-types.js";
 export interface InitializeParams {
     protocolVersion: string;
     host?: {
@@ -522,6 +522,41 @@ export interface RpcMethodMap {
             ok: true;
         };
     };
+    "solo.message": {
+        params: SoloMessageParams;
+        result: {
+            resultText: string;
+        };
+    };
+    "solo.evaluate": {
+        params: SoloEvaluateParams;
+        result: SoloEvaluation;
+    };
+    "product.plan": {
+        params: ProductPlanParams;
+        result: {
+            productId: string;
+            plan: ProductPlan;
+        };
+    };
+    "product.confirm": {
+        params: ProductConfirmParams;
+        result: {
+            productId: string;
+            ok: true;
+        };
+    };
+    "product.message": {
+        params: ProductMessageParams;
+        result: {
+            response: string;
+            plan?: ProductPlan;
+            mutations?: Array<{
+                type: string;
+                taskId: string;
+            }>;
+        };
+    };
     "product.create": {
         params: ProductCreateParams;
         result: {

package/dist/types/protocol/notifications.d.ts

@@ -6,4 +6,4 @@
  * This file re-exports the wire types.
  * Internal consumers import from this file — zero churn.
  */
-export type { AgentSource, AgentsErrorNotification, AgentsStatusNotification, ArtifactType, MediaResultType, MemoryDecayCompletedNotification, MemoryUpdatedNotification, NotificationMethod, NotificationMethodMap, NotificationThreadItem, PermissionRuleUpdatedNotification, PlanInterruptedNotification, PongNotification, ProductBudgetUpdateNotification, ProductBudgetWarningNotification, ProductCheckpointedNotification, ProductCompletedNotification, ProductDagTopologyNotification, ProductTaskCompletedNotification, ProductTaskFailedNotification, ProductTaskOutputDeltaNotification, ProductTaskStartedNotification, ProjectArchivedNotification, ProjectCreatedNotification, ProjectDeletedNotification, ProjectRenamedNotification, ProjectSwitchedNotification, ProjectUnarchivedNotification, SessionInfoNotification, SoloAgentDeltaNotification, SoloAgentDiffNotification, SoloAgentUsageNotification, SoloEvaluationNotification, SoloProgressNotification, TeamMemberNotification, ToolApprovalRequestNotification, TurnAnnotationsNotification, TurnArtifactNotification, TurnAskUserNotification, TurnDeltaNotification, TurnEndNotification, TurnErrorNotification, TurnExecProgressNotification, TurnHeartbeatNotification, TurnMediaPersistedNotification, TurnMediaProgressNotification, TurnMediaResultNotification, TurnPlanUpdateNotification, TurnReasoningDeltaNotification, TurnRecoveryNotification, TurnSidechainCompletedNotification, TurnSidechainStartedNotification, TurnSkillInstructionNotification, TurnStartNotification, TurnSubagentDeltaNotification, TurnSuggestionsNotification, TurnTaskUpdatedNotification, TurnTodosUpdatedNotification, TurnToolBlockedNotification, TurnToolCallNotification, TurnToolResultNotification, TurnToolUseSummaryNotification, TurnUsageUpdateNotification, WireTokenUsage, } from "./wire/index.js";
+export type { AgentSource, AgentsErrorNotification, AgentsStatusNotification, ArtifactType, MediaResultType, MemoryDecayCompletedNotification, MemoryUpdatedNotification, NotificationMethod, NotificationMethodMap, NotificationThreadItem, PermissionRuleUpdatedNotification, PlanInterruptedNotification, PongNotification, ProductBudgetUpdateNotification, ProductBudgetWarningNotification, ProductCheckpointedNotification, ProductCompletedNotification, ProductDagTopologyNotification, ProductPlanFailedNotification, ProductPlanningDeltaNotification, ProductPlanReadyNotification, ProductTaskCompletedNotification, ProductTaskFailedNotification, ProductTaskOutputDeltaNotification, ProductTaskStartedNotification, ProjectArchivedNotification, ProjectCreatedNotification, ProjectDeletedNotification, ProjectRenamedNotification, ProjectSwitchedNotification, ProjectUnarchivedNotification, SessionInfoNotification, SoloAgentDeltaNotification, SoloAgentDiffNotification, SoloAgentUsageNotification, SoloEvaluationNotification, SoloProgressNotification, TeamMemberNotification, ToolApprovalRequestNotification, TurnAnnotationsNotification, TurnArtifactNotification, TurnAskUserNotification, TurnDeltaNotification, TurnEndNotification, TurnErrorNotification, TurnExecProgressNotification, TurnHeartbeatNotification, TurnMediaPersistedNotification, TurnMediaProgressNotification, TurnMediaResultNotification, TurnPlanUpdateNotification, TurnReasoningDeltaNotification, TurnRecoveryNotification, TurnSidechainCompletedNotification, TurnSidechainStartedNotification, TurnSkillInstructionNotification, TurnStartNotification, TurnSubagentDeltaNotification, TurnSuggestionsNotification, TurnTaskUpdatedNotification, TurnTodosUpdatedNotification, TurnToolBlockedNotification, TurnToolCallNotification, TurnToolResultNotification, TurnToolUseSummaryNotification, TurnUsageUpdateNotification, WireTokenUsage, } from "./wire/index.js";

package/dist/types/protocol/wire/acp-protocol.d.ts

@@ -22,12 +22,17 @@ export declare const ACP_EXTENDED_METHODS: {
     readonly SOLO_SELECT: "x/solo.select";
     readonly SOLO_CANCEL: "x/solo.cancel";
     readonly PRODUCT_CREATE: "x/product.create";
+    readonly PRODUCT_PLAN: "x/product.plan";
+    readonly PRODUCT_CONFIRM: "x/product.confirm";
+    readonly PRODUCT_MESSAGE: "x/product.message";
     readonly PRODUCT_RESUME: "x/product.resume";
     readonly PRODUCT_PAUSE: "x/product.pause";
     readonly PRODUCT_CANCEL: "x/product.cancel";
     readonly PRODUCT_ROLLBACK: "x/product.rollback";
     readonly PRODUCT_STATUS: "x/product.status";
     readonly SOLO_SUBSCRIBE: "x/solo.subscribe";
+    readonly SOLO_MESSAGE: "x/solo.message";
+    readonly SOLO_EVALUATE: "x/solo.evaluate";
     readonly PRODUCT_SUBSCRIBE: "x/product.subscribe";
     readonly TEAM_DELEGATE: "x/team.delegate";
 };
@@ -105,6 +110,8 @@ export interface AcpSessionPromptResult {
     stopReason: AcpStopReason;
     /** Token usage for this turn */
     usage?: AcpUsage;
+    /** Final assistant content (internal, used for history tracking). */
+    content?: string;
 }
 export interface AcpSessionEndParams {
     sessionId: string;

package/dist/types/protocol/wire/agent-methods.d.ts

@@ -56,7 +56,7 @@ export interface AgentConfig {
     modelIdMap?: Record<string, string>;
 }
 export type SoloState = "running" | "evaluating" | "completed" | "cancelled" | "failed";
-export type SoloAgentState = "pending" | "running" | "completed" | "failed";
+export type SoloAgentState = "pending" | "running" | "completed" | "failed" | "idle";
 export interface SoloAgentResult {
     id: string;
     state: SoloAgentState;

package/dist/types/protocol/wire/index.d.ts

@@ -3,7 +3,7 @@ export { GATEWAY_RPC_METHODS, type AgentCall, type GatewayRpcMethodMap, type Pro
 export { type ChatMessage, type ChatMessageRole, type ThinkingBlock, type ToolCallMessage, type ToolDefinition, } from "./chat-types.js";
 export { type AgentCapabilities, type AgentCategory, type AgentConfig, type AgentDescriptor, type AgentProtocol, type AgentRpcMethodMap, type AgentStatus, type CustomAgentDef, type ProductInstanceDef, type ProductPhase, type ProductStatus, type ProductSummary, type ProductTaskDef, type ProductTaskStatus, type SoloAgentResult, type SoloAgentState, type SoloState, type SoloStatus, } from "./agent-methods.js";
 export { AGENT_TEAM_WS_EVENT_NAMES, AGENT_WS_EVENT_NAMES, ALL_AGENT_WS_EVENT_NAMES, type AgentTeamWsEventName, type AgentWsEventName, type AllAgentWsEventName, } from "./agent-events.js";
-export { type AgentSource, type AgentsErrorNotification, type AgentsStatusNotification, type ArtifactType, type MediaResultType, type MemoryDecayCompletedNotification, type MemoryUpdatedNotification, type NotificationMethod, type NotificationMethodMap, type NotificationThreadItem, type PermissionRuleUpdatedNotification, type PlanInterruptedNotification, type PongNotification, type ProductBudgetUpdateNotification, type ProductBudgetWarningNotification, type ProductCheckpointedNotification, type ProductCompletedNotification, type ProductDagTopologyNotification, type ProductTaskCompletedNotification, type ProductTaskFailedNotification, type ProductTaskOutputDeltaNotification, type ProductTaskStartedNotification, type ProjectArchivedNotification, type ProjectCreatedNotification, type ProjectDeletedNotification, type ProjectRenamedNotification, type ProjectSwitchedNotification, type ProjectUnarchivedNotification, type SessionInfoNotification, type SoloAgentDeltaNotification, type SoloAgentDiffNotification, type SoloAgentUsageNotification, type SoloEvaluationNotification, type SoloProgressNotification, type TeamMemberNotification, type ToolApprovalRequestNotification, type TurnAnnotationsNotification, type TurnArtifactNotification, type TurnAskUserNotification, type TurnDeltaNotification, type TurnEndNotification, type TurnErrorNotification, type TurnExecProgressNotification, type TurnHeartbeatNotification, type TurnMediaPersistedNotification, type TurnMediaProgressNotification, type TurnMediaResultNotification, type TurnPlanUpdateNotification, type TurnReasoningDeltaNotification, type TurnRecoveryNotification, type TurnSidechainCompletedNotification, type TurnSidechainStartedNotification, type TurnSkillInstructionNotification, type TurnStartNotification, type TurnSubagentDeltaNotification, type TurnSuggestionsNotification, type TurnTaskUpdatedNotification, type TurnTodosUpdatedNotification, type TurnToolBlockedNotification, type TurnToolCallNotification, type TurnToolResultNotification, type TurnToolUseSummaryNotification, type TurnUsageUpdateNotification, type WireTokenUsage, } from "./notification-payloads.js";
+export { type AgentSource, type AgentsErrorNotification, type AgentsStatusNotification, type ArtifactType, type MediaResultType, type MemoryDecayCompletedNotification, type MemoryUpdatedNotification, type NotificationMethod, type NotificationMethodMap, type NotificationThreadItem, type PermissionRuleUpdatedNotification, type PlanInterruptedNotification, type PongNotification, type ProductBudgetUpdateNotification, type ProductBudgetWarningNotification, type ProductCheckpointedNotification, type ProductCompletedNotification, type ProductDagTopologyNotification, type ProductTaskCompletedNotification, type ProductTaskFailedNotification, type ProductTaskOutputDeltaNotification, type ProductTaskStartedNotification, type ProjectArchivedNotification, type ProjectCreatedNotification, type ProjectDeletedNotification, type ProjectRenamedNotification, type ProjectSwitchedNotification, type ProjectUnarchivedNotification, type SessionInfoNotification, type SoloAgentDeltaNotification, type SoloAgentDiffNotification, type SoloAgentUsageNotification, type SoloEvaluationNotification, type SoloProgressNotification, type TeamMemberNotification, type ToolApprovalRequestNotification, type TurnAnnotationsNotification, type TurnArtifactNotification, type TurnAskUserNotification, type TurnDeltaNotification, type TurnEndNotification, type TurnErrorNotification, type TurnExecProgressNotification, type TurnHeartbeatNotification, type TurnMediaPersistedNotification, type TurnMediaProgressNotification, type TurnMediaResultNotification, type TurnPlanUpdateNotification, type TurnReasoningDeltaNotification, type TurnRecoveryNotification, type TurnSidechainCompletedNotification, type TurnSidechainStartedNotification, type TurnSkillAcquisitionNeededNotification, type TurnSkillInstructionNotification, type TurnStartNotification, type TurnSubagentDeltaNotification, type TurnSuggestionsNotification, type TurnTaskUpdatedNotification, type TurnTodosUpdatedNotification, type TurnToolBlockedNotification, type TurnToolCallNotification, type TurnToolResultNotification, type TurnToolUseSummaryNotification, type TurnUsageUpdateNotification, type WireTokenUsage, type ProductPlanReadyNotification, type ProductPlanFailedNotification, type ProductPlanningDeltaNotification, } from "./notification-payloads.js";
 export { ACP_EXTENDED_METHODS, ACP_EXTENDED_SESSION_UPDATE_TYPES, ACP_METHODS, ACP_PROTOCOL_VERSION, ACP_SESSION_UPDATE_TYPES, isAcpJsonRpcNotification, isAcpJsonRpcRequest, isAcpJsonRpcResponse, isExtendedSessionUpdateType, isStandardSessionUpdateType, parseAcpMessage, type AcpAgentCapabilities, type AcpAgentMessageChunkPayload, type AcpAgentThoughtChunkPayload, type AcpAvailableCommandsUpdatePayload, type AcpConfigOptionDescriptor, type AcpConfigOptionUpdatePayload, type AcpContentBlock, type AcpContextItem, type AcpEndTurnPayload, type AcpExtendedMethod, type AcpExtendedSessionUpdateType, type AcpFsReadTextFileParams, type AcpFsReadTextFileResult, type AcpFsWriteTextFileParams, type AcpFsWriteTextFileResult, type AcpHostCapabilities, type AcpInitializeParams, type AcpInitializeResult, type AcpJsonRpcError, type AcpJsonRpcMessage, type AcpJsonRpcNotification, type AcpJsonRpcRequest, type AcpJsonRpcResponse, type AcpPermissionOption, type AcpPermissionRequestParams, type AcpPermissionRequestResult, type AcpPlanPayload, type AcpSessionEndParams, type AcpSessionNewParams, type AcpSessionNewResult, type AcpSessionPromptParams, type AcpSessionPromptResult, type AcpSessionSetConfigParams, type AcpSessionUpdateNotification, type AcpSessionUpdateType, type AcpStandardMethod, type AcpStandardSessionUpdateType, type AcpStopReason, type AcpToolCallPayload, type AcpToolCallUpdatePayload, type AcpUsage, type AcpUsageUpdatePayload, type AcpXAskUserPayload, type AcpXMediaProgressPayload, type AcpXMediaResultPayload, type AcpXMemoryUpdatedPayload, type AcpXProductCheckpointPayload, type AcpXProductTaskCompletedPayload, type AcpXProductTaskStartedPayload, type AcpXRecoveryPayload, type AcpXSessionInfoPayload, type AcpXSidechainCompletedPayload, type AcpXSidechainStartedPayload, type AcpXSkillInstructionPayload, type AcpXSoloAgentFinishedPayload, type AcpXSoloSelectedPayload, type AcpXSoloStartedPayload, type AcpXSubagentDeltaPayload, type AcpXSubagentEndedPayload, type AcpXSubagentStartedPayload, type AcpXSuggestionsPayload, type AcpXTeamMemberUpdatePayload, } from "./acp-protocol.js";
 export { type ApprovalRequiredToolContract, type ModelSelectionReason, type PendingPromptContract, type RuntimeCapabilitySummaryContract, type RuntimeSessionContract, type SessionIdentityContract, } from "./session.js";
 export { type GatewayChannelExecutionEgressContract, type GatewayChannelExecutionEgressKind, type GatewayChannelExecutionIngressBindingContract, type GatewayChannelExecutionIngressSource, } from "./channel-ingress.js";

package/dist/types/protocol/wire/memory-provider-lifecycle.d.ts

@@ -1,7 +1,7 @@
 import type { AgentExecutionRefs } from "./transport.js";
 export declare const MEMORY_OBSERVATION_HOOK_VALUES: readonly ["prefetch", "sync_turn", "on_pre_compress", "on_session_end", "on_delegation", "on_memory_write"];
 export type MemoryObservationHook = (typeof MEMORY_OBSERVATION_HOOK_VALUES)[number];
-export declare const MEMORY_OBSERVATION_SOURCE_VALUES: readonly ["turn", "sidechain", "compress", "session-end"];
+export declare const MEMORY_OBSERVATION_SOURCE_VALUES: readonly ["turn", "sidechain", "compress", "session-end", "agent-remember", "auto-extract", "implicit-extract", "profile-extraction", "dream"];
 export type MemoryObservationSource = (typeof MEMORY_OBSERVATION_SOURCE_VALUES)[number];
 export declare const MEMORY_WRITE_ACCESS_VALUES: readonly ["observe-only", "parent-write", "deny"];
 export type MemoryWriteAccess = (typeof MEMORY_WRITE_ACCESS_VALUES)[number];
@@ -56,6 +56,8 @@ export interface MemorySearchOptions {
     limit?: number;
     minScore?: number;
     llmConfig?: MemoryLlmConfig;
+    /** Categories to boost during reranking (e.g. ["lesson", "preference"]). */
+    preferredCategories?: string[];
 }
 export interface MemoryIngestOptions {
     llmConfig?: MemoryLlmConfig;