profclaw 2.0.0 → 2.3.0

package/dist/chat/execution/tools/tool-search.js

@@ -0,0 +1,155 @@
+/**
+ * Tool Search Tool
+ *
+ * Allows the AI agent to discover available tool categories and
+ * dynamically load them into the current session.
+ *
+ * This solves the cold-start problem: instead of including all tool
+ * schemas up front (high token cost), only core tools are loaded by
+ * default, and the agent can search/load others as needed.
+ */
+import { z } from 'zod';
+import { ToolLoader } from '../../../agents/tool-loader.js';
+import { getToolRegistry } from '../registry.js';
+import { logger } from '../../../utils/logger.js';
+// Schema
+const ToolSearchParamsSchema = z.object({
+    query: z
+        .string()
+        .min(1)
+        .describe('Search query describing what kind of tools you need (e.g. "browser automation", "git diff", "image generation")'),
+    autoLoad: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true, automatically load the top-matching category into the session so its tools become available immediately'),
+});
+// Session-scoped loaders
+// One ToolLoader per session; keyed by conversationId so each session
+// has its own independent set of loaded tools.
+const sessionLoaders = new Map();
+function getOrCreateLoader(conversationId) {
+    let loader = sessionLoaders.get(conversationId);
+    if (!loader) {
+        const registry = getToolRegistry();
+        const toolMap = new Map();
+        for (const tool of registry.list()) {
+            toolMap.set(tool.name, tool);
+        }
+        loader = new ToolLoader(toolMap);
+        sessionLoaders.set(conversationId, loader);
+    }
+    return loader;
+}
+/**
+ * Remove the loader for a conversation when it ends (called externally).
+ */
+export function clearSessionLoader(conversationId) {
+    sessionLoaders.delete(conversationId);
+}
+/**
+ * Expose the loader for a conversation so callers (e.g. the orchestrator)
+ * can query which tools are currently loaded.
+ */
+export function getSessionLoader(conversationId) {
+    return sessionLoaders.get(conversationId);
+}
+// Tool Definition
+export const searchAvailableToolsTool = {
+    name: 'search_available_tools',
+    description: `Search available tool categories and optionally load them for use in this session.
+
+Use this tool when you need capabilities that are not yet available (e.g. browser automation,
+advanced git operations, image generation, voice synthesis, or memory access).
+
+Steps:
+1. Call with a natural-language query describing what you need.
+2. Review the matching categories and their tool lists.
+3. Call again with autoLoad: true (or call loadCategory manually) to activate the tools.
+
+The core tools (read_file, write_file, exec, git_status, git_commit, complete_task) are always
+available and do not need to be loaded.`,
+    category: 'profclaw',
+    securityLevel: 'safe',
+    allowedHosts: ['gateway', 'local'],
+    parameters: ToolSearchParamsSchema,
+    async execute(context, params) {
+        const { query, autoLoad } = params;
+        logger.info(`[ToolSearch] Searching for: "${query}"`, {
+            component: 'ToolSearch',
+            conversationId: context.conversationId,
+            autoLoad,
+        });
+        try {
+            const loader = getOrCreateLoader(context.conversationId);
+            const matchedCategories = loader.search(query);
+            if (matchedCategories.length === 0) {
+                const allCategories = loader.getCategories();
+                const hint = `No categories matched "${query}". ` +
+                    `Available categories: ${allCategories.map((c) => c.name).join(', ')}.`;
+                return {
+                    success: true,
+                    data: {
+                        query,
+                        matches: [],
+                        autoLoaded: null,
+                        hint,
+                    },
+                    output: hint,
+                };
+            }
+            // Optionally auto-load the best match
+            let autoLoaded = null;
+            if (autoLoad && matchedCategories.length > 0) {
+                const best = matchedCategories[0];
+                loader.loadCategory(best.name);
+                autoLoaded = best.name;
+                logger.info(`[ToolSearch] Auto-loaded category: ${best.name}`, {
+                    component: 'ToolSearch',
+                    conversationId: context.conversationId,
+                });
+            }
+            const matches = matchedCategories.map((cat) => ({
+                categoryName: cat.name,
+                description: cat.description,
+                keywords: cat.keywords,
+                tools: cat.tools,
+                alwaysLoaded: cat.alwaysLoaded,
+                loaded: cat.tools.some((t) => loader.isLoaded(t)),
+            }));
+            const loadedNames = matches
+                .filter((m) => m.loaded)
+                .map((m) => m.categoryName);
+            const hint = autoLoaded
+                ? `Category "${autoLoaded}" has been loaded. Its tools are now available.`
+                : loadedNames.length > 0
+                    ? `Categories already loaded: ${loadedNames.join(', ')}. Call again with autoLoad: true to load others.`
+                    : `Found ${matches.length} matching categor${matches.length === 1 ? 'y' : 'ies'}. Call again with autoLoad: true to activate the best match.`;
+            const summary = `Found ${matches.length} matching categor${matches.length === 1 ? 'y' : 'ies'} for "${query}"` +
+                (autoLoaded ? ` — loaded "${autoLoaded}"` : '') +
+                `.`;
+            return {
+                success: true,
+                data: {
+                    query,
+                    matches,
+                    autoLoaded,
+                    hint,
+                },
+                output: summary,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[ToolSearch] Search failed: ${message}`, error instanceof Error ? error : undefined);
+            return {
+                success: false,
+                error: {
+                    code: 'TOOL_SEARCH_ERROR',
+                    message,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=tool-search.js.map

package/dist/chat/execution/types.d.ts

@@ -5,6 +5,8 @@
  * Inspired by OpenClaw's execution model.
  */
 import type { z } from 'zod';
+import type { ToolTier, ModelCapabilityLevel } from '../../providers/core/types.js';
+export type { ToolTier, ModelCapabilityLevel };
 /**
  * Security mode determines how commands are validated
  * - deny: Block all tool execution
@@ -157,20 +159,6 @@ export interface ToolAvailability {
     reason?: string;
 }
 export type ToolCategory = 'execution' | 'filesystem' | 'web' | 'data' | 'system' | 'profclaw' | 'memory' | 'browser' | 'custom';
-/**
- * Tool tier determines which models receive this tool.
- * - essential: Core tools that work reliably with any model (8-10 tools)
- * - standard: Tools that need moderate reasoning (25-30 tools)
- * - full: All tools, only for large/capable models (72 tools)
- */
-export type ToolTier = 'essential' | 'standard' | 'full';
-/**
- * Model capability level for adaptive prompting and tool selection.
- * - basic: Small/local models (<14B params). Simple instruction following.
- * - instruction: Medium models (14B-70B). Can follow multi-step instructions.
- * - reasoning: Large frontier models. Chain-of-thought, complex tool orchestration.
- */
-export type ModelCapabilityLevel = 'basic' | 'instruction' | 'reasoning';
 export interface ToolExample {
     description: string;
     params: Record<string, unknown>;
@@ -283,6 +271,23 @@ export interface AIToolCall {
     name: string;
     arguments: Record<string, unknown>;
 }
+export interface SelfCorrectionMeta {
+    /** Number of automatic retries performed */
+    retries: number;
+    /** Number of correction cycles applied (retries + fixable prompts) */
+    corrections: number;
+    /** Human-readable error context strings to inject into the next AI prompt */
+    promptContext: string[];
+    /** Names of alternative tools suggested by the self-correction engine */
+    alternativeTools: string[];
+    /** Parameter fix suggestions for fixable errors */
+    parameterFixes: Array<{
+        paramName: string;
+        currentValue: unknown;
+        suggestedValue: unknown;
+        reason: string;
+    }>;
+}
 export interface ToolCallResult {
     toolCallId: string;
     toolName: string;
@@ -293,6 +298,8 @@ export interface ToolCallResult {
         remaining: number;
         resetAt: number;
     };
+    /** Populated when self-correction was attempted (retries, fixable prompts) */
+    selfCorrection?: SelfCorrectionMeta;
 }
 /** Options for filtering tools when building AI schemas */
 export interface ToolFilterOptions {

package/dist/chat/execution/workflows/executor.d.ts

@@ -9,5 +9,16 @@ export declare class WorkflowExecutor {
     cancel(executionId: string): void;
     /** Execute a single workflow step, applying param interpolation and overrides */
     private executeStep;
+    /**
+     * Execute multiple steps concurrently (fan-out).
+     * All parallel steps run at once; results are merged.
+     * Fails only if ALL parallel steps fail.
+     */
+    private executeParallelSteps;
+    /**
+     * Execute an agent session step - spawns an isolated AI agent.
+     * The agent runs a prompt with tool access and returns the result.
+     */
+    private executeAgentStep;
 }
 //# sourceMappingURL=executor.d.ts.map

package/dist/chat/execution/workflows/executor.js

@@ -165,7 +165,17 @@ export class WorkflowExecutor {
             execution.stepResults[i].status = 'running';
             context.onStepStart?.(step, i);
             const stepStartMs = Date.now();
-            const stepResult = await this.executeStep(step, variables, context, options);
+            const stepType = step.type || 'tool';
+            let stepResult;
+            if (stepType === 'parallel' && step.parallelSteps?.length) {
+                stepResult = await this.executeParallelSteps(step.parallelSteps, variables, context, options);
+            }
+            else if (stepType === 'agent_session' && step.prompt) {
+                stepResult = await this.executeAgentStep(step, variables);
+            }
+            else {
+                stepResult = await this.executeStep(step, variables, context, options);
+            }
             const durationMs = Date.now() - stepStartMs;
             execution.stepResults[i] = {
                 stepId: step.id,
@@ -257,5 +267,93 @@ export class WorkflowExecutor {
             };
         }
     }
+    /**
+     * Execute multiple steps concurrently (fan-out).
+     * All parallel steps run at once; results are merged.
+     * Fails only if ALL parallel steps fail.
+     */
+    async executeParallelSteps(steps, variables, context, options) {
+        const results = await Promise.allSettled(steps.map((step) => this.executeStep(step, variables, context, options)));
+        const outputs = {};
+        let anySuccess = false;
+        const errors = [];
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const step = steps[i];
+            if (result.status === 'fulfilled') {
+                if (result.value.success) {
+                    anySuccess = true;
+                    if (step.captureOutput) {
+                        outputs[step.captureOutput] = extractOutput(result.value, step.captureOutput);
+                        variables[step.captureOutput] = outputs[step.captureOutput];
+                    }
+                }
+                else {
+                    errors.push(`${step.name}: ${result.value.error?.message || 'failed'}`);
+                }
+            }
+            else {
+                errors.push(`${step.name}: ${result.reason}`);
+            }
+        }
+        return {
+            success: anySuccess,
+            output: JSON.stringify(outputs),
+            data: outputs,
+            error: errors.length > 0 ? { code: 'PARALLEL_ERRORS', message: errors.join('; ') } : undefined,
+        };
+    }
+    /**
+     * Execute an agent session step - spawns an isolated AI agent.
+     * The agent runs a prompt with tool access and returns the result.
+     */
+    async executeAgentStep(step, variables) {
+        try {
+            const { executeAgenticChat } = await import('../../agentic-executor.js');
+            const { createChatToolHandler } = await import('../../tool-handler.js');
+            const prompt = interpolateString(step.prompt || '', variables);
+            const conversationId = `workflow-agent-${crypto.randomUUID()}`;
+            const toolHandler = await createChatToolHandler({
+                conversationId,
+                securityMode: 'full',
+            });
+            const tools = toolHandler.getTools();
+            const response = await Promise.race([
+                executeAgenticChat({
+                    conversationId,
+                    messages: [{
+                            id: crypto.randomUUID(),
+                            role: 'user',
+                            content: prompt,
+                            timestamp: new Date().toISOString(),
+                        }],
+                    systemPrompt: 'You are an AI agent executing a workflow step. Complete the task concisely.',
+                    model: step.model,
+                    effort: 'medium',
+                    toolHandler,
+                    tools: tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.parameters,
+                    })),
+                }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Agent step timed out')), step.timeoutMs || 300000)),
+            ]);
+            return {
+                success: true,
+                output: response.content,
+                data: { content: response.content, model: response.model, tokens: response.usage?.totalTokens },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_STEP_ERROR',
+                    message: error instanceof Error ? error.message : 'Agent step failed',
+                },
+            };
+        }
+    }
 }
 //# sourceMappingURL=executor.js.map

package/dist/chat/execution/workflows/types.d.ts

@@ -5,15 +5,37 @@ export interface WorkflowDefinition {
     description: string;
     /** Keywords that trigger this workflow */
     triggers: string[];
-    /** Sequential steps */
+    /** Sequential steps (or parallel groups) */
     steps: WorkflowStep[];
     /** Variables available to all steps */
     variables?: Record<string, unknown>;
+    /** Schedule trigger - cron expression to auto-run this workflow */
+    schedule?: {
+        cron?: string;
+        intervalMs?: number;
+        timezone?: string;
+    };
+    /** Delivery configuration - where to send final output */
+    delivery?: {
+        channels: Array<{
+            type: 'telegram' | 'slack' | 'discord' | 'webhook';
+            target: string;
+        }>;
+        /** Which step output(s) to include in delivery */
+        includeOutputs?: string[];
+        /** Template for formatting the delivery message */
+        template?: string;
+    };
+    /** Max duration for entire workflow (ms) */
+    timeoutMs?: number;
 }
+export type WorkflowStepType = 'tool' | 'agent_session' | 'deliver' | 'parallel';
 export interface WorkflowStep {
     id: string;
     name: string;
-    /** Tool to execute */
+    /** Step type - defaults to 'tool' for backwards compatibility */
+    type?: WorkflowStepType;
+    /** Tool to execute (for type=tool) */
     tool: string;
     /** Parameters - supports {{variable}} interpolation from previous step outputs */
     params: Record<string, unknown>;
@@ -25,6 +47,17 @@ export interface WorkflowStep {
     continueOnError?: boolean;
     /** Timeout override in ms */
     timeoutMs?: number;
+    /** For type=parallel: steps to run concurrently */
+    parallelSteps?: WorkflowStep[];
+    /** For type=agent_session: AI prompt to execute */
+    prompt?: string;
+    /** For type=agent_session: AI model override */
+    model?: string;
+    /** For type=deliver: delivery target override */
+    deliverTo?: {
+        type: 'telegram' | 'slack' | 'discord' | 'webhook';
+        target: string;
+    };
 }
 export interface WorkflowExecution {
     workflowId: string;

package/dist/chat/format/index.d.ts

@@ -4,4 +4,5 @@
  * Shared formatters for tool results across web UI and messaging channels.
  */
 export { formatToolResult, type ChannelFormat, type FormattedToolResult, } from './tool-result-formatter.js';
+export { convertMarkdown, stripMarkdown, type FormatTarget, } from './markdown-convert.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/chat/format/index.js

@@ -4,4 +4,5 @@
  * Shared formatters for tool results across web UI and messaging channels.
  */
 export { formatToolResult, } from './tool-result-formatter.js';
+export { convertMarkdown, stripMarkdown, } from './markdown-convert.js';
 //# sourceMappingURL=index.js.map

package/dist/chat/format/markdown-convert.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Markdown Converter
+ *
+ * Converts standard markdown to platform-specific formats.
+ * The AI agent always produces markdown. Each delivery channel
+ * needs its own format.
+ *
+ * Supported targets:
+ *   - telegram: HTML subset (<b>, <i>, <code>, <pre>, <a>)
+ *   - slack: mrkdwn (*bold*, _italic_, `code`, ```blocks```, <url|text>)
+ *   - discord: Standard markdown (mostly pass-through)
+ *   - plain: Strip all formatting
+ */
+export type FormatTarget = 'telegram' | 'slack' | 'discord' | 'plain' | 'html';
+/**
+ * Convert markdown text to the target format.
+ */
+export declare function convertMarkdown(text: string, target: FormatTarget): string;
+/**
+ * Strip all markdown formatting -> plain text
+ */
+export declare function stripMarkdown(text: string): string;
+//# sourceMappingURL=markdown-convert.d.ts.map

package/dist/chat/format/markdown-convert.js

@@ -0,0 +1,149 @@
+/**
+ * Markdown Converter
+ *
+ * Converts standard markdown to platform-specific formats.
+ * The AI agent always produces markdown. Each delivery channel
+ * needs its own format.
+ *
+ * Supported targets:
+ *   - telegram: HTML subset (<b>, <i>, <code>, <pre>, <a>)
+ *   - slack: mrkdwn (*bold*, _italic_, `code`, ```blocks```, <url|text>)
+ *   - discord: Standard markdown (mostly pass-through)
+ *   - plain: Strip all formatting
+ */
+/**
+ * Convert markdown text to the target format.
+ */
+export function convertMarkdown(text, target) {
+    switch (target) {
+        case 'telegram':
+            return markdownToTelegramHtml(text);
+        case 'slack':
+            return markdownToSlackMrkdwn(text);
+        case 'discord':
+            return text; // Discord supports standard markdown
+        case 'plain':
+            return stripMarkdown(text);
+        case 'html':
+            return markdownToHtml(text);
+        default:
+            return text;
+    }
+}
+/**
+ * Markdown -> Telegram HTML
+ * Telegram supports: <b>, <i>, <u>, <s>, <code>, <pre>, <a href="url">text</a>
+ */
+function markdownToTelegramHtml(text) {
+    let result = text;
+    // Escape HTML entities first (but not our converted tags)
+    result = result
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+    // Code blocks: ```lang\n...\n``` -> <pre><code>...</code></pre>
+    result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_m, lang, code) => {
+        const langAttr = lang ? ` class="language-${lang}"` : '';
+        return `<pre><code${langAttr}>${code.trim()}</code></pre>`;
+    });
+    // Inline code: `text` -> <code>text</code>
+    result = result.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Bold: **text** -> <b>text</b>
+    result = result.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+    // Italic: *text* or _text_ -> <i>text</i>
+    result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<i>$1</i>');
+    result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, '<i>$1</i>');
+    // Strikethrough: ~~text~~ -> <s>text</s>
+    result = result.replace(/~~(.+?)~~/g, '<s>$1</s>');
+    // Links: [text](url) -> <a href="url">text</a>
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    // Headings: # text -> <b>text</b> (Telegram has no heading tag)
+    result = result.replace(/^#{1,3}\s+(.+)$/gm, '<b>$1</b>');
+    // Bullet lists: - text or * text -> bullet
+    result = result.replace(/^\s*[-*]\s+(.+)$/gm, '\u2022 $1');
+    // Numbered lists: keep as-is (Telegram renders them fine)
+    // Block quotes: > text -> (no Telegram equivalent, use italic)
+    result = result.replace(/^>\s+(.+)$/gm, '<i>$1</i>');
+    return result;
+}
+/**
+ * Markdown -> Slack mrkdwn
+ * Slack uses: *bold*, _italic_, ~strikethrough~, `code`, ```code blocks```, <url|text>
+ */
+function markdownToSlackMrkdwn(text) {
+    let result = text;
+    // Code blocks: keep as-is (Slack supports ```)
+    // But remove language hints
+    result = result.replace(/```\w*\n/g, '```\n');
+    // Bold: **text** -> *text*
+    result = result.replace(/\*\*(.+?)\*\*/g, '*$1*');
+    // Italic: *text* -> _text_ (but not inside bold)
+    // Skip this - could conflict with bold conversion
+    // Strikethrough: ~~text~~ -> ~text~
+    result = result.replace(/~~(.+?)~~/g, '~$1~');
+    // Links: [text](url) -> <url|text>
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<$2|$1>');
+    // Headings: # text -> *text* (bold)
+    result = result.replace(/^#{1,3}\s+(.+)$/gm, '*$1*');
+    // Block quotes: > text -> > text (Slack supports this)
+    // Keep as-is
+    return result;
+}
+/**
+ * Markdown -> HTML (for web/email)
+ */
+function markdownToHtml(text) {
+    let result = text;
+    // Escape HTML
+    result = result
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+    // Code blocks
+    result = result.replace(/```(\w*)\n([\s\S]*?)```/g, (_m, lang, code) => {
+        return `<pre><code class="${lang}">${code.trim()}</code></pre>`;
+    });
+    // Inline code
+    result = result.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Bold
+    result = result.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
+    // Italic
+    result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<em>$1</em>');
+    result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, '<em>$1</em>');
+    // Links
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    // Headings
+    result = result.replace(/^### (.+)$/gm, '<h3>$1</h3>');
+    result = result.replace(/^## (.+)$/gm, '<h2>$1</h2>');
+    result = result.replace(/^# (.+)$/gm, '<h1>$1</h1>');
+    // Bullet lists
+    result = result.replace(/^\s*[-*]\s+(.+)$/gm, '<li>$1</li>');
+    // Paragraphs
+    result = result.replace(/\n\n/g, '</p><p>');
+    result = `<p>${result}</p>`;
+    return result;
+}
+/**
+ * Strip all markdown formatting -> plain text
+ */
+export function stripMarkdown(text) {
+    let result = text;
+    // Code blocks: remove fences, keep content
+    result = result.replace(/```\w*\n([\s\S]*?)```/g, '$1');
+    // Inline code: remove backticks
+    result = result.replace(/`([^`]+)`/g, '$1');
+    // Bold/italic: remove markers
+    result = result.replace(/\*\*(.+?)\*\*/g, '$1');
+    result = result.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '$1');
+    result = result.replace(/(?<!_)_([^_]+)_(?!_)/g, '$1');
+    // Strikethrough
+    result = result.replace(/~~(.+?)~~/g, '$1');
+    // Links: [text](url) -> text (url)
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)');
+    // Headings: remove #
+    result = result.replace(/^#{1,3}\s+/gm, '');
+    // Bullet lists: - text -> text
+    result = result.replace(/^\s*[-*]\s+/gm, '- ');
+    return result;
+}
+//# sourceMappingURL=markdown-convert.js.map

package/dist/chat/index.d.ts

@@ -8,7 +8,7 @@ export * from './system-prompts.js';
 export * from './conversations.js';
 export * from './memory.js';
 export { PROFCLAW_CONTEXT, CHAT_PRESETS, QUICK_ACTIONS, buildSystemPrompt, type ChatPreset, type ChatContext, type QuickAction, type RuntimeInfo, } from './system-prompts.js';
-export { initConversationTables, createConversation, getConversation, listConversations, updateConversationTitle, deleteConversation, addMessage, getConversationMessages, getRecentConversationsWithPreview, type Conversation, type ConversationMessage, } from './conversations.js';
+export { initConversationTables, createConversation, getConversation, listConversations, updateConversationTitle, deleteConversation, addMessage, getConversationMessages, getRecentConversationsWithPreview, deleteMessage, type Conversation, type ConversationMessage, } from './conversations.js';
 export { DEFAULT_MEMORY_CONFIG, estimateTokens, estimateMessagesTokens, getContextWindow, needsCompaction, summarizeMessages, compactMessages, getMemoryStats, truncateToolResult, processToolCallsForCompaction, scoreMessageImportance, selectMessagesForRetention, type MemoryConfig, type CompactionResult, type MemoryStats, } from './memory.js';
 export { CHAT_SKILLS, MODEL_TIERS, detectIntent, selectModel, buildSkillPrompt, type ChatSkill, type SkillCapability, type IntentPattern, type SkillMatch, type ModelTier, } from './skills.js';
 export { CHAT_TOOLS, executeTool, getToolDefinitions, type ToolResult, type CreateProjectInput, type CreateTicketInput, type CreateSprintInput, type ConfigureProviderInput, } from './tools.js';

package/dist/chat/index.js

@@ -9,7 +9,7 @@ export * from './conversations.js';
 export * from './memory.js';
 // Re-export for convenience
 export { PROFCLAW_CONTEXT, CHAT_PRESETS, QUICK_ACTIONS, buildSystemPrompt, } from './system-prompts.js';
-export { initConversationTables, createConversation, getConversation, listConversations, updateConversationTitle, deleteConversation, addMessage, getConversationMessages, getRecentConversationsWithPreview, } from './conversations.js';
+export { initConversationTables, createConversation, getConversation, listConversations, updateConversationTitle, deleteConversation, addMessage, getConversationMessages, getRecentConversationsWithPreview, deleteMessage, } from './conversations.js';
 export { DEFAULT_MEMORY_CONFIG, estimateTokens, estimateMessagesTokens, getContextWindow, needsCompaction, summarizeMessages, compactMessages, getMemoryStats, 
 // Advanced context pruning
 truncateToolResult, processToolCallsForCompaction, scoreMessageImportance, selectMessagesForRetention, } from './memory.js';