qlogicagent 1.2.1 → 2.0.0

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/runtime/prompt/environment-context.d.ts

@@ -15,15 +15,23 @@
  *   - Available package managers
  */
 import { type SystemPromptSection } from "./system-prompt-sections.js";
+import type { TaskDomain } from "./task-domain.js";
 export type ShellType = "bash" | "powershell" | "zsh" | "cmd" | "fish" | "unknown";
 /**
  * Create a system prompt section that provides environment context.
  * Memoized — computed once per session (environment doesn't change mid-session).
  */
 export declare function createEnvironmentContextSection(cwdOverride?: string): SystemPromptSection;
+/**
+ * Create the task guidance system prompt section.
+ * Domain-aware: selects appropriate guidance based on detected or overridden task domain.
+ *
+ * @param domain - Task domain from auto-detection or host override.
+ */
+export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPromptSection;
 /**
  * Create a system prompt section that provides tool usage guidance.
- * CC parity: matches claude-code's AgentTool prompt guidance patterns.
+ * CC parity: matches claude-code's getUsingYourToolsSection().
  * Tells the LLM when to use specialized tools vs. primitives.
  */
 export declare function createToolGuidanceSection(): SystemPromptSection;

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

@@ -1,3 +1,4 @@
 export { assembleSystemPrompt, clearSystemPromptSections, systemPromptSection, type SystemPromptSection, } from "./system-prompt-sections.js";
 export { getInstructions, buildInstructionsPrompt, resetInstructionCache, } from "./instruction-loader.js";
-export { createEnvironmentContextSection } from "./environment-context.js";
+export { createEnvironmentContextSection, createTaskGuidanceSection, createToolGuidanceSection } from "./environment-context.js";
+export { detectTaskDomain, resolveTaskDomain, loadProjectTaskDomain, persistTaskDomain, shouldPersistDomain, type TaskDomain, type DomainResolutionContext } from "./task-domain.js";

package/dist/types/runtime/prompt/task-domain.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Task Domain Detection — three-tier domain resolution for system prompt routing.
+ *
+ * qlogicagent handles coding, office, AND creative tasks.
+ * A coding-only system prompt hurts non-coding performance.
+ *
+ * Resolution priority (highest → lowest):
+ *   1. Project file: `.qlogicagent/settings.yaml` → `taskDomain: coding`
+ *      Persisted, user-editable, checked into repo. Strongest signal.
+ *   2. Host override: `config.taskDomain` in thread.turn params.
+ *      Set by Electron/Hub per-request.
+ *   3. Session sticky: once a domain is established in a session,
+ *      keep it unless a new turn has a STRONG signal for a different domain.
+ *   4. Auto-detect: regex keyword matching on the current user message.
+ *      Falls back to "general" if ambiguous.
+ *
+ * The `resolveTaskDomain()` function implements this full chain.
+ * The `detectTaskDomain()` function is the low-level keyword matcher (tier 4).
+ */
+/**
+ * Task domain determines which system prompt sections are injected.
+ *
+ * - "coding" — software engineering: bug fixes, refactoring, code gen, etc.
+ * - "office" — data analysis, reports, documents, spreadsheets, emails
+ * - "creative" — writing, copywriting, marketing, storytelling, brainstorming
+ * - "general" — undetectable or mixed domain, uses universal guidance
+ */
+export type TaskDomain = "coding" | "office" | "creative" | "general";
+/**
+ * Load task domain from project-level `.qlogicagent/settings.yaml`.
+ * Returns undefined if file doesn't exist or doesn't contain a valid domain.
+ *
+ * Uses sync I/O — called once per turn, file is tiny (<1KB).
+ * Simple key:value parser (no YAML dependency needed for this).
+ */
+export declare function loadProjectTaskDomain(cwd: string): TaskDomain | undefined;
+/**
+ * Detect task domain from user message text (tier 4 — lowest priority).
+ * Uses keyword matching — fast, no LLM call.
+ */
+export declare function detectTaskDomain(userText: string): TaskDomain;
+export interface DomainResolutionContext {
+    /** Current working directory (for project file lookup). */
+    cwd: string;
+    /** Host-provided override from config.taskDomain. */
+    hostOverride?: TaskDomain;
+    /** Previous session domain (for stickiness). */
+    sessionDomain?: TaskDomain;
+    /** Current turn's user message text. */
+    userText: string;
+}
+/**
+ * Full domain resolution chain — implements the four-tier priority:
+ *   1. Project file (.qlogicagent/settings.yaml or INSTRUCTIONS.md frontmatter)
+ *   2. Host override (config.taskDomain)
+ *   3. Session stickiness (keep previous domain unless strong signal)
+ *   4. Auto-detect from keywords
+ *
+ * Returns both the resolved domain and a "source" tag for debugging.
+ */
+export declare function resolveTaskDomain(ctx: DomainResolutionContext): {
+    domain: TaskDomain;
+    source: "project-file" | "host-override" | "session-sticky" | "auto-detect";
+};
+/**
+ * Persist the detected task domain to `.qlogicagent/settings.yaml`.
+ *
+ * This runs once per workspace — subsequent sessions skip auto-detect
+ * and hit Tier 1 (project file) directly.
+ *
+ * Conditions for writing:
+ *   - `domain` is NOT "general" (ambiguous → don't commit)
+ *   - No existing `settings.yaml` with a `taskDomain` line
+ *   - The auto-detect score was above the confidence threshold
+ *
+ * The written file is user-editable and meant to be checked into the repo.
+ */
+export declare function persistTaskDomain(cwd: string, domain: TaskDomain): boolean;
+/**
+ * Check if auto-detect scored high enough to justify persisting.
+ */
+export declare function shouldPersistDomain(userText: string, domain: TaskDomain): boolean;

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

@@ -1,5 +1,5 @@
 export type { PortableTool, PortableToolResult, ToolContentBlock, } from "./portable-tool.js";
-export { setToolPool, addTool, addTools, removeTool, findTool, hasTool, getToolNames, getToolCount, executeTool, getToolManifest, getTools, AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent, } from "./tools.js";
+export { setToolPool, addTool, addTools, removeTool, findTool, hasTool, getToolNames, getToolCount, executeTool, getToolManifest, getTools, activateTool, isToolActivated, clearActivatedTools, AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent, } from "./tools.js";
 export { MEMORY_TOOL_NAME, MEMORY_TOOL_MAX_CONTENT_LENGTH, MEMORY_TOOL_ACTIONS, MEMORY_TOOL_SCHEMA, MEMORY_TOOL_DESCRIPTION, MEMORY_TOOL_LABEL, isMemoryContentSafe, executeMemoryTool, } from "./memory/memory-tool.js";
 export type { MemoryToolAction, MemoryToolParams, MemoryToolResult, MemoryToolExecutorDeps, MediaPreferencesSummary, } from "./memory/memory-tool.js";
 export { MemoryStore, MEMORY_ENTRY_DELIMITER, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_USER_CHAR_LIMIT, } from "./memory/memory-store.js";

package/dist/types/skills/tools/media-cancel-tool.d.ts

@@ -0,0 +1,30 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const MEDIA_CANCEL_TOOL_NAME: "media_cancel";
+export interface MediaCancelToolParams {
+    task_id: string;
+    provider?: string;
+}
+export declare const MEDIA_CANCEL_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly task_id: {
+            readonly type: "string";
+            readonly description: "The task ID of the media generation to cancel (returned in previous generation results).";
+        };
+        readonly provider: {
+            readonly type: "string";
+            readonly description: "Provider name (e.g. 'doubao', 'zhipu'). If omitted, auto-detects from task context.";
+        };
+    };
+    readonly required: readonly ["task_id"];
+};
+export interface MediaCancelToolDeps {
+    cancelTask(params: {
+        taskId: string;
+        provider?: string;
+    }): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare function createMediaCancelTool(deps: MediaCancelToolDeps): PortableTool<MediaCancelToolParams>;

package/dist/types/skills/tools/shell/index.d.ts

@@ -13,5 +13,6 @@ export { TaskOutput, generateTaskId, getTaskOutputDir, setTaskOutputDir, getTask
 export type { ProgressCallback } from "./task-output.js";
 export type { ExecResult, ShellCommand } from "./shell-command.js";
 export { wrapSpawn, createAbortedCommand, createFailedCommand, } from "./shell-command.js";
+export { subprocessEnv } from "./subprocess-env.js";
 export { exec, getCwd, setCwd, initCwd, getOriginalCwd, setShellProvider, getShellProvider, } from "./shell-exec.js";
 export type { ExecOptions } from "./shell-exec.js";

package/dist/types/skills/tools/shell/subprocess-env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return a copy of `process.env` with sensitive variables removed.
+ * The allowlist includes vars known to be safe for child shells
+ * (PATH, HOME, LANG, TERM, etc.).
+ */
+export declare function subprocessEnv(): NodeJS.ProcessEnv;

package/dist/types/skills/tools/three-d-generate-tool.d.ts

@@ -32,6 +32,7 @@ export interface ThreeDGenerateResult {
     mediaUrls: string[];
     model?: string;
     durationMs?: number;
+    metadata?: Record<string, unknown>;
 }
 /** Deps injected by the host runtime for 3D generation. */
 export interface ThreeDGenerateToolDeps {

package/dist/types/skills/tools.d.ts

@@ -57,9 +57,24 @@ export declare function executeTool(name: string, toolCallId: string, args: Reco
  * CC reference: claude-code-haha/src/tools.ts getTools()
  */
 export declare function getTools(): PortableTool[];
+/**
+ * Activate a deferred tool so it appears in subsequent LLM manifests.
+ * CC parity: tool_search select: → activateTool → tool included in manifest.
+ * Returns true if the tool exists, is enabled, and was activated.
+ */
+export declare function activateTool(name: string): boolean;
+/**
+ * Check if a tool has been activated via tool_search.
+ */
+export declare function isToolActivated(name: string): boolean;
+/**
+ * Clear all tool activations (call at session/turn boundary if needed).
+ */
+export declare function clearActivatedTools(): void;
 /**
  * Generate ToolDefinition[] manifest for LLM tool_use.
  * Filters by isEnabled() — disabled tools never reach the model.
+ * Deferred tools are excluded UNLESS they have been activated via tool_search.
  * CC: getTools() + manifest generation combined.
  */
 export declare function getToolManifest(includeDeferred?: boolean): ToolDefinition[];

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.2.1",
+  "version": "2.0.0",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",