qlogicagent 2.10.22 → 2.10.24

package/dist/types/cli/stdio-server.d.ts

@@ -17,6 +17,7 @@ export interface StdioServerConfig {
 export declare class StdioServer {
     private running;
     private readonly startedAt;
+    private readonly packageVersion;
     private readonly rpcContract;
     private readonly rpcIds;
     private readonly rpcDeadlineTimers;
@@ -48,10 +49,13 @@ export declare class StdioServer {
     private taskStore;
     /** Media auto-download service — persists generated media files locally. */
     private mediaPersistence;
+    private pathService;
+    private toolCatalog;
     /** Session-scoped memory prefetch state (LRU dedup + byte limit). */
     private memoryPrefetchState;
     /** Local SQLite memory provider (when better-sqlite3 is available). */
     private memoryProvider;
+    private memoryDreamProvider;
     private memoryUserId;
     /** Last user message text for auto-extract hook (set at turn start, cleared at turn end). */
     private lastUserMessageForAutoExtract;
@@ -59,33 +63,21 @@ export declare class StdioServer {
     private lastAssistantMessageForExtract;
     /** MEMDIR file-based memory (CC memdir parity). */
     private memdir;
+    private readonly projectMemoryStoreFactory;
     /** Memory write gate state (P2+P3: category gate + supersedes). */
     private fileWatcher;
     /** Pending ask_user requests waiting for host response */
     private pendingAskUser;
     /** Session-level task domain stickiness. Survives across turns within a session. */
     private sessionTaskDomain;
-    /** ACP agent detector (scans for installed ACP agent CLIs). */
-    private acpDetector;
-    /** Persistent per-agent configuration store. */
-    private agentConfigStore;
-    /** Solo Mode evaluator (lazily created). */
-    private soloEvaluator;
-    /** Product Mode orchestrator (lazily created). */
-    private productOrchestrator;
-    /** Product Planner — interactive planning phase. */
-    private productPlanner;
-    /** Process managers for solo/product (stored for agents.processes/kill). */
-    private soloProcessManager;
-    private productProcessManager;
+    /** Agents/solo/product handler facade. */
+    private readonly multiAgentHandlerHost;
     /** ACP Server instance — handles ACP protocol alongside legacy protocol. */
     private acpServer;
-    /** ACP per-session conversation history for multi-turn support. */
-    private acpSessionHistory;
-    /** Resumed session histories — restored from JSONL persistence on session.resume. */
-    private resumedSessionHistory;
-    /** Idle dream timer — fires after configurable idle period to trigger memory consolidation. */
-    private idleDreamTimer;
+    private sessionHistory;
+    private idleDreamCoordinator;
+    private petRuntime;
+    private readonly petConfirmCoordinator;
     private modelRegistryHydration;
     constructor(config: StdioServerConfig);
     /**
@@ -101,22 +93,14 @@ export declare class StdioServer {
      */
     private setActiveWorkdir;
     start(): void;
-    stop(): void;
+    stop(): Promise<void>;
     private readonly methodHandlers;
     private handleMessage;
-    /**
-     * `initialize` — the sole handshake handler.
-     * Accepts both legacy flat params (`hostName`, `hostVersion`) and
-     * Codex-style nested params (`host.name`, `host.version`).
-     * Always returns the InitializeResult shape.
-     */
-    private handleInitialize;
     /**
      * Ensure a default project exists on first start.
      * Called from both legacy handleInitialize and ACP acpHandleInitialize.
      */
     private ensureDefaultProject;
-    private ensureDefaultProjectDir;
     /**
      * `thread.create` — create a new thread (session container).
      * Maps threadId → sessionId for the underlying session system.
@@ -130,78 +114,13 @@ export declare class StdioServer {
      * For group: look up by groupKey pattern.
      * If not found, create a new session and return it.
      */
-    private handlePing;
-    private handleHealth;
-    private handleMetrics;
-    private handleCancel;
-    private static readonly SUGGESTION_PROMPT;
     /**
      * Atomically resolve transport + model + apiKey for a given ModelPurpose.
      * If the resolved provider matches `this.currentProvider`, reuses cached transport.
      * Otherwise creates a one-shot client. Returns null if purpose is unresolvable.
-     * This ensures side-ops always use fresh model from registry — never stale cache.
+     * This ensures side-ops always use fresh model from registry.
      */
     private resolveClientForPurpose;
-    /**
-     * Generate follow-up suggestions after a turn completes.
-     * Fire-and-forget — failures are silently logged. Non-blocking.
-     * CC parity: suggestions use the SAME model as main (prompt cache sharing).
-     */
-    private generateSuggestions;
-    /**
-     * Create a soul generator function that uses small model LLM.
-     * Used by pet.hatch to generate personalized name/personality/catchphrase.
-     */
-    createPetSoulGenerator(): ((rarity: string, stats: any) => Promise<{
-        name: string;
-        personality: string;
-        catchphrase: string;
-    }>) | undefined;
-    /**
-     * Create a generic small LLM call function for short generation tasks.
-     * Returns a function compatible with generateLLMReaction's signature.
-     */
-    createSmallLLMCall(): ((prompt: string, maxTokens: number) => Promise<string | null>) | undefined;
-    /**
-     * P4 Forge: Analyze uploaded image via Vision model (design §14.3 step 1).
-     */
-    forgeAnalyzeImage(imageBase64: string, hint?: string): Promise<string>;
-    /**
-     * P4 Forge: Generate a single state SVG via LLM code generation (design §14.3 Option C).
-     */
-    forgeGenerateSVG(characterDesc: string, state: string): Promise<string>;
-    /**
-     * P4 Forge: Generate a base skeleton SVG via LLM (design §14.3 Plan A).
-     * One LLM call produces the entire character skeleton with labeled parts.
-     * States are then rendered by injecting CSS animations (no additional LLM calls).
-     */
-    forgeGenerateSkeleton(characterDesc: string): Promise<string>;
-    /**
-     * P4 Forge: Score SVG consistency using Vision model (design §14.4).
-     * Compares a candidate SVG against the reference (idle) to score character consistency.
-     */
-    forgeScoreConsistency(referenceSvg: string, candidateSvg: string, state: string, characterDesc: string): Promise<{
-        score: number;
-        feedback: string;
-    }>;
-    /**
-     * Award XP to pet on events (fire-and-forget).
-     */
-    private petAwardXp;
-    /** Check if the pet system is active (soul hatched). */
-    private isPetActive;
-    /** Pending confirm requests — confirmId → resolve callback. */
-    private pendingConfirms;
-    /**
-     * Request user confirmation for a tool call via the pet overlay.
-     * Returns true if approved, false if denied or timed out.
-     */
-    requestPetConfirm(toolName: string, description: string, risk: "low" | "medium" | "high", timeoutMs?: number): Promise<boolean>;
-    private handlePetConfirmResponse;
-    /**
-     * Generate pet reaction after turn (P3: LLM-enhanced, P0: template fallback).
-     */
-    private petReactionAfterTurn;
     /**
      * Ensure the L2 SQLite memory provider exists for read-only RPCs
      * (memory.atlas / memory.activity). These can be called before any turn has
@@ -279,18 +198,16 @@ export declare class StdioServer {
     /**
      * `tasks.cancel` — Cancel a running task by ID.
      */
-    /** Map process handle state → agents.status notification status. */
-    private static readonly STATE_TO_STATUS;
     /** Emit an `agents.status` notification when a child process state changes. */
     private emitAgentStatus;
+    private createDreamHandlerHost;
+    private createAcpExtendedHandlerHost;
     /**
      * Handle an MCP tool call proxied from an external ACP agent via the
      * named-pipe bridge.  Dispatches the tool through the host's own tool
      * system and returns the text result.
      */
     private handleMcpToolCall;
-    /** Ensure agent config store is loaded. */
-    private ensureAgentConfigStore;
     /** `agents.scan` — Scan for installed ACP agent CLIs. */
     /** `agents.list` — Return cached agent descriptors. */
     /** `agents.config` — Register / unregister / update custom agents. */
@@ -337,9 +254,9 @@ export declare class StdioServer {
      * Enable idle dream scheduling. Called after session setup when LLM config is available.
      */
     enableIdleDream(minutes?: number): void;
-    private resetIdleDreamTimer;
     private cancelIdleDreamTimer;
-    private triggerIdleDream;
+    disposeSessionRuntime(): void;
+    private closeMemoryProviders;
     /**
      * Initialize the ACP server alongside the legacy protocol.
      * Called once when the host is an ACP-compliant client.
@@ -347,38 +264,4 @@ export declare class StdioServer {
     initAcpServer(): void;
     /** Get the ACP server instance (for external wiring, e.g., main.ts). */
     getAcpServer(): AcpServer | null;
-    private acpHandleInitialize;
-    private acpHandleSessionNew;
-    private acpHandleSessionPrompt;
-    /**
-     * Run a turn in ACP mode — streams events via session/update, returns final result.
-     * This duplicates the core logic of handleTurn but returns a promise with the final content.
-     */
-    private runAcpTurn;
-    private acpHandleSessionEnd;
-    private acpHandleSessionSetConfig;
-    private acpHandleSessionSetModel;
-    private acpHandleSessionSetMode;
-    private acpHandlePermissionResponse;
-    private acpHandleAbort;
-    private acpHandleDream;
-    private acpHandleSoloStart;
-    private acpHandleSoloStatus;
-    private acpHandleSoloSelect;
-    private acpHandleSoloCancel;
-    private acpHandleSoloSubscribe;
-    private acpHandleSoloMessage;
-    private acpHandleSoloEvaluate;
-    private acpHandleAgentsList;
-    private acpHandleProductCreate;
-    private acpHandleProductPlan;
-    private acpHandleProductConfirm;
-    private acpHandleProductMessage;
-    private acpHandleProductResume;
-    private acpHandleProductStatus;
-    private acpHandleProductPause;
-    private acpHandleProductCancel;
-    private acpHandleProductRollback;
-    private acpHandleProductSubscribe;
-    private acpHandleTeamDelegate;
 }

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

@@ -3,9 +3,7 @@ import { type TaskToolHooks } from "../skills/tools/task-tool.js";
 import { type ExecProgress } from "../skills/tools/exec-tool.js";
 import type { AgentLogger } from "../agent/types.js";
 import { type AskUserQuestion } from "../skills/tools/ask-user-tool.js";
-import type { MediaClient } from "@xiaozhiclaw/provider-core";
-import type { MediaCapability } from "@xiaozhiclaw/provider-core";
-import type { ProviderToolAPI } from "@xiaozhiclaw/provider-core";
+import { type MediaCapability, type MediaClient, type ProviderToolAPI } from "./provider-core-facade.js";
 /** Enable or disable group security mode (blocks sensitive file access). */
 export declare function setGroupSecurityMode(enabled: boolean): void;
 /**
@@ -14,7 +12,6 @@ export declare function setGroupSecurityMode(enabled: boolean): void;
  * falling back to SearXNG. Called from stdio-server per session.
  */
 export declare function setProviderToolAPI(api: ProviderToolAPI | undefined): void;
-export declare function createProviderToolAPIForSession(providerId: string | undefined, apiKey: string | undefined): ProviderToolAPI | undefined;
 /** Set callback invoked after LLM-driven project switch. */
 export declare function setProjectSwitchCallback(cb: ((project: {
     id: string;

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

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/tool-bootstrap.media-provider-alias.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import type { ToolCatalog } from "../runtime/ports/index.js";
+export declare function createCliToolCatalog(): ToolCatalog;

package/dist/types/cli/tool-invoker-factory.d.ts

@@ -0,0 +1,10 @@
+import type { ToolInvoker } from "../agent/types.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+export interface LocalToolInvokerDeps {
+    mediaPersistence: MediaPersistence;
+    getSessionId(): string;
+    log(message: string): void;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export declare function createLocalToolInvoker(deps: LocalToolInvokerDeps): ToolInvoker;

package/dist/types/cli/tool-result-processor.d.ts

@@ -0,0 +1,14 @@
+import type { ToolInvoker } from "../agent/types.js";
+import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+import type { PortableToolResult } from "../skills/portable-tool.js";
+type ToolInvokeResult = Awaited<ReturnType<ToolInvoker["invoke"]>>;
+export interface ToolResultProcessorDeps {
+    turnId: string;
+    sessionId?: string;
+    result: PortableToolResult;
+    mediaPersistence: MediaPersistence;
+    log(message: string): void;
+    sendNotification(method: string, params: unknown): void;
+}
+export declare function processToolResult(deps: ToolResultProcessorDeps): Promise<ToolInvokeResult>;
+export {};

package/dist/types/cli/transport.d.ts

@@ -7,18 +7,8 @@
  * Each transport reads incoming JSON-RPC messages and emits them
  * to a registered handler; outgoing messages are sent via send().
  */
-export interface Transport {
-    /** Register the message handler (called for each valid parsed message). */
-    onMessage(handler: (msg: unknown) => void): void;
-    /** Register the close handler (called when the transport closes). */
-    onClose(handler: () => void): void;
-    /** Send a JSON-RPC message (object will be serialized to JSON). */
-    send(msg: unknown): void;
-    /** Start listening for incoming messages. */
-    start(): void;
-    /** Close the transport gracefully. */
-    close(): void;
-}
+import type { Transport } from "../transport/io-transport.js";
+export type { Transport } from "../transport/io-transport.js";
 /**
  * Line-delimited JSON over stdin/stdout.
  * Each line on stdin is a JSON message; each send() writes one JSON line to stdout.

package/dist/types/cli/turn-ask-user-setup.d.ts

@@ -0,0 +1,9 @@
+interface PendingAskUserRequest {
+    resolve(answers: Record<string, string> | null): void;
+}
+export interface TurnAskUserSetupHost {
+    pendingAskUser: Map<string, PendingAskUserRequest>;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export declare function configureTurnAskUser(host: TurnAskUserSetupHost): void;
+export {};

package/dist/types/cli/turn-event-forwarder.d.ts

@@ -0,0 +1,10 @@
+import type { TurnEvent } from "../agent/types.js";
+export interface TurnEventForwardHost {
+    sendNotification(method: string, params: unknown): void;
+}
+export declare function forwardTurnSideEvent(params: {
+    event: TurnEvent;
+    turnId: string;
+    now: string;
+    host: TurnEventForwardHost;
+}): boolean;

package/dist/types/cli/turn-lifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import { SessionState } from "../runtime/session/session-state.js";
+export interface TurnLifecycleHost {
+    activeTurn: AbortController | null;
+    turnDone: Promise<void>;
+    currentSessionId: string;
+    currentHooks: HookRegistry | null;
+    sessionState: SessionState | null;
+    sessionTaskDomain: unknown;
+    memoryPrefetchState: MemoryPrefetchState;
+    enableIdleDream(): void;
+}
+export interface PreparedTurnLifecycle {
+    abortController: AbortController;
+    resolveTurnDone(): void;
+}
+export declare function prepareTurnLifecycle(host: TurnLifecycleHost, sessionId: string): Promise<PreparedTurnLifecycle>;
+export declare function finishTurnLifecycle(host: TurnLifecycleHost, lifecycle: PreparedTurnLifecycle): void;

package/dist/types/cli/turn-lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/turn-media-setup.d.ts

@@ -0,0 +1,16 @@
+import { type MediaClient } from "./provider-core-facade.js";
+interface MediaUsageRecorder {
+    addMediaUsage(model: string, billingUnit: string, quantity: number): void;
+}
+export interface TurnMediaSetupHost {
+    mediaClient: MediaClient;
+    currentMediaApiKeys: Record<string, string> | null;
+    sessionState?: MediaUsageRecorder | null;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export declare function configureTurnMedia(params: {
+    host: TurnMediaSetupHost;
+    config?: Record<string, unknown>;
+    turnId: string;
+}): void;
+export {};

package/dist/types/cli/turn-permission-sync.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionBehavior, PermissionConfig, PermissionMode, PermissionRuleEntry } from "../runtime/ports/index.js";
+export interface TurnPermissionRuleEngine {
+    setMode(mode: PermissionMode): void;
+    replaceRules(rules: PermissionRuleEntry[]): void;
+    setDefaultBehavior(behavior: PermissionBehavior): void;
+}
+export declare function syncTurnPermissionConfig(ruleEngine: TurnPermissionRuleEngine, rawPermissions: unknown): PermissionConfig;

package/dist/types/cli/turn-permission-sync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/turn-project-router.d.ts

@@ -0,0 +1,22 @@
+export interface TurnProjectRoutingHost {
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(workdir: string): void;
+    log(message: string): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export interface StaleProjectHintContext {
+    activeProjectName?: string;
+    projectNames: string[];
+}
+export interface TurnProjectRoutingResult {
+    sessionProjectRoot: string;
+    sessionProjectId?: string;
+    projectHintStale: boolean;
+    staleProjectHintContext?: StaleProjectHintContext;
+}
+export declare function routeTurnProjectContext(params: {
+    config?: Record<string, unknown>;
+    sessionId?: string;
+    host: TurnProjectRoutingHost;
+    nowMs?: number;
+}): TurnProjectRoutingResult;

package/dist/types/cli/turn-project-router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/turn-skill-autopersist.d.ts

@@ -0,0 +1,47 @@
+import { type CommunityPublishSkillInput, type CommunityPublishSkillResult } from "../runtime/community/community-consent-client.js";
+import { type CommunityTelemetryRecorder } from "../runtime/community/community-telemetry-recorder.js";
+export interface TurnSkillAutoPersistHost {
+    log(message: string): void;
+}
+export interface CommunitySkillPublisher {
+    publishSkill(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
+}
+export type AutoPersistResult = {
+    status: "ignored";
+} | {
+    status: "exists";
+    skillPath: string;
+} | {
+    status: "created";
+    skillPath: string;
+} | {
+    status: "blocked";
+    skillPath: string;
+    reason: string;
+} | {
+    status: "skipped";
+    skillPath: string;
+    reason: string;
+};
+export type CommunityPublishAuditDecision = "published" | "blocked" | "skipped";
+export interface CommunityPublishAuditEntry {
+    eventTurnId: string;
+    skillName: string;
+    decision: CommunityPublishAuditDecision;
+    reason: string;
+    resourceId?: string;
+    createdAt: string;
+}
+export declare const COMMUNITY_PUBLISH_AUDIT_FILE = "community-publish-audit.jsonl";
+export declare function maybeAutoPersistSkillInstruction(params: {
+    instruction: unknown;
+    eventTurnId: string;
+    projectRoot: string;
+    host: TurnSkillAutoPersistHost;
+    communityPublisher?: CommunitySkillPublisher | null;
+    communityTelemetryRecorder?: CommunityTelemetryRecorder | null;
+}): Promise<AutoPersistResult>;
+export declare function createDefaultCommunitySkillPublisher(): CommunitySkillPublisher | null;
+export declare function listCommunityPublishAuditEntries(input?: {
+    limit?: number;
+}): CommunityPublishAuditEntry[];

package/dist/types/cli/turn-skill-autopersist.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/turn-suggestion-generator.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "../agent/types.js";
+import type { NotificationMethodMap } from "../protocol/notifications.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface TurnSuggestionClient {
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export interface TurnSuggestionGeneratorDeps {
+    turnId: string;
+    messages: ChatMessage[];
+    client: TurnSuggestionClient | null;
+    sendNotification<M extends keyof NotificationMethodMap>(method: M, params: NotificationMethodMap[M]): void;
+}
+export declare function generateTurnSuggestions({ turnId, messages, client, sendNotification, }: TurnSuggestionGeneratorDeps): Promise<void>;

package/dist/types/orchestration/agent-instance.d.ts

@@ -14,7 +14,7 @@
 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 { ProductCreateParams, ProductStatus, ProductSummary } from "../runtime/infra/acp-types.js";
+import type { ProductCreateParams, ProductStatus, ProductSummary } from "../protocol/wire/acp-agent-management.js";
 export interface ProductCallbacks {
     log?: {
         info(msg: string): void;