jiva-core 0.3.2 → 0.3.21

package/Dockerfile

@@ -8,8 +8,8 @@ WORKDIR /app
 COPY package*.json ./
 COPY tsconfig.json ./
 
-# Install dependencies (including dev dependencies for build)
-RUN npm ci
+# Install dependencies (skip postinstall/playwright in CI environment)
+RUN npm ci --ignore-scripts
 
 # Copy source code
 COPY src ./src
@@ -28,16 +28,21 @@ RUN apk add --no-cache dumb-init
 # Copy package files
 COPY package*.json ./
 
-# Install production dependencies only
-RUN npm ci --omit=dev && npm cache clean --force
+# Install production dependencies only (skip postinstall/playwright)
+RUN npm ci --omit=dev --ignore-scripts && npm cache clean --force
+
+# Pre-install MCP servers globally so they don't need to be downloaded per-session
+RUN npm install -g @modelcontextprotocol/server-filesystem
 
 # Copy built application from builder
 COPY --from=builder /app/dist ./dist
 
-# Create non-root user
-RUN addgroup -g 1001 -S nodejs && \
+# Create workspace directory and set permissions
+RUN mkdir -p /workspace && \
+    addgroup -g 1001 -S nodejs && \
     adduser -S nodejs -u 1001 && \
-    chown -R nodejs:nodejs /app
+    chown -R nodejs:nodejs /app && \
+    chown nodejs:nodejs /workspace
 
 USER nodejs
 

package/cloud-run.yaml

@@ -58,7 +58,7 @@ spec:
         
         # Storage configuration
         - name: JIVA_STORAGE_PROVIDER
-          value: "gcp"
+          value: "gcp-bucket"
         - name: JIVA_GCP_BUCKET
           value: "jiva-state-BUCKET_NAME"
         - name: JIVA_GCP_PROJECT

package/cloud-run.yaml.template

@@ -57,7 +57,7 @@ spec:
         
         # Storage configuration
         - name: JIVA_STORAGE_PROVIDER
-          value: "gcp"
+          value: "gcp-bucket"
         - name: JIVA_GCP_BUCKET
           value: "jiva-state-BUCKET_NAME"
         - name: JIVA_GCP_PROJECT

package/dist/core/client-agent.d.ts

@@ -35,24 +35,30 @@ export declare class ClientAgent {
     private mcpManager;
     private mcpClient;
     private failureCount;
-    private readonly ALLOWED_TOOLS;
+    private _availableTools;
     constructor(orchestrator: ModelOrchestrator, mcpManager: MCPServerManager);
     /**
-     * Use LLM to analyze the task and determine involvement level + requirements.
-     * Replaces keyword-based determineInvolvementLevel() and parseRequirements()
-     * with semantic understanding that avoids false positives.
+     * Returns all tool names currently available from connected MCP servers.
+     * Result is cached after the first call; call resetToolCache() if servers change.
      */
-    private analyzeTaskRequirements;
+    private getAvailableTools;
+    /** Reset the tool cache (e.g. after MCP server reconnects). */
+    resetToolCache(): void;
+    /**
+     * Find the first available tool whose name contains any of the given substrings.
+     * Returns null if no match is found.
+     */
+    private findTool;
     /**
-     * @deprecated Use analyzeTaskRequirements() instead. Kept for reference.
-     * Determine involvement level based on user request complexity
+     * Build a human-readable summary of available tool categories for LLM prompts.
      */
-    determineInvolvementLevel(userMessage: string, subtasks: string[]): InvolvementLevel;
+    private buildToolContextForPrompt;
     /**
-     * @deprecated Use analyzeTaskRequirements() instead. Kept for reference.
-     * Parse requirements from user message
+     * Use LLM to analyze the task and determine involvement level + requirements.
+     * Replaces keyword-based determineInvolvementLevel() and parseRequirements()
+     * with semantic understanding that avoids false positives.
      */
-    parseRequirements(userMessage: string, subtasks: string[]): Requirement[];
+    private analyzeTaskRequirements;
     /**
      * Validate Worker's work at appropriate involvement level
      */
@@ -78,26 +84,27 @@ export declare class ClientAgent {
      */
     private validateOutcome;
     /**
-     * Check if file exists using read tool
+     * Check whether a file exists, using whichever MCP tool is available.
+     * Tries filesystem read tools first, then falls back to shell.
      */
     private fileExists;
     /**
      * Use LLM to generate an actionable correction instruction from raw validation issues.
-     * Instead of echoing "requires using playwright__ but Worker did not use these tools",
-     * produces something like "Use the filesystem tools to list ~/Library/Caches and report sizes".
+     * Translates internal validation failures into concrete, tool-specific directions
+     * for the Worker, referencing only the tools actually available in the system.
      */
     private generateCorrectionInstruction;
     /**
-     * Validate file contents for common issues
+     * Validate file contents for common issues, using whichever MCP tool is available.
      */
     private validateFileContents;
     /**
-     * Validate HTML file in browser
-     */
-    private validateInBrowser;
-    /**
-     * Reset failure tracking (for new conversation/session)
+     * THOROUGH-level shell-based verification: runs lightweight, read-only shell
+     * commands to confirm work was actually done (file sizes, test output presence, etc.).
+     * Skips gracefully when no shell tool is available.
      */
+    private validateWithShell;
+    /** Reset failure tracking (call at the start of each new conversation/session). */
     resetFailureTracking(): void;
 }
 //# sourceMappingURL=client-agent.d.ts.map

package/dist/core/client-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-agent.d.ts","sourceRoot":"","sources":["../../src/core/client-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAI5D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAgBjD,oBAAY,gBAAgB;IAC1B,OAAO,YAAY,CAAM,0BAA0B;IACnD,QAAQ,aAAa,CAAI,mCAAmC;IAC5D,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,GAAG,mBAAmB,GAAG,SAAS,GAAG,cAAc,GAAG,aAAa,GAAG,OAAO,CAAC;IACnG,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAa;IAGjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAS5B;gBAEU,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,gBAAgB;IAMzE;;;;OAIG;YACW,uBAAuB;IA+GrC;;;OAGG;IACH,yBAAyB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,gBAAgB;IAuCpF;;;OAGG;IACH,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE;IAgEzE;;OAEG;IACG,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,YAAY,EAC1B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,gBAAgB,CAAC;IAyG5B;;;OAGG;YACW,4BAA4B;IA8D1C;;;;;OAKG;YACW,sBAAsB;IAyEpC;;OAEG;IACH,OAAO,CAAC,eAAe;IA+CvB;;OAEG;YACW,eAAe;IAgD7B;;OAEG;YACW,UAAU;IAYxB;;;;OAIG;YACW,6BAA6B;IAiD3C;;OAEG;YACW,oBAAoB;IAqClC;;OAEG;YACW,iBAAiB;IA+B/B;;OAEG;IACH,oBAAoB,IAAI,IAAI;CAG7B"}
+{"version":3,"file":"client-agent.d.ts","sourceRoot":"","sources":["../../src/core/client-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAI5D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAgBjD,oBAAY,gBAAgB;IAC1B,OAAO,YAAY,CAAM,0BAA0B;IACnD,QAAQ,aAAa,CAAI,mCAAmC;IAC5D,QAAQ,aAAa;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,GAAG,mBAAmB,GAAG,SAAS,GAAG,cAAc,GAAG,aAAa,GAAG,OAAO,CAAC;IACnG,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAa;IAGjC,OAAO,CAAC,eAAe,CAAyB;gBAEpC,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,gBAAgB;IAQzE;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAQzB,+DAA+D;IAC/D,cAAc,IAAI,IAAI;IAItB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAmBjC;;;;OAIG;YACW,uBAAuB;IAgHrC;;OAEG;IACG,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,YAAY,EAC1B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,gBAAgB,CAAC;IAyG5B;;;OAGG;YACW,4BAA4B;IA8D1C;;;;;OAKG;YACW,sBAAsB;IA6EpC;;OAEG;IACH,OAAO,CAAC,eAAe;IA+CvB;;OAEG;YACW,eAAe;IAsC7B;;;OAGG;YACW,UAAU;IA2BxB;;;;OAIG;YACW,6BAA6B;IAoD3C;;OAEG;YACW,oBAAoB;IAoDlC;;;;OAIG;YACW,iBAAiB;IA+C/B,mFAAmF;IACnF,oBAAoB,IAAI,IAAI;CAG7B"}

package/dist/core/client-agent.js

@@ -22,22 +22,63 @@ export class ClientAgent {
     mcpManager;
     mcpClient;
     failureCount = 0;
-    // Read-only tools Client can use for validation
-    ALLOWED_TOOLS = [
-        'filesystem__read_text_file',
-        'filesystem__list_directory',
-        'filesystem__directory_tree',
-        'filesystem__search_files',
-        'playwright__browser_navigate',
-        'playwright__browser_console_messages',
-        'playwright__browser_take_screenshot',
-        'playwright__browser_evaluate',
-    ];
+    // Lazily cached list of all available tool names (populated on first use)
+    _availableTools = null;
     constructor(orchestrator, mcpManager) {
         this.orchestrator = orchestrator;
         this.mcpManager = mcpManager;
         this.mcpClient = mcpManager.getClient();
     }
+    // ─── Tool Discovery ───────────────────────────────────────────────────────
+    /**
+     * Returns all tool names currently available from connected MCP servers.
+     * Result is cached after the first call; call resetToolCache() if servers change.
+     */
+    getAvailableTools() {
+        if (this._availableTools === null) {
+            this._availableTools = this.mcpClient.getAllTools().map(t => t.name);
+            logger.debug(`[Client] Discovered ${this._availableTools.length} available tools: ${this._availableTools.join(', ')}`);
+        }
+        return this._availableTools;
+    }
+    /** Reset the tool cache (e.g. after MCP server reconnects). */
+    resetToolCache() {
+        this._availableTools = null;
+    }
+    /**
+     * Find the first available tool whose name contains any of the given substrings.
+     * Returns null if no match is found.
+     */
+    findTool(...patterns) {
+        const tools = this.getAvailableTools();
+        for (const pattern of patterns) {
+            const found = tools.find(t => t.includes(pattern));
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    /**
+     * Build a human-readable summary of available tool categories for LLM prompts.
+     */
+    buildToolContextForPrompt() {
+        const tools = this.getAvailableTools();
+        if (tools.length === 0) {
+            return 'No MCP tools are currently available.';
+        }
+        // Group by server prefix (everything before __)
+        const byServer = {};
+        for (const tool of tools) {
+            const [server] = tool.split('__');
+            if (!byServer[server])
+                byServer[server] = [];
+            byServer[server].push(tool);
+        }
+        return Object.entries(byServer)
+            .map(([server, serverTools]) => `- ${server}: ${serverTools.join(', ')}`)
+            .join('\n');
+    }
+    // ─── Task Analysis ────────────────────────────────────────────────────────
     /**
      * Use LLM to analyze the task and determine involvement level + requirements.
      * Replaces keyword-based determineInvolvementLevel() and parseRequirements()
@@ -47,6 +88,7 @@ export class ClientAgent {
         const workerContext = workerResult
             ? `\nWorker Result (first 500 chars): ${workerResult.result.substring(0, 500)}\nWorker Success: ${workerResult.success}\nTools Used: ${workerResult.toolsUsed.join(', ') || 'none'} (${workerResult.toolsUsed.length} total)`
             : '';
+        const availableToolsContext = this.buildToolContextForPrompt();
         const analysisPrompt = `You are a task analyst for a software agent system. Analyze the user's request to determine:
 1. How deeply to validate the Worker's output (involvement level)
 2. What specific requirements the task implies
@@ -58,6 +100,9 @@ ${workerContext}
 
 PREVIOUS FAILURE COUNT: ${this.failureCount}
 
+AVAILABLE TOOLS (what the Worker and Client can actually use):
+${availableToolsContext}
+
 Respond ONLY with valid JSON in this exact format (no other text):
 {
   "involvementLevel": "<MINIMAL | STANDARD | THOROUGH>",
@@ -73,19 +118,14 @@ Respond ONLY with valid JSON in this exact format (no other text):
 }
 
 CRITICAL RULES for involvementLevel:
-- THOROUGH: ONLY when the user EXPLICITLY asks to test or verify something in a browser/test environment, OR after previous failures (failureCount > 0), OR for complex multi-file operations (>3 subtasks)
+- THOROUGH: ONLY when the user EXPLICITLY asks to test or verify something, OR after previous failures (failureCount > 0), OR for complex multi-file operations (>3 subtasks)
 - MINIMAL: Information-only requests (listing files, explaining code, describing something, answering questions) where no files are created or modified
 - STANDARD: Default for creation, modification, or action tasks
 
 CRITICAL RULES for requirements:
-- "testing" type with mustUseTools ["playwright__"] should ONLY be set when the user wants browser-based testing or verification of a web page/HTML/UI
-- Words like "check", "find", "verify" in the context of system administration (disk space, processes, configurations) are NOT browser testing — they are "information" type WITHOUT playwright tools
-- Examples:
-  - "check how much space my caches use" = type "information", mustUseTools null
-  - "find the biggest files in Downloads" = type "information", mustUseTools null
-  - "test the login page in the browser" = type "testing", mustUseTools ["playwright__"]
-  - "create index.html and verify it works" = type "file_creation" + type "testing" with playwright
-  - "make sure the server is running" = type "verification", mustUseTools null
+- Only set mustUseTools to tool names listed in AVAILABLE TOOLS above — do NOT reference tools that are not available
+- If the required tool is not in AVAILABLE TOOLS, set mustUseTools to null
+- "testing" type should only be set when the user explicitly wants something executed and verified
 - If no specific tools are required, set mustUseTools to null
 - Always include at least one requirement entry`;
         try {
@@ -140,102 +180,7 @@ CRITICAL RULES for requirements:
             requirements: [{ type: 'other', description: 'General task completion' }],
         };
     }
-    /**
-     * @deprecated Use analyzeTaskRequirements() instead. Kept for reference.
-     * Determine involvement level based on user request complexity
-     */
-    determineInvolvementLevel(userMessage, subtasks) {
-        const messageLower = userMessage.toLowerCase();
-        const subtasksLower = subtasks.join(' ').toLowerCase();
-        // THOROUGH: User explicitly requests testing/verification
-        const testKeywords = ['test', 'verify', 'check', 'make sure', 'ensure', 'validate'];
-        if (testKeywords.some(kw => messageLower.includes(kw))) {
-            logger.debug('[Client] THOROUGH mode: Testing/verification requested');
-            return InvolvementLevel.THOROUGH;
-        }
-        // THOROUGH: After failures (user frustrated)
-        if (this.failureCount > 0) {
-            logger.debug(`[Client] THOROUGH mode: ${this.failureCount} previous failures detected`);
-            return InvolvementLevel.THOROUGH;
-        }
-        // THOROUGH: Complex multi-file operations
-        if (subtasks.length > 3 || (messageLower.includes('component') && messageLower.includes('index.html'))) {
-            logger.debug('[Client] THOROUGH mode: Complex multi-file operation');
-            return InvolvementLevel.THOROUGH;
-        }
-        // MINIMAL: Information-only requests
-        const infoKeywords = ['what', 'list', 'show', 'explain', 'describe', 'how', 'tell me'];
-        const creationKeywords = ['create', 'build', 'write', 'generate', 'make', 'add'];
-        const hasInfoKeyword = infoKeywords.some(kw => messageLower.includes(kw));
-        const hasCreationKeyword = creationKeywords.some(kw => messageLower.includes(kw));
-        if (hasInfoKeyword && !hasCreationKeyword) {
-            logger.debug('[Client] MINIMAL mode: Information request');
-            return InvolvementLevel.MINIMAL;
-        }
-        // STANDARD: Default for creation/modification tasks
-        logger.debug('[Client] STANDARD mode: Regular creation task');
-        return InvolvementLevel.STANDARD;
-    }
-    /**
-     * @deprecated Use analyzeTaskRequirements() instead. Kept for reference.
-     * Parse requirements from user message
-     */
-    parseRequirements(userMessage, subtasks) {
-        const requirements = [];
-        const messageLower = userMessage.toLowerCase();
-        const combined = (messageLower + ' ' + subtasks.join(' ').toLowerCase());
-        // Detect file creation requirements
-        const fileMatches = userMessage.match(/(?:create|build|generate|write|save as)\s+([a-zA-Z0-9._/-]+\.(html|js|css|md|json|txt|py|ts|tsx|jsx))/gi);
-        if (fileMatches) {
-            fileMatches.forEach(match => {
-                const filename = match.split(/\s+/).pop();
-                if (filename) {
-                    requirements.push({
-                        type: 'file_creation',
-                        description: `Create file: ${filename}`,
-                        filePath: filename,
-                    });
-                }
-            });
-        }
-        // Detect testing requirements (explicit verification requests)
-        const testKeywords = ['test', 'verify', 'check', 'make sure', 'ensure'];
-        if (testKeywords.some(kw => combined.includes(kw))) {
-            requirements.push({
-                type: 'testing',
-                description: 'Verify functionality through testing',
-                mustUseTools: ['playwright__'],
-            });
-        }
-        // Detect browser verification requirements - ONLY for file verification, not general browsing
-        // This should trigger for "open index.html in browser" but NOT for "open linkedin.com"
-        const isLocalFileOpen = (combined.includes('open') && combined.includes('.html')) ||
-            (combined.includes('browser') && combined.includes('.html'));
-        const isExternalUrl = combined.match(/open\s+(?:https?:\/\/)?(?:www\.)?[a-z0-9-]+\.[a-z]{2,}/i);
-        if (isLocalFileOpen && !isExternalUrl) {
-            requirements.push({
-                type: 'verification',
-                description: 'Browser testing required for local HTML file',
-                mustUseTools: ['playwright__browser_navigate', 'playwright__browser_console_messages'],
-            });
-        }
-        // For external URLs, don't require specific tools - just opening the page is enough
-        if (isExternalUrl) {
-            requirements.push({
-                type: 'verification',
-                description: 'Open external URL',
-                // No mustUseTools - Worker just needs to navigate, Client shouldn't demand specific validation tools
-            });
-        }
-        // Default: at least verify Worker did some work
-        if (requirements.length === 0) {
-            requirements.push({
-                type: 'other',
-                description: 'General task completion',
-            });
-        }
-        return requirements;
-    }
+    // ─── Main Validation Entry Point ──────────────────────────────────────────
     /**
      * Validate Worker's work at appropriate involvement level
      */
@@ -388,6 +333,7 @@ Respond ONLY with the JSON, no other text.`;
         }
         const toolList = workerResult.toolsUsed.join(', ');
         const uniqueTools = [...new Set(workerResult.toolsUsed)].join(', ');
+        const availableToolsContext = this.buildToolContextForPrompt();
         const coherencePrompt = `You are a strict quality auditor. Your job is to determine whether a Worker agent's result is SUPPORTED by the tools it actually used, or whether it fabricated/hallucinated claims.
 
 USER REQUEST: ${userMessage}
@@ -399,13 +345,16 @@ TOOLS ACTUALLY USED (in order): ${toolList}
 UNIQUE TOOLS USED: ${uniqueTools}
 TOTAL TOOL CALLS: ${workerResult.toolsUsed.length}
 
+AVAILABLE TOOLS IN THIS SYSTEM:
+${availableToolsContext}
+
 CRITICAL: Analyze whether the claims in the Worker's result are supported by the tools it used.
 
-Key tool semantics:
-- filesystem__list_directory / filesystem__directory_tree / filesystem__search_files = only shows file/folder NAMES and structure, does NOT read file contents
-- filesystem__read_text_file / filesystem__read_file = actually reads file content
-- mcp-shell-server__shell_exec = runs a shell command (check what command was likely run based on context)
-- playwright__* = browser automation tools
+Key tool semantics to apply:
+- Tools with names like "list_directory", "directory_tree", "search_files" show file/folder NAMES only — they do NOT read file contents
+- Tools with names like "read_text_file", "read_file", "get_file_content" actually read file content
+- Tools with names like "shell_exec", "run_command", "bash", "execute" run shell commands — infer what was run from the worker's result
+- For any other tool, infer its semantics from its name
 
 Common hallucination patterns to detect:
 1. Worker claims to have "inspected", "reviewed", "analyzed", or "scanned" source code but never used read_text_file — it only listed directories
@@ -503,46 +452,51 @@ Respond ONLY with valid JSON:
                 }
             }
         }
-        // Browser testing validation (only for THOROUGH)
+        // Shell-based deep verification (THOROUGH only)
         if (level === InvolvementLevel.THOROUGH) {
-            for (const req of requirements) {
-                if ((req.type === 'testing' || req.type === 'verification') &&
-                    workerResult.result.includes('.html')) {
-                    // Extract HTML filename from result
-                    const htmlMatch = workerResult.result.match(/([a-zA-Z0-9._-]+\.html)/);
-                    if (htmlMatch) {
-                        const htmlFile = htmlMatch[1];
-                        const browserValidation = await this.validateInBrowser(htmlFile);
-                        if (!browserValidation.valid) {
-                            issues.push(browserValidation.issue);
-                        }
-                    }
-                }
-            }
+            const shellIssues = await this.validateWithShell(requirements, workerResult);
+            issues.push(...shellIssues.issues);
         }
         return { issues };
     }
+    // ─── Tool-Based Verification ────────────────────────────────────────────────────
     /**
-     * Check if file exists using read tool
+     * Check whether a file exists, using whichever MCP tool is available.
+     * Tries filesystem read tools first, then falls back to shell.
      */
     async fileExists(filePath) {
-        try {
-            await this.mcpClient.executeTool('filesystem__read_text_file', {
-                path: filePath,
-                head: 1,
-            });
-            return true;
+        const readTool = this.findTool('read_text_file', 'read_file', 'get_file_content');
+        if (readTool) {
+            try {
+                await this.mcpClient.executeTool(readTool, { path: filePath, head: 1 });
+                return true;
+            }
+            catch {
+                return false;
+            }
         }
-        catch (error) {
-            return false;
+        const shellTool = this.findTool('shell_exec', 'run_command', 'bash', 'execute');
+        if (shellTool) {
+            try {
+                const result = await this.mcpClient.executeTool(shellTool, {
+                    command: `test -f "${filePath}" && echo "exists" || echo "not_found"`,
+                });
+                return String(result).includes('exists');
+            }
+            catch {
+                return false;
+            }
         }
+        logger.debug('[Client] No tool available to verify file existence');
+        return false;
     }
     /**
      * Use LLM to generate an actionable correction instruction from raw validation issues.
-     * Instead of echoing "requires using playwright__ but Worker did not use these tools",
-     * produces something like "Use the filesystem tools to list ~/Library/Caches and report sizes".
+     * Translates internal validation failures into concrete, tool-specific directions
+     * for the Worker, referencing only the tools actually available in the system.
      */
     async generateCorrectionInstruction(userMessage, subtask, issues, workerResult) {
+        const availableToolsContext = this.buildToolContextForPrompt();
         const correctionPrompt = `You are generating a correction instruction for a Worker agent that failed to complete a task properly.
 
 ORIGINAL USER REQUEST: ${userMessage}
@@ -555,10 +509,12 @@ ${issues.map((issue, i) => `${i + 1}. ${issue}`).join('\n')}
 WORKER'S RESULT (first 300 chars): ${workerResult.result.substring(0, 300)}
 TOOLS WORKER USED: ${workerResult.toolsUsed.join(', ') || 'none'}
 
+AVAILABLE TOOLS THE WORKER CAN USE:
+${availableToolsContext}
+
 Generate a CLEAR, ACTIONABLE instruction that tells the Worker exactly what to do to fix the issues.
 The instruction should:
-- Be a direct command (e.g., "Use the run_process tool to execute 'du -sh ~/Library/Caches' and report the output")
-- Reference specific tools or actions the Worker should take
+- Be a direct command referencing specific available tools by name
 - Be concise (1-2 sentences)
 - NOT include validation jargon like "mustUseTools", "requirements", or "involvement level"
 - NOT be a generic statement like "retry the task" — be specific about WHAT to do
@@ -584,74 +540,101 @@ Respond ONLY with the correction instruction text, nothing else.`;
         return `Fix the following issue and retry: ${issues[0]}`;
     }
     /**
-     * Validate file contents for common issues
+     * Validate file contents for common issues, using whichever MCP tool is available.
      */
     async validateFileContents(filePath) {
-        try {
-            const content = await this.mcpClient.executeTool('filesystem__read_text_file', {
-                path: filePath,
-                head: 200,
-            });
-            const contentStr = typeof content === 'string' ? content : JSON.stringify(content);
-            // Check for HTML path mismatches
-            if (filePath.endsWith('.html')) {
-                const hrefMatches = contentStr.match(/href="([^"]+)"/g) || [];
-                const srcMatches = contentStr.match(/src="([^"]+)"/g) || [];
-                for (const match of [...hrefMatches, ...srcMatches]) {
-                    const pathMatch = match.match(/(?:href|src)="([^"]+)"/);
-                    if (pathMatch) {
-                        const referencedPath = pathMatch[1];
-                        if (!referencedPath.startsWith('http') && !referencedPath.startsWith('data:')) {
-                            const exists = await this.fileExists(referencedPath);
-                            if (!exists) {
-                                return {
-                                    valid: false,
-                                    issue: `HTML references non-existent file: ${referencedPath}. Fix file paths or create missing files.`
-                                };
-                            }
+        const readTool = this.findTool('read_text_file', 'read_file', 'get_file_content');
+        const shellTool = this.findTool('shell_exec', 'run_command', 'bash', 'execute');
+        let contentStr = null;
+        if (readTool) {
+            try {
+                const content = await this.mcpClient.executeTool(readTool, { path: filePath, head: 200 });
+                contentStr = typeof content === 'string' ? content : JSON.stringify(content);
+            }
+            catch (error) {
+                return { valid: false, issue: `Could not read file: ${error}` };
+            }
+        }
+        else if (shellTool) {
+            try {
+                const content = await this.mcpClient.executeTool(shellTool, {
+                    command: `head -200 "${filePath}" 2>&1`,
+                });
+                contentStr = String(content);
+            }
+            catch (error) {
+                return { valid: false, issue: `Could not read file via shell: ${error}` };
+            }
+        }
+        if (contentStr === null) {
+            return { valid: true }; // No read tool available; skip content check
+        }
+        // Check path reference integrity in HTML files
+        if (filePath.endsWith('.html')) {
+            const hrefMatches = contentStr.match(/href="([^"]+)"/g) || [];
+            const srcMatches = contentStr.match(/src="([^"]+)"/g) || [];
+            for (const match of [...hrefMatches, ...srcMatches]) {
+                const pathMatch = match.match(/(?:href|src)="([^"]+)"/);
+                if (pathMatch) {
+                    const referencedPath = pathMatch[1];
+                    if (!referencedPath.startsWith('http') && !referencedPath.startsWith('data:')) {
+                        const exists = await this.fileExists(referencedPath);
+                        if (!exists) {
+                            return {
+                                valid: false,
+                                issue: `HTML references non-existent file: ${referencedPath}. Fix file paths or create missing files.`,
+                            };
                         }
                     }
                 }
             }
-            return { valid: true };
-        }
-        catch (error) {
-            return { valid: false, issue: `Could not read file: ${error}` };
         }
+        return { valid: true };
     }
     /**
-     * Validate HTML file in browser
+     * THOROUGH-level shell-based verification: runs lightweight, read-only shell
+     * commands to confirm work was actually done (file sizes, test output presence, etc.).
+     * Skips gracefully when no shell tool is available.
      */
-    async validateInBrowser(htmlFile) {
-        try {
-            // Navigate to file
-            const workspaceDir = process.cwd();
-            const fileUrl = `file://${workspaceDir}/${htmlFile}`;
-            await this.mcpClient.executeTool('playwright__browser_navigate', {
-                url: fileUrl,
-            });
-            // Check for console errors
-            const errors = await this.mcpClient.executeTool('playwright__browser_console_messages', {
-                level: 'error',
-            });
-            const errorStr = typeof errors === 'string' ? errors : JSON.stringify(errors);
-            if (errorStr && errorStr.length > 0 && !errorStr.includes('[]')) {
-                return {
-                    valid: false,
-                    issue: `Browser errors detected in ${htmlFile}: ${errorStr}. Fix these errors before delivery.`
-                };
-            }
-            return { valid: true };
+    async validateWithShell(requirements, workerResult) {
+        const issues = [];
+        const shellTool = this.findTool('shell_exec', 'run_command', 'bash', 'execute');
+        if (!shellTool) {
+            logger.debug('[Client] No shell tool available for THOROUGH shell validation — skipping');
+            return { issues };
         }
-        catch (error) {
-            logger.debug(`[Client] Browser validation error: ${error}`);
-            // Don't fail validation if browser test fails - might not have browser available
-            return { valid: true };
+        for (const req of requirements) {
+            if ((req.type === 'file_creation' || req.type === 'file_modification') && req.filePath) {
+                try {
+                    const result = await this.mcpClient.executeTool(shellTool, {
+                        command: `wc -c "${req.filePath}" 2>&1`,
+                    });
+                    const resultStr = String(result);
+                    if (resultStr.includes('No such file') || resultStr.includes('cannot access')) {
+                        issues.push(`Shell verification failed: ${req.filePath} does not exist on disk.`);
+                    }
+                    else {
+                        const sizeMatch = resultStr.match(/^\s*(\d+)/);
+                        if (sizeMatch && parseInt(sizeMatch[1], 10) === 0) {
+                            issues.push(`File ${req.filePath} was created but is empty.`);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[Client] Shell validation error for ${req.filePath}: ${error}`);
+                }
+            }
+            if (req.type === 'testing') {
+                const hasTestOutput = workerResult.result.match(/passed|failed|error|PASS|FAIL|✓|✗|tests run|test suite/i);
+                if (!hasTestOutput) {
+                    logger.debug('[Client] THOROUGH: testing requirement but no test output detected in worker result');
+                }
+            }
         }
+        return { issues };
     }
-    /**
-     * Reset failure tracking (for new conversation/session)
-     */
+    // ─── Session Management ─────────────────────────────────────────────────────
+    /** Reset failure tracking (call at the start of each new conversation/session). */
     resetFailureTracking() {
         this.failureCount = 0;
     }