qlogicagent 1.3.0 → 2.0.0

package/dist/qlogicagent.cmd

@@ -0,0 +1,2 @@
+@echo off
+node "%~dp0cli.js" %*

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

@@ -6,6 +6,10 @@
  * All log/debug output goes to stderr (never pollutes the protocol).
  *
  * Usage:
- *   qlogicagent [--verbose]
+ *   qlogicagent [--verbose] [--acp]
+ *
+ * Flags:
+ *   --verbose  Enable debug logging to stderr
+ *   --acp      Enable ACP (Agent-Client Protocol) server alongside legacy protocol
  */
 export {};

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

@@ -9,6 +9,7 @@
  * The physical I/O layer is abstracted via the Transport interface.
  */
 import type { Transport } from "./transport.js";
+import { AcpServer } from "../transport/acp-server.js";
 export interface StdioServerConfig {
     verbose: boolean;
     transport?: Transport;
@@ -35,6 +36,8 @@ export declare class StdioServer {
     private currentTransport;
     private currentApiKey;
     private currentModel;
+    private currentProvider;
+    private currentBaseUrl;
     private sessionState;
     private currentMediaApiKeys;
     private taskStore;
@@ -43,6 +46,8 @@ export declare class StdioServer {
     /** QMemory adapter (when QMEMORY_BASE_URL env is set). Used by Dream hippocampus bridge. */
     private qmemoryAdapter;
     private qmemoryUserId;
+    /** Local memory store for system prompt injection (CC memory parity). */
+    private memoryStore;
     private fileWatcher;
     /** Pending ask_user requests waiting for host response */
     private pendingAskUser;
@@ -59,6 +64,20 @@ export declare class StdioServer {
     /** Process managers for solo/product (stored for agents.processes/kill). */
     private soloProcessManager;
     private productProcessManager;
+    /** ACP Server instance — handles ACP protocol alongside legacy protocol. */
+    private acpServer;
+    /** Idle dream timer — fires after configurable idle period to trigger memory consolidation. */
+    private idleDreamTimer;
+    /** Idle dream config (minutes). Default: 30 min idle = trigger dream. */
+    private idleDreamMinutes;
+    /** Whether idle dream is enabled. Requires LLM config + memory root to be set. */
+    private idleDreamEnabled;
+    /** Last dream timestamp to enforce cooldown. */
+    private lastDreamAt;
+    /** Dream cooldown (ms). Default: 4 hours. */
+    private dreamCooldownMs;
+    /** Max dream duration (ms). Default: 5 minutes. */
+    private dreamMaxDurationMs;
     constructor(config: StdioServerConfig);
     start(): void;
     stop(): void;
@@ -243,4 +262,40 @@ export declare class StdioServer {
     private sendNotification;
     private writeStdout;
     private log;
+    /**
+     * Enable idle dream scheduling. Called after session setup when LLM config is available.
+     */
+    enableIdleDream(minutes?: number): void;
+    private resetIdleDreamTimer;
+    private cancelIdleDreamTimer;
+    private triggerIdleDream;
+    /**
+     * Initialize the ACP server alongside the legacy protocol.
+     * Called once when the host is an ACP-compliant client.
+     */
+    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 acpHandleProductCreate;
+    private acpHandleProductResume;
+    private acpHandleProductStatus;
+    private acpHandleTeamDelegate;
 }

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, autoDetectProvider, } from "./llm/index.js";
+export { ProviderRegistry, createLLMClient, } from "./llm/index.js";
 export type { LLMTransport, LLMRequest, LLMChunk } from "./llm/index.js";
 export { createHookRegistry } from "./runtime/hooks/hook-registry.js";
 export { buildSkillInstruction, } from "./orchestration/index.js";

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

@@ -12,7 +12,7 @@ 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, autoDetectProvider } 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";

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -2,17 +2,54 @@
  * ACP Protocol Adapter — translates between qlogicagent's internal JSON-RPC
  * protocol and the ACP (Agent-Client Protocol) wire format.
  *
- * ACP = JSON-RPC 2.0 over stdio with different method names:
- *   initialize → initialize (compatible)
- *   session/new → create session with workspaceRoot + mcpServers
- *   prompt → send task
- *   session/close → abort
- *   message notifications → turn.delta / turn.end
+ * Aligned with @agentclientprotocol/sdk v0.18.2 (PROTOCOL_VERSION = 1).
+ * Reference: AionUI ClientSideConnection, @agentclientprotocol/sdk.
  *
- * Reference: AionUI AcpAgentManager, ACP protocol spec.
+ * ACP = JSON-RPC 2.0 over NDJSON stdio:
+ *   HOST → AGENT (requests):
+ *     initialize, session/new, session/prompt, session/close, session/resume
+ *   AGENT → HOST (notifications):
+ *     session/update — carries { sessionId, update: { sessionUpdate: "...", ...payload } }
+ *   AGENT → HOST (requests, host must respond):
+ *     fs/read_text_file, fs/write_text_file, session/request_permission,
+ *     session/elicitation, terminal/create, terminal/output, terminal/release,
+ *     terminal/wait_for_exit, terminal/kill
  */
 import type { ChildProcess } from "node:child_process";
 import type { AcpInitializeResult, AcpSessionResult, AcpPromptResponse, McpServerConfig } from "./acp-types.js";
+/**
+ * Handler for agent→host requests (fs, terminal, permission, elicitation).
+ * Host implementations should implement the methods they support.
+ */
+export interface AcpHostRequestHandler {
+    /** Read a text file from the host filesystem. */
+    readTextFile?(params: {
+        path: string;
+    }): Promise<{
+        content: string;
+    } | undefined>;
+    /** Write a text file on the host filesystem. */
+    writeTextFile?(params: {
+        path: string;
+        content: string;
+    }): Promise<Record<string, unknown> | undefined>;
+    /** Request permission for a tool call (return selected option). */
+    requestPermission?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Elicitation request (ask user for input). */
+    elicitation?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Create a terminal session. */
+    createTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Terminal output data. */
+    terminalOutput?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Release a terminal. */
+    releaseTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Wait for terminal exit. */
+    waitForTerminalExit?(params: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+    /** Kill a terminal. */
+    killTerminal?(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Extension method (unknown method from agent). */
+    extMethod?(method: string, params: unknown): Promise<unknown>;
+}
 /** Internal representation of an ACP notification translated to qlogicagent format. */
 export interface TranslatedNotification {
     method: string;
@@ -21,45 +58,59 @@ export interface TranslatedNotification {
 export declare class AcpProtocolAdapter {
     private pendingRpcs;
     private rl;
+    private child;
     private onNotification;
+    private hostHandler;
     /**
      * Attach to a child process's stdio for ACP communication.
      * Must be called before any RPC methods.
+     *
+     * @param child The spawned ACP agent process
+     * @param onNotification Callback for agent notifications (session/update, etc.)
+     * @param hostHandler Optional handler for agent→host requests (fs, terminal, permission)
+     */
+    attach(child: ChildProcess, onNotification?: (method: string, params: unknown) => void, hostHandler?: AcpHostRequestHandler): void;
+    /**
+     * Handle an incoming JSON-RPC request from the agent (reverse-RPC).
+     * Agent calls host for fs operations, terminal, permissions, etc.
      */
-    attach(child: ChildProcess, onNotification?: (method: string, params: unknown) => void): void;
+    private handleAgentRequest;
     /** Detach from the child process. */
     detach(): void;
     /** Send a raw JSON-RPC request and await response. */
     sendRpc(child: ChildProcess, method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
     /**
      * Perform ACP initialize handshake.
-     * Permissive: fallback protocolVersion to 0 if missing.
-     * Extracts `supportsResume` from capabilities for D-1 session resume.
+     * Sends standard clientInfo + clientCapabilities (aligned with SDK).
      */
     initialize(child: ChildProcess): Promise<AcpInitializeResult>;
     /**
      * Create an ACP session.
-     * Optionally injects MCP servers and system prompt.
+     * Official SDK params: { cwd, mcpServers, additionalDirectories? }
+     * Optionally injects system prompt as extension field.
      */
     createSession(child: ChildProcess, options: {
-        workspaceRoot: string;
+        cwd: string;
         mcpServers?: McpServerConfig[];
+        additionalDirectories?: string[];
         systemPrompt?: string;
     }): Promise<AcpSessionResult>;
     /**
      * Send a prompt to a running ACP session.
-     * Returns the complete response.
+     * Official SDK params: { sessionId, prompt: ContentBlock[], messageId? }
+     * Official SDK response: { stopReason, usage?, userMessageId? }
+     *
+     * Note: Actual content is delivered via session/update notifications DURING
+     * the prompt execution. The response only signals completion.
      */
     sendPrompt(child: ChildProcess, sessionId: string, content: string, timeoutMs?: number): Promise<AcpPromptResponse>;
     /**
-     * Resume an existing ACP session (D-1).
-     * Only call if the agent's capabilities.supportsResume is true.
-     * Falls back to createSession + summary injection if session/resume fails.
+     * Resume an existing ACP session (loadSession capability).
+     * Official SDK method: session/load (same schema as session/new + sessionId).
      */
     resumeSession(child: ChildProcess, sessionId: string, options?: {
-        workspaceRoot?: string;
+        cwd?: string;
         mcpServers?: McpServerConfig[];
-        summary?: string;
     }): Promise<AcpSessionResult>;
     /**
      * Close an ACP session.
@@ -68,6 +119,9 @@ export declare class AcpProtocolAdapter {
     /**
      * Translate an ACP notification into qlogicagent's internal format.
      * Returns null if the notification is not translatable (handled separately).
+     *
+     * Standard ACP: agent sends "session/update" notification with
+     *   params: { sessionId, update: { sessionUpdate: "<type>", ...payload } }
      */
     static translateNotification(method: string, params: unknown): TranslatedNotification | null;
 }

package/dist/types/runtime/infra/acp-types.d.ts

@@ -136,39 +136,52 @@ export interface AgentConfigStoreData {
 /** ACP initialize result (from agent's response). */
 export interface AcpInitializeResult {
     protocolVersion: number;
-    capabilities: {
-        prompts?: boolean;
-        /** Whether this agent supports session/resume (D-1). */
-        supportsResume?: boolean;
+    /** Standard ACP agentCapabilities (official SDK field). */
+    agentCapabilities: {
+        loadSession?: boolean;
+        mcpCapabilities?: {
+            http?: boolean;
+            sse?: boolean;
+        };
+        promptCapabilities?: {
+            audio?: boolean;
+            embeddedContext?: boolean;
+            image?: boolean;
+        };
+        sessionCapabilities?: Record<string, unknown>;
         [key: string]: unknown;
     };
-    serverInfo?: {
+    /** Standard ACP agentInfo (official SDK field). */
+    agentInfo?: {
         name: string;
         version?: string;
     };
+    authMethods?: Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
 }
-/** ACP session/new result. */
+/** ACP session/new result (official: { sessionId, configOptions?, models?, modes? }). */
 export interface AcpSessionResult {
-    id: string;
+    sessionId: string;
 }
-/** ACP prompt response content item. */
-export interface AcpContentItem {
-    type: "text" | "image" | "resource";
-    text?: string;
-    data?: string;
-    mimeType?: string;
-}
-/** ACP prompt response. */
+/** Standard ACP stopReason. */
+export type AcpStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
+/** ACP prompt response (official: { stopReason, usage?, userMessageId? }). */
 export interface AcpPromptResponse {
-    content: AcpContentItem[];
+    stopReason: AcpStopReason;
     usage?: AcpPromptResponseUsage;
+    userMessageId?: string;
+    /** Aggregated text from session/update notifications (populated by adapter). */
+    text?: string;
 }
-/** ACP per-turn usage stats. */
+/** ACP per-turn usage stats (aligned with SDK zUsage). */
 export interface AcpPromptResponseUsage {
     inputTokens?: number;
     outputTokens?: number;
     totalTokens?: number;
     cachedReadTokens?: number;
+    cachedWriteTokens?: number;
     thoughtTokens?: number;
 }
 /** ACP usage_update notification payload (session-level). */

package/dist/types/runtime/infra/agent-paths.d.ts

@@ -7,7 +7,7 @@
  */
 /** Dot-directory name used for both user-level and project-level storage. */
 export declare const AGENT_DOT_DIR = ".qlogicagent";
-/** `~/.qlogicagent/` */
+/** `~/.qlogicagent/` (or QLOGICAGENT_HOME override) */
 export declare function getUserAgentHome(): string;
 /** `~/.qlogicagent/sessions/` */
 export declare function getUserSessionsRoot(): string;

package/dist/types/runtime/infra/index.d.ts

@@ -7,12 +7,12 @@ export { createWorktreeBackend } from "./worktree-backend.js";
 export { registerCleanup, runCleanupFunctions } from "./cleanup-registry.js";
 export { atomicWriteFile, readJsonFile, writeJsonFile, loadPersistedMemory, savePersistedMemory, getMemoryFilePath, type PersistedMemory, } from "./disk-storage.js";
 export { AcpDetector, ACP_BACKENDS } from "./acp-detector.js";
-export { AcpProtocolAdapter, type TranslatedNotification } from "./acp-protocol-adapter.js";
+export { AcpProtocolAdapter, type TranslatedNotification, type AcpHostRequestHandler } from "./acp-protocol-adapter.js";
 export { AcpUsageTracker, type AccumulatedUsage } from "./acp-usage-tracker.js";
 export { AgentConfigStore } from "./agent-config-store.js";
 export { ModelIdTranslator } from "./model-id-translator.js";
 export { SkillInjector } from "./skill-injector.js";
 export { ACP_FAULT_LEVEL, type AcpFaultLevel, buildLlmEnvForTeammate } from "./agent-process.js";
 export { McpBridge, MCP_BRIDGE_TOOLS } from "./mcp-bridge.js";
-export type { AgentCategory, AgentProtocol, AgentStatus, AcpBackendConfig, AgentDescriptor, ExternalAgentDescriptor, CustomAgentDef, AgentConfig, AgentConfigStoreData, AgentCapabilities, AcpInitializeResult, AcpSessionResult, AcpPromptResponse, AcpContentItem, AcpPromptResponseUsage, AcpUsageUpdatePayload, McpServerConfig, AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloState, SoloAgentState, SoloAgentResult, SoloEvaluation, SoloStatus, SoloStartParams, SoloIdParams, SoloSelectParams, ProductPhase, ProductInstanceState, ProductTaskStatus, ProductBudget, ProductInstanceDef, ProductTaskDef, ProductCreateParams, ProductIdParams, ProductInstanceStatus, ProductTaskState, ProductStatus, ProductSummary, AgentsGetGatewayResult, AgentsListConfiguredItem, AgentsProcessInfo, AgentsKillParams, AgentsGetLogParams, AgentsGetLogResult, AgentsTestConnectionParams, AgentsTestConnectionResult, SoloDeleteParams, ProductDeleteParams, AgentSource, } from "./acp-types.js";
+export type { AgentCategory, AgentProtocol, AgentStatus, AcpBackendConfig, AgentDescriptor, ExternalAgentDescriptor, CustomAgentDef, AgentConfig, AgentConfigStoreData, AgentCapabilities, AcpInitializeResult, AcpSessionResult, AcpPromptResponse, AcpPromptResponseUsage, AcpStopReason, AcpUsageUpdatePayload, McpServerConfig, AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloState, SoloAgentState, SoloAgentResult, SoloEvaluation, SoloStatus, SoloStartParams, SoloIdParams, SoloSelectParams, ProductPhase, ProductInstanceState, ProductTaskStatus, ProductBudget, ProductInstanceDef, ProductTaskDef, ProductCreateParams, ProductIdParams, ProductInstanceStatus, ProductTaskState, ProductStatus, ProductSummary, AgentsGetGatewayResult, AgentsListConfiguredItem, AgentsProcessInfo, AgentsKillParams, AgentsGetLogParams, AgentsGetLogResult, AgentsTestConnectionParams, AgentsTestConnectionResult, SoloDeleteParams, ProductDeleteParams, AgentSource, } from "./acp-types.js";
 export type { AgentsStatusNotification, AgentsErrorNotification, SoloProgressNotification, SoloEvaluationNotification, SoloAgentDeltaNotification, ProductTaskStartedNotification, ProductTaskCompletedNotification, ProductTaskFailedNotification, ProductCheckpointedNotification, ProductBudgetWarningNotification, ProductCompletedNotification, } from "../../protocol/notifications.js";

package/dist/types/transport/acp-event-emitter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ACP Event Emitter — translates internal qlogicagent notifications to ACP
+ * session/update notifications.
+ *
+ * Maps the 47+ internal notification methods (turn.delta, turn.tool_call, etc.)
+ * to 9 standard + 19 extended ACP sessionUpdate types.
+ *
+ * Usage: Called by the StdioServer event loop. Instead of (or in addition to)
+ * emitting raw notifications, events are translated and emitted through the
+ * AcpServer.emitSessionUpdate() method.
+ */
+import type { AcpServer } from "./acp-server.js";
+/**
+ * Translates and emits a qlogicagent internal notification as an ACP session/update.
+ *
+ * @param server The AcpServer instance to emit through
+ * @param sessionId Active ACP session ID
+ * @param method Internal notification method name
+ * @param params Internal notification payload
+ */
+export declare function emitAcpUpdate(server: AcpServer, sessionId: string, method: string, params: Record<string, unknown>): void;

package/dist/types/transport/acp-server.d.ts

@@ -0,0 +1,130 @@
+/**
+ * ACP Server — Agent-Client Protocol server layer for qlogicagent.
+ *
+ * This module implements qlogicagent as an ACP Server, allowing any ACP-compliant
+ * host (AionUI, Cursor, openclaw, etc.) to connect and interact with the agent.
+ *
+ * Protocol: ACP v1 over JSON-RPC 2.0 / stdio (line-delimited JSON).
+ *
+ * Responsibilities:
+ * - Accepts ACP standard methods: initialize, session/new, session/prompt, session/end
+ * - Accepts x/ extended methods: x/abort, x/dream, x/solo.*, x/product.*
+ * - Emits ACP session/update notifications (standard + x_ extended)
+ * - Translates host permission responses back to the agent
+ *
+ * Architecture: AcpServer wraps a Transport and delegates to an AcpRequestHandler
+ * interface. The StdioServer implements this interface by routing ACP methods to
+ * existing internal handlers.
+ */
+import type { Transport } from "../cli/transport.js";
+import { type AcpInitializeParams, type AcpInitializeResult, type AcpSessionNewParams, type AcpSessionNewResult, type AcpSessionPromptParams, type AcpSessionPromptResult, type AcpSessionEndParams, type AcpSessionSetConfigParams, type AcpSessionUpdateType, type AcpPermissionRequestParams, type AcpPermissionRequestResult } from "qlogicagent-runtime-contracts";
+export declare const ACP_ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    /** Protocol version mismatch */
+    readonly PROTOCOL_MISMATCH: -32001;
+    /** Session not found */
+    readonly SESSION_NOT_FOUND: -32002;
+    /** Agent busy (turn in progress) */
+    readonly AGENT_BUSY: -32003;
+};
+/**
+ * Interface that StdioServer (or any backend) implements to handle ACP requests.
+ * Each method corresponds to an ACP protocol method.
+ */
+export interface AcpRequestHandler {
+    handleAcpInitialize(params: AcpInitializeParams): Promise<AcpInitializeResult>;
+    handleAcpSessionNew(params: AcpSessionNewParams): Promise<AcpSessionNewResult>;
+    handleAcpSessionPrompt(params: AcpSessionPromptParams): Promise<AcpSessionPromptResult>;
+    handleAcpSessionEnd(params: AcpSessionEndParams): Promise<void>;
+    handleAcpSessionSetConfig(params: AcpSessionSetConfigParams): Promise<void>;
+    handleAcpSessionSetModel(sessionId: string, model: string): Promise<void>;
+    handleAcpSessionSetMode(sessionId: string, mode: string): Promise<void>;
+    handleAcpPermissionResponse(permissionId: string, optionId: string): void;
+    handleAcpAbort(params: {
+        sessionId: string;
+    }): Promise<void>;
+    handleAcpDream(params: {
+        sessionId: string;
+        config?: Record<string, unknown>;
+    }): Promise<{
+        ok: boolean;
+        summary?: string;
+    }>;
+    handleAcpSoloStart(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpSoloStatus(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpSoloSelect(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpProductCreate(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpProductResume(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpProductStatus(params: Record<string, unknown>): Promise<unknown>;
+    handleAcpTeamDelegate(params: Record<string, unknown>): Promise<unknown>;
+}
+export interface AcpServerConfig {
+    verbose?: boolean;
+}
+/**
+ * AcpServer — manages the ACP protocol state machine.
+ *
+ * Lifecycle:
+ * 1. Host connects (stdio)
+ * 2. Host sends `initialize` → agent responds with capabilities
+ * 3. Host sends `session/new` → session created
+ * 4. Host sends `session/prompt` → agent runs turn, emits session/update notifications
+ * 5. Host sends `session/end` → session cleaned up
+ */
+export declare class AcpServer {
+    private transport;
+    private handler;
+    private verbose;
+    /** Host capabilities declared during initialize */
+    private hostCapabilities;
+    /** Whether the host supports x_ extended events */
+    private hostSupportsExtendedEvents;
+    /** Whether the host supports x/ extended RPC methods */
+    private hostSupportsExtendedMethods;
+    /** Active session ID (ACP v1 = single session per connection) */
+    private activeSessionId;
+    /** Pending permission requests (agent → host) waiting for response */
+    private pendingPermissions;
+    constructor(transport: Transport, handler: AcpRequestHandler, config?: AcpServerConfig);
+    /**
+     * Route an incoming raw message through ACP protocol handling.
+     * Called by the unified message dispatcher in StdioServer.
+     * Returns true if the message was handled, false otherwise.
+     */
+    dispatchMessage(raw: unknown): boolean;
+    /**
+     * Emit an ACP session/update notification to the host.
+     * Standard update types are always sent; x_ types only if host declared
+     * capabilities.extendedEvents = true.
+     */
+    emitSessionUpdate(sessionId: string, type: AcpSessionUpdateType, payload: Record<string, unknown>): void;
+    /**
+     * Send a permission request to the host (agent → host RPC).
+     * Returns a promise that resolves with the host's chosen option.
+     */
+    requestPermission(params: AcpPermissionRequestParams): Promise<AcpPermissionRequestResult>;
+    /** Whether the host supports extended events */
+    get supportsExtendedEvents(): boolean;
+    /** Whether the host supports extended methods */
+    get supportsExtendedMethods(): boolean;
+    /** Get the active session ID */
+    get sessionId(): string | null;
+    private handleRequest;
+    private handleNotification;
+    private handleResponse;
+    private onInitialize;
+    private onSessionNew;
+    private onSessionPrompt;
+    private onSessionEnd;
+    private onSessionSetConfig;
+    private onAbort;
+    private onDream;
+    private sendResult;
+    private sendError;
+    private isJsonRpcResponse;
+    private log;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Transport layer — ACP Server + Event Emitter.
+ */
+export { AcpServer, ACP_ERROR_CODES } from "./acp-server.js";
+export type { AcpRequestHandler, AcpServerConfig } from "./acp-server.js";
+export { emitAcpUpdate } from "./acp-event-emitter.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",