profclaw 2.0.0 → 2.4.0

package/dist/chat/execution/executor.js

@@ -17,6 +17,7 @@ import { logger } from "../../utils/logger.js";
 import { randomUUID } from "crypto";
 import { hasSecrets, isSecretsDetectionEnabled, redactSecrets, } from "./secrets.js";
 import { checkSafetyBounds } from "./guardrails.js";
+import { CorrectionTracker, executeWithSelfCorrection, formatErrorContextForPrompt, suggestParameterFixes, classifyFailure, } from "./self-correction.js";
 // Constants
 const DEFAULT_TIMEOUT_MS = 300_000; // 5 minutes
 const PROGRESS_THROTTLE_MS = 100; // Throttle progress updates
@@ -33,8 +34,39 @@ const redactToolText = (text) => {
     return redactSecrets(text);
 };
 // Tool Executor
+/** Error codes that represent user/policy decisions - self-correction must not retry these */
+const NON_RETRYABLE_CODES = new Set([
+    'APPROVAL_REQUIRED',
+    'DENIED',
+    'USER_DENIED',
+    'SAFETY_BLOCKED',
+    'PROMPT_BLOCKED',
+    'RATE_LIMITED',
+    'TOOL_NOT_FOUND',
+    'MISSING_PARAMS',
+    'INVALID_PARAMS',
+]);
+/** Maximum retries per tool call enforced by the correction budget */
+const MAX_CORRECTIONS_PER_CALL = 3;
 export class ToolExecutor {
     abortControllers = new Map();
+    /**
+     * One CorrectionTracker per conversation, reset when a conversation ends.
+     * Key: conversationId
+     */
+    correctionTrackers = new Map();
+    getOrCreateTracker(conversationId) {
+        let tracker = this.correctionTrackers.get(conversationId);
+        if (!tracker) {
+            tracker = new CorrectionTracker(MAX_CORRECTIONS_PER_CALL);
+            this.correctionTrackers.set(conversationId, tracker);
+        }
+        return tracker;
+    }
+    /** Call this when a conversation is done to free the tracker. */
+    resetCorrectionBudget(conversationId) {
+        this.correctionTrackers.delete(conversationId);
+    }
     /**
      * Execute a single tool call
      */
@@ -242,137 +274,159 @@ export class ToolExecutor {
                 },
             };
         }
-        // Execute the tool through process pool
+        // Execute the tool through process pool, wrapped with self-correction
         const processPool = getProcessPool();
-        try {
-            const result = await processPool.submit(toolCallId, toolCall.name, context.conversationId, async () => {
-                // Check if sandbox execution is required
-                if (securityCheck.sandboxRequired &&
-                    securityPolicy.mode === "sandbox") {
-                    return this.executeInSandbox(tool, params, context, toolCallId);
-                }
-                // Normal execution
-                return this.executeWithTimeout(tool, params, {
-                    ...context,
-                    toolCallId,
-                    sessionManager: getSessionManager(),
-                    securityPolicy,
-                }, DEFAULT_TIMEOUT_MS);
-            }, {
-                userId: context.userId,
-                priority: tool.securityLevel === "safe" ? 1 : 0,
-                timeout: DEFAULT_TIMEOUT_MS,
-            });
-            const durationMs = Date.now() - startTime;
-            const sanitizedOutput = redactToolText(result.output);
-            const sanitizedResult = sanitizedOutput === result.output
-                ? result
-                : {
-                    ...result,
-                    output: sanitizedOutput,
-                };
-            // Log successful execution
-            auditLogger.logExecution({
-                toolName: toolCall.name,
-                toolCallId,
-                conversationId: context.conversationId,
-                userId: context.userId,
-                params,
-                command: this.extractCommand(params),
-                securityMode: securityPolicy.mode,
-                success: sanitizedResult.success,
-                durationMs,
-                exitCode: sanitizedResult.data?.exitCode,
-                output: sanitizedResult.output,
-                error: sanitizedResult.error?.message,
-            });
-            logger.info(`[Executor] Tool ${toolCall.name} completed in ${durationMs}ms`, { component: "ToolExecutor" });
-            return {
-                toolCallId,
-                toolName: toolCall.name,
-                result: {
-                    ...sanitizedResult,
-                    durationMs,
-                },
-                rateLimitInfo: {
-                    remaining: rateLimitResult.remaining - 1,
-                    resetAt: rateLimitResult.resetAt,
-                },
-            };
-        }
-        catch (error) {
-            const durationMs = Date.now() - startTime;
-            // Handle specific error types
-            if (error instanceof PoolFullError) {
-                auditLogger.logError({
-                    toolName: toolCall.name,
-                    toolCallId,
-                    conversationId: context.conversationId,
+        const correctionTracker = this.getOrCreateTracker(context.conversationId);
+        /**
+         * Inner executor: submits one attempt to the process pool and converts
+         * thrown pool errors (PoolFullError, TimeoutError) into ToolResult failures
+         * so the self-correction classifier can handle them uniformly.
+         */
+        const poolExecutor = async () => {
+            try {
+                return await processPool.submit(toolCallId, toolCall.name, context.conversationId, async () => {
+                    if (securityCheck.sandboxRequired &&
+                        securityPolicy.mode === "sandbox") {
+                        return this.executeInSandbox(tool, params, context, toolCallId);
+                    }
+                    return this.executeWithTimeout(tool, params, {
+                        ...context,
+                        toolCallId,
+                        sessionManager: getSessionManager(),
+                        securityPolicy,
+                    }, DEFAULT_TIMEOUT_MS);
+                }, {
                     userId: context.userId,
-                    error: "Execution pool is full",
+                    priority: tool.securityLevel === "safe" ? 1 : 0,
+                    timeout: DEFAULT_TIMEOUT_MS,
                 });
-                return {
-                    toolCallId,
-                    toolName: toolCall.name,
-                    result: {
+            }
+            catch (err) {
+                if (err instanceof PoolFullError) {
+                    return {
                         success: false,
                         error: {
                             code: "POOL_FULL",
                             message: "Too many concurrent executions. Please try again later.",
                             retryable: true,
                         },
-                        durationMs,
-                    },
-                };
-            }
-            if (error instanceof TimeoutError || error instanceof QueueTimeoutError) {
-                auditLogger.logTimeout({
-                    toolName: toolCall.name,
-                    toolCallId,
-                    conversationId: context.conversationId,
-                    userId: context.userId,
-                    durationMs,
-                });
-                return {
-                    toolCallId,
-                    toolName: toolCall.name,
-                    result: {
+                    };
+                }
+                if (err instanceof TimeoutError || err instanceof QueueTimeoutError) {
+                    return {
                         success: false,
                         error: {
                             code: "TIMEOUT",
-                            message: error.message,
+                            message: err instanceof Error ? err.message : "Execution timed out",
                             retryable: true,
                         },
-                        durationMs,
+                    };
+                }
+                return {
+                    success: false,
+                    error: {
+                        code: "EXECUTION_ERROR",
+                        message: err instanceof Error ? err.message : "Unknown error",
                     },
                 };
             }
-            // Generic error
+        };
+        // Run with self-correction (auto-retry for retryable, context injection for fixable)
+        const correctionOutcome = await executeWithSelfCorrection(toolCall.name, poolExecutor, {
+            correctionBudget: correctionTracker.canCorrect()
+                ? correctionTracker.getStatus().maxCorrections - correctionTracker.getStatus().used
+                : 0,
+            signal: undefined,
+            onRetry: (attempt, error) => {
+                logger.info(`[Executor] Self-correction retry ${attempt} for "${toolCall.name}": ${error.code} - ${error.message}`, { component: "ToolExecutor", toolName: toolCall.name, attempt });
+                correctionTracker.recordCorrection();
+            },
+        });
+        const rawResult = correctionOutcome.result;
+        const durationMs = Date.now() - startTime;
+        // Sanitize output secrets
+        const sanitizedOutput = redactToolText(rawResult.output);
+        const sanitizedResult = sanitizedOutput === rawResult.output
+            ? rawResult
+            : { ...rawResult, output: sanitizedOutput };
+        // Audit log the final outcome
+        if (rawResult.error?.code === "POOL_FULL") {
+            auditLogger.logError({
+                toolName: toolCall.name,
+                toolCallId,
+                conversationId: context.conversationId,
+                userId: context.userId,
+                error: rawResult.error.message,
+            });
+        }
+        else if (rawResult.error?.code === "TIMEOUT") {
+            auditLogger.logTimeout({
+                toolName: toolCall.name,
+                toolCallId,
+                conversationId: context.conversationId,
+                userId: context.userId,
+                durationMs,
+            });
+        }
+        else {
             auditLogger.logExecution({
                 toolName: toolCall.name,
                 toolCallId,
                 conversationId: context.conversationId,
                 userId: context.userId,
                 params,
+                command: this.extractCommand(params),
                 securityMode: securityPolicy.mode,
-                success: false,
+                success: sanitizedResult.success,
                 durationMs,
-                error: error instanceof Error ? error.message : "Unknown error",
+                exitCode: sanitizedResult.data?.exitCode,
+                output: sanitizedResult.output,
+                error: sanitizedResult.error?.message,
             });
-            logger.error(`[Executor] Tool ${toolCall.name} failed`, error instanceof Error ? error : undefined);
-            return {
-                toolCallId,
-                toolName: toolCall.name,
-                result: {
-                    success: false,
-                    error: {
-                        code: "EXECUTION_ERROR",
-                        message: error instanceof Error ? error.message : "Unknown error",
-                    },
-                    durationMs,
-                },
+        }
+        if (sanitizedResult.success) {
+            logger.info(`[Executor] Tool ${toolCall.name} completed in ${durationMs}ms` +
+                (correctionOutcome.retries > 0
+                    ? ` (after ${correctionOutcome.retries} self-correction retries)`
+                    : ""), { component: "ToolExecutor" });
+        }
+        else {
+            logger.error(`[Executor] Tool ${toolCall.name} failed after ${correctionOutcome.retries} retries`, undefined);
+        }
+        // Build self-correction metadata to attach to the result
+        const hasCorrectionActivity = correctionOutcome.retries > 0 || correctionOutcome.corrections > 0;
+        let selfCorrection;
+        if (hasCorrectionActivity || correctionOutcome.errorContexts.length > 0) {
+            // For fixable failures, generate parameter fix suggestions
+            const parameterFixes = !sanitizedResult.success && sanitizedResult.error
+                ? (() => {
+                    const cls = classifyFailure(sanitizedResult.error, toolCall.name);
+                    return cls.type === 'fixable'
+                        ? suggestParameterFixes(sanitizedResult.error, toolCall.name, params)
+                        : [];
+                })()
+                : [];
+            selfCorrection = {
+                retries: correctionOutcome.retries,
+                corrections: correctionOutcome.corrections,
+                promptContext: correctionOutcome.errorContexts.map(formatErrorContextForPrompt),
+                alternativeTools: correctionOutcome.alternativesSuggested.map((a) => a.toolName),
+                parameterFixes,
             };
         }
+        return {
+            toolCallId,
+            toolName: toolCall.name,
+            result: {
+                ...sanitizedResult,
+                durationMs,
+            },
+            rateLimitInfo: {
+                remaining: rateLimitResult.remaining - 1,
+                resetAt: rateLimitResult.resetAt,
+            },
+            ...(selfCorrection ? { selfCorrection } : {}),
+        };
     }
     /**
      * Execute multiple tool calls (parallel or sequential)

package/dist/chat/execution/index.js

@@ -7,6 +7,7 @@
 // Types
 export * from './types.js';
 // Core modules
+import { configureToolRouter } from './tool-router.js';
 export { getToolRegistry, ToolRegistryImpl } from './registry.js';
 export { getSecurityManager, initSecurityManager, SecurityPolicyManager } from './security.js';
 export { getSessionManager, ToolSessionManager } from './session-manager.js';
@@ -102,9 +103,12 @@ export async function initializeToolExecution(options) {
     }
     // Register built-in tools
     if (options?.registerBuiltins !== false) {
-        registerBuiltinTools();
+        await registerBuiltinTools();
         logger.debug('[Execution] Built-in tools registered', { component: 'ToolExecution' });
     }
+    // Enable model-aware tool filtering to reduce token usage
+    configureToolRouter({ enabled: true });
+    logger.debug('[Execution] Tool router enabled', { component: 'ToolExecution' });
     initialized = true;
     logger.info('[Execution] Tool execution system initialized', { component: 'ToolExecution' });
 }

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

@@ -23,6 +23,14 @@ export interface SandboxExecuteResult {
     containerId?: string;
     error?: string;
 }
+/**
+ * Ping the Docker daemon, giving up after a timeout. A wedged daemon (for example a
+ * half-started Docker Desktop) accepts the connection but never answers, which would
+ * otherwise hang startup forever.
+ */
+export declare function pingDockerWithTimeout(docker: {
+    ping(): Promise<unknown>;
+}, timeoutMs?: number): Promise<void>;
 export declare class SandboxManager {
     private config;
     private securityConfig;

package/dist/chat/execution/sandbox.js

@@ -16,6 +16,30 @@ const DEFAULT_CPU_LIMIT = '1';
 const CONTAINER_POOL_SIZE = 3;
 const CONTAINER_MAX_AGE_MS = 3600_000; // 1 hour
 const CLEANUP_INTERVAL_MS = 60_000; // 1 minute
+const DEFAULT_DOCKER_PING_TIMEOUT_MS = 3_000;
+/** How long to wait for the Docker daemon to answer before treating it as unavailable. */
+function getDockerPingTimeoutMs(env = process.env) {
+    const parsed = Number(env['PROFCLAW_DOCKER_PING_TIMEOUT_MS']);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DOCKER_PING_TIMEOUT_MS;
+}
+/**
+ * Ping the Docker daemon, giving up after a timeout. A wedged daemon (for example a
+ * half-started Docker Desktop) accepts the connection but never answers, which would
+ * otherwise hang startup forever.
+ */
+export async function pingDockerWithTimeout(docker, timeoutMs = getDockerPingTimeoutMs()) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`Docker daemon did not respond within ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        await Promise.race([docker.ping(), timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 const DEFAULT_SESSION_IDLE_MS = 600_000; // 10 minutes
 export class SandboxManager {
     config;
@@ -76,7 +100,7 @@ export class SandboxManager {
                     : new DockerModule.default();
             }
             // Check Docker connection
-            await this.docker.ping();
+            await pingDockerWithTimeout(this.docker);
             logger.info('[Sandbox] Docker connection established', { component: 'Sandbox' });
             // Log active security level so operators know what enforcement is in place
             logger.info(`[Sandbox] Security level: ${this.securityConfig.level} (mode override: ${process.env.PROFCLAW_SANDBOX_LEVEL ?? 'none'}, resolved: ${getSecurityLevel()})`, {

package/dist/chat/execution/tool-router.js

@@ -17,7 +17,7 @@ import { logger } from '../../utils/logger.js';
 const MODEL_PATTERNS = [
     // Large reasoning models (full tier)
     { pattern: /claude-(3\.5|4|opus|sonnet-4)/i, capability: 'reasoning', tier: 'full' },
-    { pattern: /gpt-4o|gpt-4-turbo|gpt-4\.5/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /gpt-?4o|gpt-4-turbo|gpt-4\.5|gpt-4\.1/i, capability: 'reasoning', tier: 'full' },
     { pattern: /gemini-(pro|1\.5|2)/i, capability: 'reasoning', tier: 'full' },
     { pattern: /o[13]-/i, capability: 'reasoning', tier: 'full' },
     { pattern: /deepseek-(v3|r1|chat)/i, capability: 'reasoning', tier: 'full' },
@@ -38,6 +38,9 @@ const MODEL_PATTERNS = [
     { pattern: /glm-4-(air|flashx|long)/i, capability: 'instruction', tier: 'standard' },
     { pattern: /glm-4\.7-flash/i, capability: 'instruction', tier: 'standard' },
     { pattern: /moonshot|kimi/i, capability: 'instruction', tier: 'standard' },
+    // Models with strong native tool calling despite small size
+    { pattern: /gemma-?4/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /qwen-?3/i, capability: 'instruction', tier: 'standard' },
     // Small/local basic models (essential tier)
     { pattern: /llama-?3\.(2-[13]b|1-8b)|llama3\.2/i, capability: 'basic', tier: 'essential' },
     { pattern: /qwen-?2\.5-[37]b|qwen2\.5:[37]b/i, capability: 'basic', tier: 'essential' },
@@ -54,23 +57,17 @@ export const ESSENTIAL_TOOL_NAMES = new Set([
     'exec',
     'read_file',
     'write_file',
-    'edit_file',
-    'search_files',
     'web_search',
     'web_fetch',
     'complete_task',
-    'memory_search',
-    'agents_list',
 ]);
 /**
  * Tools restricted to full tier only (large capable models).
  */
 export const FULL_ONLY_TOOL_NAMES = new Set([
+    // Browser automation
     'canvas_render',
     'image_analyze',
-    'subagent_orchestrate',
-    'openai_image_gen',
-    'tts_speak',
     'browser_navigate',
     'browser_snapshot',
     'browser_click',
@@ -79,9 +76,33 @@ export const FULL_ONLY_TOOL_NAMES = new Set([
     'browser_screenshot',
     'browser_pages',
     'browser_close',
+    // Advanced orchestration
+    'subagent_orchestrate',
+    'openai_image_gen',
+    'tts_speak',
     'discord_actions',
     'slack_actions',
     'telegram_actions',
+    // Heavy tools that small models misuse
+    'sessions_spawn',
+    'sessions_send',
+    'decompose_task',
+    'multi_patch',
+    'github_pr',
+    'create_pr',
+    'cron_create',
+    'cron_trigger',
+    'cron_delete',
+    'cron_archive',
+    'cron_pause',
+    'cron_history',
+    'feed_add',
+    'feed_bundle_install',
+    'feed_poll',
+    'feed_digest',
+    'feed_discover',
+    'repl_execute',
+    'db_maintenance',
 ]);
 // State
 let config = {
@@ -92,6 +113,11 @@ let config = {
 };
 // Track promoted tools per conversation (conversationId -> set of tool names)
 const promotedTools = new Map();
+const TIER_MAX_TOOLS = {
+    essential: 8,
+    standard: 12,
+    full: 50,
+};
 // Core Functions
 /**
  * Classify a model ID into a capability profile.
@@ -103,7 +129,7 @@ export function classifyModel(modelId) {
             return {
                 capability: entry.capability,
                 tier: entry.tier,
-                maxTools: entry.tier === 'essential' ? 10 : entry.tier === 'standard' ? 30 : 100,
+                maxTools: TIER_MAX_TOOLS[entry.tier],
                 contextWindow,
                 toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
             };
@@ -118,7 +144,7 @@ export function classifyModel(modelId) {
             return {
                 capability: 'basic',
                 tier: 'essential',
-                maxTools: 10,
+                maxTools: TIER_MAX_TOOLS['essential'],
                 contextWindow,
                 toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
             };
@@ -127,18 +153,18 @@ export function classifyModel(modelId) {
             return {
                 capability: 'instruction',
                 tier: 'standard',
-                maxTools: 30,
+                maxTools: TIER_MAX_TOOLS['standard'],
                 contextWindow,
                 toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
             };
         }
     }
-    // Unknown model: default to configured tier (safe, won't break)
+    // Unknown model: default to standard tier (balances capability vs token cost)
     const contextWindow = 128000;
     return {
         capability: 'reasoning',
-        tier: config.defaultTier,
-        maxTools: 100,
+        tier: 'standard',
+        maxTools: TIER_MAX_TOOLS['standard'],
         contextWindow,
         toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
     };

package/dist/chat/execution/tools/canvas.d.ts

@@ -43,13 +43,13 @@ declare const CanvasRenderParamsSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
-    type: "code" | "markdown" | "table" | "chart" | "diagram" | "html" | "mermaid" | "svg";
+    type: "code" | "markdown" | "table" | "html" | "chart" | "diagram" | "mermaid" | "svg";
     content: string;
     title?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
     language?: string | undefined;
 }, {
-    type: "code" | "markdown" | "table" | "chart" | "diagram" | "html" | "mermaid" | "svg";
+    type: "code" | "markdown" | "table" | "html" | "chart" | "diagram" | "mermaid" | "svg";
     content: string;
     title?: string | undefined;
     metadata?: Record<string, unknown> | undefined;

package/dist/chat/execution/tools/code-tools.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Code Tools
+ *
+ * Development workflow tools: lint, typecheck, build, format, dependency audit.
+ * These complement the existing file-ops, git, and exec tools to enable
+ * full coding agent workflows.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const TypeCheckParams: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+}, {
+    path?: string | undefined;
+}>;
+export declare const typeCheckTool: ToolDefinition<z.infer<typeof TypeCheckParams>, unknown>;
+declare const LintParams: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    fix: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+    fix?: boolean | undefined;
+}, {
+    path?: string | undefined;
+    fix?: boolean | undefined;
+}>;
+export declare const lintTool: ToolDefinition<z.infer<typeof LintParams>, unknown>;
+declare const BuildParams: z.ZodObject<{
+    script: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    script?: string | undefined;
+}, {
+    script?: string | undefined;
+}>;
+export declare const buildTool: ToolDefinition<z.infer<typeof BuildParams>, unknown>;
+declare const FormatParams: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+}, {
+    path?: string | undefined;
+}>;
+export declare const formatTool: ToolDefinition<z.infer<typeof FormatParams>, unknown>;
+declare const ProjectInfoParams: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const projectInfoTool: ToolDefinition<z.infer<typeof ProjectInfoParams>, unknown>;
+declare const CreatePrParams: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    base: z.ZodOptional<z.ZodString>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    body?: string | undefined;
+    base?: string | undefined;
+    draft?: boolean | undefined;
+}, {
+    title: string;
+    body?: string | undefined;
+    base?: string | undefined;
+    draft?: boolean | undefined;
+}>;
+export declare const createPrTool: ToolDefinition<z.infer<typeof CreatePrParams>, unknown>;
+export declare const codeTools: ToolDefinition[];
+export {};
+//# sourceMappingURL=code-tools.d.ts.map