qlogicagent 0.5.2 → 0.5.3

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

@@ -0,0 +1,125 @@
+export type { PortableTool, PortableToolResult, ToolContentBlock, } from "./portable-tool.js";
+export { ToolRegistry } from "./tool-registry.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-tool.js";
+export type { MemoryToolAction, MemoryToolParams, MemoryToolResult, MemoryToolExecutorDeps, } from "./memory-tool.js";
+export { MemoryStore, MEMORY_ENTRY_DELIMITER, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_USER_CHAR_LIMIT, } from "./memory-store.js";
+export type { MemoryStoreTarget, MemoryStoreResult, MemoryStoreOptions, MemoryStoreSerialized, } from "./memory-store.js";
+export { createQMemoryAdapter } from "./qmemory-adapter.js";
+export type { QMemoryAdapterConfig, QMemoryHealthStatus, ExtractedMemoryItem } from "./qmemory-adapter.js";
+export { createMemoryExtractor } from "./memory-extractor.js";
+export type { ExtractedMemory, ProfileUpdate, ExtractionResult, ExtractionCompleteFn, MemoryExtractorOptions, } from "./memory-extractor.js";
+export { THINK_TOOL_NAME, THINK_TOOL_SCHEMA, createThinkTool } from "./think-tool.js";
+export type { ThinkToolParams } from "./think-tool.js";
+export { TODO_TOOL_NAME, TODO_TOOL_SCHEMA, createTodoTool } from "./todo-tool.js";
+export type { TodoToolParams, TodoToolOptions } from "./todo-tool.js";
+export { MEMORY_QUERY_TOOL_NAME, MEMORY_QUERY_TOOL_SCHEMA, createMemoryQueryTool, } from "./memory-query-tool.js";
+export type { MemoryQueryToolParams, MemoryQueryToolDeps, MediaPreferencesSummary, } from "./memory-query-tool.js";
+export { READ_TOOL_NAME, READ_TOOL_SCHEMA, createReadTool } from "./tools/read-tool.js";
+export type { ReadToolParams, ReadToolDeps, ReadResultType } from "./tools/read-tool.js";
+export { WRITE_TOOL_NAME, WRITE_TOOL_SCHEMA, createWriteTool } from "./tools/write-tool.js";
+export type { WriteToolParams, WriteToolDeps } from "./tools/write-tool.js";
+export { EDIT_TOOL_NAME, EDIT_TOOL_SCHEMA, createEditTool } from "./tools/edit-tool.js";
+export type { EditToolParams, EditToolDeps } from "./tools/edit-tool.js";
+export { APPLY_PATCH_TOOL_NAME, APPLY_PATCH_TOOL_SCHEMA, createApplyPatchTool } from "./tools/apply-patch-tool.js";
+export type { ApplyPatchToolParams, ApplyPatchToolDeps, ApplyPatchSummary } from "./tools/apply-patch-tool.js";
+export { PDF_TOOL_NAME, PDF_TOOL_SCHEMA, createPdfTool } from "./tools/pdf-tool.js";
+export type { PdfToolParams, PdfToolDeps } from "./tools/pdf-tool.js";
+export { EXEC_TOOL_NAME, EXEC_TOOL_SCHEMA, createExecTool, ASSISTANT_BLOCKING_BUDGET_MS } from "./tools/exec-tool.js";
+export type { ExecToolParams, ExecToolHost, ExecProgress, ExecToolOutput } from "./tools/exec-tool.js";
+export { isPowerShellToolEnabled, getDefaultShellType, generateCommandId, createBashProvider, createPowerShellProvider, encodePowerShellCommand, classifyCommand, commandHasAnyCd, SEARCH_COMMANDS, READ_COMMANDS, LIST_COMMANDS, SILENT_COMMANDS, SAFE_ENV_VARS, BARE_SHELL_PREFIXES, stripSafeWrappers, stripAllLeadingEnvVars, getSimpleCommandPrefix, getFirstWordPrefix, stripWrappersFromArgv, detectBlockedSleepPattern, TaskOutput, generateTaskId, getTaskOutputDir, setTaskOutputDir, getTaskOutputPath, MAX_TASK_OUTPUT_BYTES, wrapSpawn, createAbortedCommand, createFailedCommand, exec, getCwd, setCwd, initCwd, getOriginalCwd, setShellProvider, getShellProvider, } from "./tools/shell/index.js";
+export type { ShellType, ShellProvider, BuildCommandOpts, BuiltCommand, BashProviderOptions, CommandClassification, ProgressCallback, ExecResult, ShellCommand, ExecOptions, } from "./tools/shell/index.js";
+export { SEARCH_TOOL_NAME, SEARCH_TOOL_SCHEMA, createSearchTool } from "./tools/search-tool.js";
+export type { SearchToolParams, SearchToolDeps, SearchMode, SearchOutput, SearchFileResult, SearchContentResult, } from "./tools/search-tool.js";
+export { IMAGE_GENERATE_TOOL_NAME, IMAGE_GENERATE_TOOL_SCHEMA, createImageGenerateTool } from "./tools/image-generate-tool.js";
+export type { ImageGenerateToolParams, ImageGenerateToolDeps, ImageGenerateResult } from "./tools/image-generate-tool.js";
+export { VIDEO_GENERATE_TOOL_NAME, VIDEO_GENERATE_TOOL_SCHEMA, createVideoGenerateTool } from "./tools/video-generate-tool.js";
+export type { VideoGenerateToolParams, VideoGenerateToolDeps, VideoGenerateResult } from "./tools/video-generate-tool.js";
+export { VIDEO_MERGE_TOOL_NAME, VIDEO_MERGE_TOOL_SCHEMA, createVideoMergeTool } from "./tools/video-merge-tool.js";
+export type { VideoMergeToolParams, VideoMergeToolDeps, VideoMergeClip, VideoMergeResult } from "./tools/video-merge-tool.js";
+export { VIDEO_UPSCALE_TOOL_NAME, VIDEO_UPSCALE_TOOL_SCHEMA, createVideoUpscaleTool } from "./tools/video-upscale-tool.js";
+export type { VideoUpscaleToolParams, VideoUpscaleToolDeps, VideoUpscaleResult } from "./tools/video-upscale-tool.js";
+export { VIDEO_EDIT_TOOL_NAME, VIDEO_EDIT_TOOL_SCHEMA, createVideoEditTool } from "./tools/video-edit-tool.js";
+export type { VideoEditToolParams, VideoEditToolDeps, VideoEditResult } from "./tools/video-edit-tool.js";
+export { MUSIC_GENERATE_TOOL_NAME, MUSIC_GENERATE_TOOL_SCHEMA, createMusicGenerateTool } from "./tools/music-generate-tool.js";
+export type { MusicGenerateToolParams, MusicGenerateToolDeps, MusicGenerateResult } from "./tools/music-generate-tool.js";
+export { TTS_TOOL_NAME, TTS_TOOL_SCHEMA, createTtsTool } from "./tools/tts-tool.js";
+export type { TtsToolParams, TtsToolDeps, TtsResult } from "./tools/tts-tool.js";
+export { WEB_FETCH_TOOL_NAME, WEB_FETCH_TOOL_SCHEMA, createWebFetchTool } from "./tools/web-fetch-tool.js";
+export type { WebFetchToolParams, WebFetchToolDeps, WebFetchResult } from "./tools/web-fetch-tool.js";
+export { WEB_SEARCH_TOOL_NAME, WEB_SEARCH_TOOL_SCHEMA, createWebSearchTool } from "./tools/web-search-tool.js";
+export type { WebSearchToolParams, WebSearchToolDeps, WebSearchResult, WebSearchOutput } from "./tools/web-search-tool.js";
+export { ASK_USER_TOOL_NAME, ASK_USER_TOOL_SCHEMA, createAskUserTool } from "./tools/ask-user-tool.js";
+export type { AskUserToolParams, AskUserToolDeps, AskUserQuestion, AskUserOption, AskUserAnswer } from "./tools/ask-user-tool.js";
+export { BRIEF_TOOL_NAME, BRIEF_TOOL_SCHEMA, createBriefTool } from "./tools/brief-tool.js";
+export type { BriefToolParams, BriefToolDeps, BriefMessageStatus, BriefAttachment, BriefDeliveryResult, BriefModeConfig, } from "./tools/brief-tool.js";
+export { TOOL_SEARCH_TOOL_NAME, TOOL_SEARCH_TOOL_SCHEMA, createToolSearchTool } from "./tools/tool-search-tool.js";
+export type { ToolSearchToolParams, ToolSearchToolDeps, DeferredToolInfo, ToolSearchOutput } from "./tools/tool-search-tool.js";
+export { SKILL_LIST_TOOL_NAME, SKILL_LIST_TOOL_SCHEMA, createSkillListTool } from "./tools/skill-list-tool.js";
+export type { SkillListToolParams, SkillListToolDeps, SkillListItem, SkillListOutput } from "./tools/skill-list-tool.js";
+export { SKILL_VIEW_TOOL_NAME, SKILL_VIEW_TOOL_SCHEMA, createSkillViewTool } from "./tools/skill-view-tool.js";
+export type { SkillViewToolParams, SkillViewToolDeps, SkillViewOutput } from "./tools/skill-view-tool.js";
+export { SKILL_MANAGE_TOOL_NAME, SKILL_MANAGE_TOOL_SCHEMA, createSkillManageTool } from "./tools/skill-manage-tool.js";
+export type { SkillManageToolParams, SkillManageToolDeps, SkillManageResult, SkillManageAction } from "./tools/skill-manage-tool.js";
+export { PATCH_TOOL_NAME, PATCH_TOOL_SCHEMA, createPatchTool, fuzzyFind } from "./tools/patch-tool.js";
+export type { PatchToolParams, PatchToolDeps, PatchResult, MatchStrategy, MatchResult } from "./tools/patch-tool.js";
+export { AGENT_TOOL_NAME, AGENT_TOOL_SCHEMA, createAgentTool } from "./tools/agent-tool.js";
+export type { AgentToolParams, AgentToolDeps, AgentResult } from "./tools/agent-tool.js";
+export { TASK_TOOL_NAME, TASK_TOOL_SCHEMA, createTaskTool } from "./tools/task-tool.js";
+export type { TaskToolParams, TaskToolDeps, TaskInfo, TaskResult, TaskAction, TaskStatus } from "./tools/task-tool.js";
+export { REPL_TOOL_NAME, REPL_TOOL_SCHEMA, REPL_HIDES_TOOLS, createReplTool } from "./tools/repl-tool.js";
+export type { ReplToolParams, ReplToolDeps, ReplPrimitives, ReplExecResult } from "./tools/repl-tool.js";
+export { BROWSER_TOOL_NAME, BROWSER_TOOL_SCHEMA, createBrowserTool } from "./tools/browser-tool.js";
+export type { BrowserToolParams, BrowserToolDeps, BrowserAction, BrowserSnapshot, BrowserScreenshot } from "./tools/browser-tool.js";
+export { CRON_TOOL_NAME, CRON_TOOL_SCHEMA, MAX_CRON_JOBS, createCronTool } from "./tools/cron-tool.js";
+export type { CronToolParams, CronToolDeps, CronJob, CronResult, CronAction } from "./tools/cron-tool.js";
+export { MEMORY_SEARCH_TOOL_NAME, MEMORY_SEARCH_TOOL_SCHEMA, createMemorySearchTool } from "./tools/memory-tool.js";
+export type { MemorySearchToolParams, MemorySearchToolDeps, MemoryEntry, MemoryQueryOutput, MemorySource } from "./tools/memory-tool.js";
+export { CHECKPOINT_TOOL_NAME, CHECKPOINT_TOOL_SCHEMA, createCheckpointTool } from "./tools/checkpoint-tool.js";
+export type { CheckpointToolParams, CheckpointToolDeps, Checkpoint, CheckpointResult, CheckpointAction } from "./tools/checkpoint-tool.js";
+export { NOTIFY_TOOL_NAME, NOTIFY_TOOL_SCHEMA, createNotifyTool } from "./tools/notify-tool.js";
+export type { NotifyToolParams, NotifyToolDeps, NotifyResult } from "./tools/notify-tool.js";
+export { SEND_MESSAGE_TOOL_NAME, SEND_MESSAGE_TOOL_SCHEMA, createSendMessageTool } from "./tools/send-message-tool.js";
+export type { SendMessageToolParams, SendMessageToolDeps, SendMessageResult } from "./tools/send-message-tool.js";
+export { TEAM_TOOL_NAME, TEAM_TOOL_SCHEMA, createTeamTool } from "./tools/team-tool.js";
+export type { TeamToolParams, TeamToolDeps, TeamMember, Team, TeamResult, TeamAction } from "./tools/team-tool.js";
+export { LSP_TOOL_NAME, LSP_TOOL_SCHEMA, createLspTool } from "./tools/lsp-tool.js";
+export type { LspToolParams, LspToolDeps, LspOperation, LspLocation, LspSymbol, LspDiagnostic, LspHoverInfo, LspCompletion, LspRenameEdit, LspCodeAction, LspResult } from "./tools/lsp-tool.js";
+export { PLAN_MODE_TOOL_NAME, PLAN_MODE_TOOL_SCHEMA, PLAN_MODE_ALLOWED_TOOLS, createPlanModeTool } from "./tools/plan-mode-tool.js";
+export type { PlanModeToolParams, PlanModeToolDeps, PlanModeAction, PlanModeState, PlanModeResult } from "./tools/plan-mode-tool.js";
+export { WORKTREE_TOOL_NAME, WORKTREE_TOOL_SCHEMA, createWorktreeTool } from "./tools/worktree-tool.js";
+export type { WorktreeToolParams, WorktreeToolDeps, WorktreeAction, WorktreeInfo, WorktreeResult } from "./tools/worktree-tool.js";
+export { MCP_TOOL_NAME, MCP_TOOL_SCHEMA, createMcpTool, createMcpAuthProxy } from "./tools/mcp-tool.js";
+export { normalizeNameForMcp, buildMcpToolName, getMcpServerPrefix, parseMcpToolName, isMcpToolName, MCP_CONNECTION_TIMEOUT_MS, MCP_REQUEST_TIMEOUT_MS, MCP_TOOL_CALL_TIMEOUT_MS, MCP_MAX_RECONNECT_ATTEMPTS, MCP_MAX_DESCRIPTION_LENGTH, } from "./tools/mcp-tool.js";
+export type { McpToolParams, McpToolDeps, McpAction, McpManageAction, McpServer, McpToolInfo, McpResource, McpResourceContent, McpCallResult, McpAuthResult, McpPromptResult, McpManageResult, McpAuthProxyDeps, McpServerConfig, McpStdioConfig, McpSseConfig, McpHttpConfig, McpWsConfig, McpInProcessConfig, McpServerState, McpConnectionStatus, McpServerCapabilities, McpExternalTool, McpToolAnnotations, McpToolIdentifier, McpToolsChangedEvent, McpResourceDefinition, McpResourceTemplate, McpPersistedResourceContent, McpPromptDefinition, McpPromptMessage, McpPromptArgument, McpPromptContent, McpElicitResult, McpElicitRequest, McpOAuthConfig, McpOAuthTokens, McpAuthState, McpLogEntry, McpLogLevel, McpTransportType, } from "./tools/mcp-tool.js";
+export type { McpResourceContentItem, } from "./tools/mcp-client-types.js";
+export { CONFIG_TOOL_NAME, CONFIG_TOOL_SCHEMA, CONFIG_READONLY_KEYS, createConfigTool } from "./tools/config-tool.js";
+export type { ConfigToolParams, ConfigToolDeps, ConfigAction, ConfigSetting, ConfigResult } from "./tools/config-tool.js";
+export { SLEEP_TOOL_NAME, SLEEP_TOOL_SCHEMA, createSleepTool } from "./tools/sleep-tool.js";
+export type { SleepToolParams, SleepToolDeps, SleepResult } from "./tools/sleep-tool.js";
+export { MONITOR_TOOL_NAME, MONITOR_TOOL_SCHEMA, createMonitorTool } from "./tools/monitor-tool.js";
+export type { MonitorToolParams, MonitorToolDeps, MonitorSource, MonitorAction, MonitorCondition, MonitorInfo, MonitorResult, } from "./tools/monitor-tool.js";
+export { STRUCTURED_OUTPUT_TOOL_NAME, STRUCTURED_OUTPUT_TOOL_SCHEMA, STRUCTURED_OUTPUT_MAX_CHARS, createStructuredOutputTool, createConfiguredStructuredOutputTool, isStructuredOutputEnabled, } from "./tools/structured-output-tool.js";
+export type { StructuredOutputToolParams, StructuredOutputToolDeps, StructuredOutputResult, SchemaValidationError, ConfiguredToolResult, SchemaCompiler, } from "./tools/structured-output-tool.js";
+export { INSTRUCTIONS_LIST_TOOL_NAME, INSTRUCTIONS_LIST_SCHEMA, createInstructionsListTool, INSTRUCTIONS_READ_TOOL_NAME, INSTRUCTIONS_READ_SCHEMA, createInstructionsReadTool, INSTRUCTIONS_WRITE_TOOL_NAME, INSTRUCTIONS_WRITE_SCHEMA, createInstructionsWriteTool, INSTRUCTIONS_DELETE_TOOL_NAME, INSTRUCTIONS_DELETE_SCHEMA, createInstructionsDeleteTool, } from "./tools/instructions-tool.js";
+export type { InstructionFileInfo, InstructionFileContent, InstructionsToolDeps, InstructionsListParams, InstructionsReadParams, InstructionsWriteParams, InstructionsDeleteParams, } from "./tools/instructions-tool.js";
+export type { ParsedSkillFrontmatter, WorkspaceSkill, SkillInstallSpec, SkillMetadata, SkillInvocationPolicy, SkillEntry, SkillCommandDispatchSpec, SkillCommandSpec, SkillSnapshot, SkillScanSeverity, SkillScanFinding, SkillScanSummary, SkillScanOptions, SkillFsDeps, SkillPathDeps, SkillLoadLimits, SkillSearchPaths, SkillLoaderDeps, } from "./skill-types.js";
+export { parseFrontmatter, resolveSkillMetadata, resolveSkillInvocationPolicy, resolveSkillKey, } from "./skill-frontmatter.js";
+export { loadSkillEntries, filterSkillEntries, buildSkillSnapshot, } from "./skill-loader.js";
+export { scanSource, scanSkillDirectory, hasCriticalFindings, isScannable, } from "./skill-guard.js";
+export type { SkillGuardDeps } from "./skill-guard.js";
+export { installSkill, uninstallSkill, createEmptyLockfile, } from "./skill-source.js";
+export type { TrustLevel, ScanVerdict, SkillSourceDescriptor, SkillFetchResult, SkillFetchDeps, SkillStorageDeps, SkillLockEntry, SkillLockfile, SkillInstallResult, } from "./skill-source.js";
+export { SKILL_TOOL_NAME, SKILL_INVOKE_SCHEMA, createSkillTool } from "./tools/skill-invoke-tool.js";
+export type { SkillInvokeParams, SkillToolDeps } from "./tools/skill-invoke-tool.js";
+export { McpStdioClient } from "./mcp/mcp-stdio-client.js";
+export { McpManager, parseMcpConfig } from "./mcp/mcp-manager.js";
+export type { McpServerEntry, McpManagerConfig } from "./mcp/mcp-manager.js";
+export { PluginLoader } from "./plugins/plugin-loader.js";
+export { PLUGIN_HOOK_MAP } from "./plugins/plugin-api.js";
+export type { PluginApi, PluginModule, PluginHookPhase } from "./plugins/plugin-api.js";
+export type { PluginLoaderConfig } from "./plugins/plugin-loader.js";
+export type { LoadedPlugin } from "./plugins/plugin-api.js";
+export { PermissionRuleEngine, parsePermissionConfig } from "./permissions/rule-engine.js";
+export { PermissionChecker } from "./permissions/hook-runner.js";
+export type { PermissionCheckerDeps } from "./permissions/hook-runner.js";
+export type { PermissionMode, PermissionBehavior, PermissionResult, PermissionRuleEntry, PermissionConfig, PermissionUpdate, PermissionDecisionReason, ToolPermissionCheckInput, ApprovalRequest, ApprovalResponse, } from "./permissions/types.js";

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

@@ -0,0 +1,3 @@
+export { McpStdioClient, type McpStdioClientConfig } from "./mcp-stdio-client.js";
+export { McpHttpClient, type McpHttpClientConfig } from "./mcp-http-client.js";
+export { McpManager, parseMcpConfig, type McpServerEntry, type McpManagerConfig } from "./mcp-manager.js";

package/dist/types/skills/mcp/mcp-http-client.d.ts

@@ -0,0 +1,66 @@
+import type { PortableTool } from "../portable-tool.js";
+interface McpToolSchema {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+interface McpToolCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+export interface McpHttpClientConfig {
+    /** Unique name for this MCP server instance */
+    name: string;
+    /** HTTP endpoint URL (e.g. "http://localhost:3000/mcp") */
+    url: string;
+    /** Extra headers for every request */
+    headers?: Record<string, string>;
+    /** Timeout for initialization handshake (ms, default: 30000) */
+    initTimeoutMs?: number;
+    /** Timeout for tool calls (ms, default: 120000) */
+    toolCallTimeoutMs?: number;
+}
+export declare class McpHttpClient {
+    private connected;
+    private toolsCache;
+    private serverName;
+    private serverVersion;
+    private sessionId;
+    private onToolsChanged;
+    readonly config: McpHttpClientConfig;
+    constructor(config: McpHttpClientConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    callTool(toolName: string, args?: Record<string, unknown>, signal?: AbortSignal): Promise<McpToolCallResult>;
+    listResources(): Promise<Array<{
+        uri: string;
+        name: string;
+        mimeType?: string;
+        description?: string;
+    }>>;
+    readResource(uri: string): Promise<Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    }>>;
+    toPortableTools(): PortableTool[];
+    getCachedTools(): McpToolSchema[];
+    get isConnected(): boolean;
+    get info(): {
+        name: string;
+        version: string;
+    };
+    setOnToolsChanged(callback: () => void): void;
+    private refreshTools;
+    private sendRequest;
+    private sendNotification;
+    private parseSSEResponse;
+    private schemaToPortableTool;
+}
+export {};

package/dist/types/skills/mcp/mcp-manager.d.ts

@@ -0,0 +1,84 @@
+import type { ToolRegistry } from "../tool-registry.js";
+/** MCP resource entry from resources/list */
+export interface McpResourceEntry {
+    uri: string;
+    name: string;
+    mimeType?: string;
+    description?: string;
+}
+/** MCP resource content from resources/read */
+export interface McpResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+export interface McpServerEntry {
+    /** Server display name */
+    name: string;
+    /** Transport type: "stdio" (default) or "http" */
+    type?: "stdio" | "http";
+    /** Command to spawn (stdio only) */
+    command?: string;
+    /** Command arguments (stdio only) */
+    args?: string[];
+    /** Extra environment variables (stdio only) */
+    env?: Record<string, string>;
+    /** HTTP endpoint URL (http only) */
+    url?: string;
+    /** Extra HTTP headers (http only) */
+    headers?: Record<string, string>;
+    /** Init timeout (ms) */
+    initTimeoutMs?: number;
+    /** Whether this server is disabled (skip connection) */
+    disabled?: boolean;
+}
+export interface McpManagerConfig {
+    servers: McpServerEntry[];
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+export declare class McpManager {
+    private clients;
+    private registry;
+    private log;
+    constructor(config: McpManagerConfig);
+    /**
+     * Connect to all configured MCP servers. Failures are logged but don't block.
+     */
+    connectAll(): Promise<void>;
+    /**
+     * Register all MCP tools into the given ToolRegistry.
+     */
+    injectTools(registry: ToolRegistry): void;
+    /**
+     * Get names of all connected servers.
+     */
+    getConnectedServers(): string[];
+    /**
+     * Get total number of MCP tools across all servers.
+     */
+    getToolCount(): number;
+    /**
+     * Disconnect all MCP servers.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * List resources from all connected MCP servers (or a specific one).
+     */
+    listResources(serverName?: string): Promise<Array<McpResourceEntry & {
+        server: string;
+    }>>;
+    /**
+     * Read a resource from a specific MCP server by URI.
+     */
+    readResource(serverName: string, uri: string): Promise<McpResourceContent[]>;
+    private reinjectTools;
+}
+/**
+ * Parse MCP server configs from a JSON structure (mcp.json format).
+ * Compatible with Claude Code's mcp_servers.json structure.
+ */
+export declare function parseMcpConfig(json: unknown): McpServerEntry[];

package/dist/types/skills/mcp/mcp-stdio-client.d.ts

@@ -0,0 +1,84 @@
+import type { PortableTool } from "../portable-tool.js";
+interface McpToolSchema {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+interface McpToolCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+}
+export interface McpStdioClientConfig {
+    /** Unique name for this MCP server instance */
+    name: string;
+    /** Command to spawn (e.g. "npx", "uvx", "node") */
+    command: string;
+    /** Arguments to pass to the command */
+    args?: string[];
+    /** Environment variables (merged with process.env) */
+    env?: Record<string, string>;
+    /** Working directory for the subprocess */
+    cwd?: string;
+    /** Timeout for initialization handshake (ms, default: 30000) */
+    initTimeoutMs?: number;
+}
+export declare class McpStdioClient {
+    private process;
+    private readline;
+    private pending;
+    private nextId;
+    private connected;
+    private toolsCache;
+    private serverName;
+    private serverVersion;
+    private supportsToolsListChanged;
+    private onToolsChanged;
+    private stderrBuffer;
+    readonly config: McpStdioClientConfig;
+    constructor(config: McpStdioClientConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    get isConnected(): boolean;
+    get info(): {
+        name: string;
+        version: string;
+    };
+    refreshTools(): Promise<McpToolSchema[]>;
+    getCachedTools(): McpToolSchema[];
+    callTool(toolName: string, args?: Record<string, unknown>, signal?: AbortSignal): Promise<McpToolCallResult>;
+    listResources(): Promise<Array<{
+        uri: string;
+        name: string;
+        mimeType?: string;
+        description?: string;
+    }>>;
+    readResource(uri: string): Promise<Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    }>>;
+    /**
+     * Convert MCP tools to PortableTool instances for ToolRegistry.
+     * Tool names are prefixed: mcp__{serverName}__{toolName}
+     */
+    toPortableTools(): PortableTool[];
+    /**
+     * Register callback for tools/list_changed notifications.
+     */
+    setOnToolsChanged(callback: (() => void) | null): void;
+    private executeAsTool;
+    private sendRequest;
+    private sendNotification;
+    private writeLine;
+    private handleLine;
+    private handleNotification;
+    private handleProcessError;
+    private handleProcessExit;
+}
+export {};

package/dist/types/skills/memory-extractor.d.ts

@@ -0,0 +1,64 @@
+export interface ExtractedMemory {
+    text: string;
+    category: string;
+    importance: number;
+    speaker: string;
+    event_date?: string;
+    tags?: string[];
+}
+export interface ProfileUpdate {
+    category: string;
+    key: string;
+    value: string;
+    confidence: number;
+}
+export interface ExtractionResult {
+    memories: ExtractedMemory[];
+    profileUpdates: ProfileUpdate[];
+}
+/**
+ * Generic OpenAI-compatible chat completion function.
+ * Consumer provides the actual HTTP transport (e.g. admin/new-api fetch).
+ */
+export type ExtractionCompleteFn = (params: {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    tools: unknown[];
+    tool_choice: unknown;
+    temperature?: number;
+    max_tokens?: number;
+}) => Promise<{
+    choices?: Array<{
+        message?: {
+            tool_calls?: Array<{
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
+            content?: string;
+        };
+    }>;
+}>;
+export interface MemoryExtractorOptions {
+    /** Model to use for extraction (default: "deepseek-chat"). */
+    model?: string;
+    /** Timeout in ms for the LLM call (default: 30_000). */
+    timeoutMs?: number;
+}
+/**
+ * Create a memory extractor backed by an OpenAI-compatible LLM endpoint.
+ *
+ * The `complete` function is injected by the consumer so that
+ * skills layer stays transport-agnostic (no admin/new-api dependency).
+ */
+export declare function createMemoryExtractor(complete: ExtractionCompleteFn, options?: MemoryExtractorOptions): {
+    /**
+     * Extract structured memories from a conversation fragment.
+     * Returns empty result if text is too short or LLM call fails.
+     */
+    extract(conversationText: string): Promise<ExtractionResult>;
+};

package/dist/types/skills/memory-query-tool.d.ts

@@ -0,0 +1,43 @@
+import type { PortableTool } from "./portable-tool.js";
+export declare const MEMORY_QUERY_TOOL_NAME: "memory_query";
+export declare const MEMORY_QUERY_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly category: {
+            readonly type: "string";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["query"];
+};
+export interface MediaPreferencesSummary {
+    imageStyle?: string;
+    videoStyle?: string;
+    musicGenre?: string;
+    musicMood?: string;
+    primaryPurpose?: string;
+    colorPreference?: string;
+}
+/**
+ * Dependency-injected callbacks for memory query.
+ * Consumers provide these from their own memory system.
+ */
+export interface MemoryQueryToolDeps {
+    /** Query recalled facts/memories by natural language. */
+    queryGraph?: (query: string, userId: string) => string[];
+    /** Retrieve user profile summary. */
+    getProfileSummary?: (userId: string) => string | null;
+    /** Retrieve media preferences. */
+    getMediaPreferences?: (userId: string) => MediaPreferencesSummary | null;
+    /** User ID for this session. */
+    userId?: string;
+}
+export interface MemoryQueryToolParams {
+    query: string;
+    category?: string;
+}
+export declare function createMemoryQueryTool(deps?: MemoryQueryToolDeps): PortableTool<MemoryQueryToolParams>;

package/dist/types/skills/memory-store.d.ts

@@ -0,0 +1,66 @@
+export declare const MEMORY_ENTRY_DELIMITER = "\n\u00A7\n";
+export declare const DEFAULT_MEMORY_CHAR_LIMIT = 2200;
+export declare const DEFAULT_USER_CHAR_LIMIT = 1375;
+export type MemoryStoreTarget = "memory" | "user";
+export interface MemoryStoreResult {
+    ok: boolean;
+    message: string;
+    target: MemoryStoreTarget;
+    entries: readonly string[];
+    entryCount: number;
+    usage: string;
+    errorCode?: string;
+}
+export interface MemoryStoreOptions {
+    memoryCharLimit?: number;
+    userCharLimit?: number;
+}
+export interface MemoryStoreSerialized {
+    memory: string;
+    user: string;
+}
+export declare class MemoryStore {
+    private memoryEntries;
+    private userEntries;
+    private frozenSnapshot;
+    private snapshotFrozen;
+    private readonly memoryCharLimit;
+    private readonly userCharLimit;
+    constructor(options?: MemoryStoreOptions);
+    /**
+     * Load from serialized form (e.g. from PG or filesystem).
+     * Deduplicates entries on load.
+     */
+    loadFromSerialized(data: Partial<MemoryStoreSerialized>): void;
+    /**
+     * Serialize current live state for persistence.
+     */
+    serialize(): MemoryStoreSerialized;
+    /**
+     * Freeze current entries for system prompt injection.
+     * Call once at session start. After freezing, mutations update
+     * live state but NOT the system prompt block.
+     */
+    freezeSnapshot(): void;
+    /**
+     * Get frozen system prompt block for the given target.
+     * Returns empty string if no entries or not yet frozen.
+     */
+    getSystemPromptBlock(target: MemoryStoreTarget): string;
+    add(target: MemoryStoreTarget, content: string): MemoryStoreResult;
+    replace(target: MemoryStoreTarget, oldText: string, newContent: string): MemoryStoreResult;
+    remove(target: MemoryStoreTarget, oldText: string): MemoryStoreResult;
+    getEntries(target: MemoryStoreTarget): readonly string[];
+    getUsage(target: MemoryStoreTarget): {
+        used: number;
+        limit: number;
+        percent: number;
+    };
+    isEmpty(): boolean;
+    private entriesFor;
+    private charLimitFor;
+    private formatUsage;
+    private renderBlock;
+    private successResult;
+    private errorResult;
+}

package/dist/types/skills/memory-tool.d.ts

@@ -0,0 +1,67 @@
+import type { MemoryProvider, MemorySearchResult } from "qlogicagent-runtime-contracts";
+import type { MemoryStore, MemoryStoreTarget } from "./memory-store.js";
+export declare const MEMORY_TOOL_NAME: "memory";
+export declare const MEMORY_TOOL_MAX_CONTENT_LENGTH = 2000;
+export declare const MEMORY_TOOL_ACTIONS: readonly ["add", "replace", "remove", "search"];
+export type MemoryToolAction = (typeof MEMORY_TOOL_ACTIONS)[number];
+export declare const MEMORY_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: string[];
+            readonly description: string;
+        };
+        readonly target: {
+            readonly type: "string";
+            readonly enum: readonly ["memory", "user"];
+            readonly description: string;
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly old_text: {
+            readonly type: "string";
+            readonly description: "Required for 'replace' and 'remove'. A substring that uniquely identifies the note entry to modify.";
+        };
+        readonly query: {
+            readonly type: "string";
+            readonly description: "Required for 'search'. Natural language query to find relevant memories.";
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export declare const MEMORY_TOOL_DESCRIPTION: string;
+export declare const MEMORY_TOOL_LABEL = "Memory";
+export declare function isMemoryContentSafe(text: string): boolean;
+export interface MemoryToolParams {
+    action: MemoryToolAction;
+    target?: MemoryStoreTarget;
+    content?: string;
+    old_text?: string;
+    query?: string;
+}
+export interface MemoryToolResult {
+    ok: boolean;
+    message: string;
+    action: string;
+    /** For MD store operations: live entry count */
+    entryCount?: number;
+    /** For MD store operations: usage string */
+    usage?: string;
+    /** For search: qmemory results */
+    results?: MemorySearchResult[];
+    /** Indicates MD store was mutated (consumer should persist) */
+    storeModified?: boolean;
+    errorCode?: string;
+}
+export interface MemoryToolExecutorDeps {
+    /** QMemory provider for semantic search. */
+    provider: MemoryProvider;
+    /** Local MD memory store for notes. */
+    store?: MemoryStore;
+    userId: string;
+    sessionId?: string;
+}
+export declare function executeMemoryTool(params: MemoryToolParams, deps: MemoryToolExecutorDeps): Promise<MemoryToolResult>;

package/dist/types/skills/permissions/bash-classifier.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bash Classifier — CC yoloClassifier bash branch parity.
+ *
+ * Specialized classifier for shell/bash commands.
+ * CC decomposes each bash tool call into structured analysis:
+ *   1. Parse the command string
+ *   2. Check against known safe/dangerous command patterns
+ *   3. Check working directory context
+ *   4. If ambiguous, defer to the LLM classifier
+ *
+ * This is a pre-filter that runs BEFORE the general classifier,
+ * so commonly-used safe shell commands bypass the LLM entirely.
+ *
+ * Reference: claude-code src/utils/permissions/yoloClassifier.ts (bash branch)
+ */
+export interface BashClassifyResult {
+    decision: "allow" | "deny" | "defer";
+    reason: string;
+    /** Informational warning for destructive commands (CC parity). */
+    destructiveWarning?: string;
+}
+/**
+ * Classify a bash/shell command for safety.
+ *
+ * @param command - The shell command string
+ * @param cwd - Current working directory (for project context check)
+ * @param projectRoot - Project root directory
+ * @returns Classification result: allow / deny / defer (to LLM classifier)
+ */
+export declare function classifyBashCommand(command: string, cwd?: string, projectRoot?: string): BashClassifyResult;