agents-library 0.1.0 → 0.1.1

package/dist/worker-agent-factory.js

@@ -24,11 +24,13 @@
  *
  * @module worker-agent-factory
  */
-import { KadiClient, z } from '@kadi.build/core';
+import { z } from '@kadi.build/core';
 import { BaseBot } from './base-bot.js';
-import { TaskAssignedEventSchema } from './types/event-schemas.js';
+import { BaseAgent } from './base-agent.js';
+import { TaskAssignedEventSchema, } from './types/event-schemas.js';
 import { logger, MODULE_AGENT } from './utils/logger.js';
 import { timer } from './utils/timer.js';
+import { formatMemoryContext } from './memory/memory-service.js';
 // ============================================================================
 // Configuration Validation Schema
 // ============================================================================
@@ -56,6 +58,7 @@ import { timer } from './utils/timer.js';
  * ```
  */
 const WorkerAgentConfigSchema = z.object({
+    agentId: z.string().optional(),
     role: z.enum(['artist', 'designer', 'programmer']),
     worktreePath: z.string().min(1, 'Worktree path is required'),
     brokerUrl: z.string()
@@ -107,30 +110,11 @@ const WorkerAgentConfigSchema = z.object({
  * // Agent now listens for {role}.task.assigned events and executes tasks
  * ```
  */
-export class BaseWorkerAgent {
+export class BaseWorkerAgent extends BaseAgent {
     // ============================================================================
     // Protected Properties (accessible to subclasses/extensions)
     // ============================================================================
-    /**
-     * KĀDI client for broker communication
-     *
-     * Used for:
-     * - Subscribing to events
-     * - Publishing completion/failure events
-     * - Invoking remote MCP tools (git, file management)
-     */
-    client;
-    /**
-     * LLM provider manager for model selection and chat
-     *
-     * Replaces direct Anthropic SDK usage. Provides:
-     * - Model-based routing (claude→Anthropic, gpt→Model Manager)
-     * - Automatic fallback on provider failure
-     * - Tool-calling via ChatOptions.tools
-     *
-     * Optional — if null, agent cannot execute tasks requiring LLM.
-     */
-    providerManager = null;
+    // NOTE: client, providerManager, memoryService are inherited from BaseAgent
     /**
      * Agent role (artist, designer, programmer)
      *
@@ -218,17 +202,27 @@ export class BaseWorkerAgent {
      */
     baseBot = null;
     /**
-     * Full agent configuration
-     *
-     * Stored for reference and potential reconfiguration.
+     * Worker-specific configuration (role, worktree, model, etc.)
      */
-    config;
+    workerConfig;
     /**
      * Set of task IDs that have been processed or are currently in-flight.
      * Prevents duplicate execution when the same task.assigned event arrives
      * multiple times (e.g., retry re-publish while first execution is still running).
      */
     processedTaskIds = new Set();
+    /**
+     * Natively loaded ability-file-local for zero-latency file operations.
+     * Loaded in initializeClient(), null if not installed or load fails.
+     */
+    nativeFileLocal = null;
+    /** Tool names provided by ability-file-local (used for routing) */
+    static FILE_LOCAL_TOOLS = new Set([
+        'list_files_and_folders', 'move_and_rename', 'copy_file',
+        'delete_file_or_folder', 'create_folder', 'create_file',
+        'watch_folder', 'unwatch_folder', 'compress_file', 'decompress_file',
+        'compress_multiple_files', 'decompress_multiple_files', 'search_files',
+    ]);
     // ============================================================================
     // Constructor
     // ============================================================================
@@ -257,33 +251,68 @@ export class BaseWorkerAgent {
      * ```
      */
     constructor(config) {
+        // If WorkerAgentFullConfig (has agentId at top level), use BaseAgent inheritance
+        const isFullConfig = 'agentId' in config && 'brokerUrl' in config && 'role' in config && 'agentRole' in config;
+        if (isFullConfig) {
+            // WorkerAgentFullConfig path: BaseAgent handles client, providers, memory
+            const fullConfig = config;
+            super({
+                agentId: fullConfig.agentId,
+                agentRole: fullConfig.agentRole,
+                version: fullConfig.version,
+                brokerUrl: fullConfig.brokerUrl,
+                networks: fullConfig.networks,
+                additionalBrokers: fullConfig.additionalBrokers,
+                provider: fullConfig.provider,
+                memory: fullConfig.memory,
+            });
+        }
+        else {
+            // Legacy WorkerAgentConfig path: create minimal BaseAgent config
+            const legacyConfig = config;
+            super({
+                agentId: legacyConfig.agentId || `agent-${legacyConfig.role}`,
+                agentRole: legacyConfig.role,
+                brokerUrl: legacyConfig.brokerUrl,
+                networks: legacyConfig.networks,
+                provider: legacyConfig.anthropicApiKey ? {
+                    anthropicApiKey: legacyConfig.anthropicApiKey,
+                } : undefined,
+            });
+        }
         // Start factory timer for lifetime tracking
         timer.start('factory');
-        // Store full configuration
-        this.config = config;
+        // Store worker-specific configuration
+        this.workerConfig = 'anthropicApiKey' in config
+            ? config
+            : {
+                // Convert WorkerAgentFullConfig to WorkerAgentConfig for internal use
+                role: config.role,
+                worktreePath: config.worktreePath,
+                brokerUrl: config.brokerUrl,
+                networks: config.networks,
+                anthropicApiKey: config.provider?.anthropicApiKey || '',
+                agentId: config.agentId,
+                claudeModel: config.claudeModel,
+                capabilities: config.capabilities,
+                customBehaviors: config.customBehaviors,
+            };
         // Extract and store individual config properties
-        this.role = config.role;
-        this.worktreePath = config.worktreePath;
+        this.role = 'role' in config ? config.role : config.role;
+        this.worktreePath = 'worktreePath' in config ? config.worktreePath : '';
         this.networks = config.networks;
         this.claudeModel = config.claudeModel || 'claude-sonnet-4-20250514';
         this.capabilities = config.capabilities || [];
         this.toolPrefixes = [];
-        // Initialize KĀDI client
-        this.client = new KadiClient({
-            name: `agent-${config.role}`,
-            version: '1.0.0',
-            brokers: {
-                default: { url: config.brokerUrl, networks: config.networks }
-            },
-            defaultBroker: 'default',
-        });
         // COMPOSITION: Create BaseBot instance for circuit breaker and retry logic
-        // Only created when anthropicApiKey is available (backward compatibility)
-        if (config.anthropicApiKey) {
+        const apiKey = 'anthropicApiKey' in config
+            ? config.anthropicApiKey
+            : config.provider?.anthropicApiKey;
+        if (apiKey) {
             const baseBotConfig = {
-                client: this.client,
-                anthropicApiKey: config.anthropicApiKey,
-                botUserId: `agent-${config.role}`
+                client: this.client, // inherited from BaseAgent
+                anthropicApiKey: apiKey,
+                botUserId: this.workerConfig.agentId || `agent-${this.role}`,
             };
             this.baseBot = new (class extends BaseBot {
                 async handleMention(_event) { }
@@ -295,6 +324,20 @@ export class BaseWorkerAgent {
     // ============================================================================
     // Protected Initialization Methods
     // ============================================================================
+    /**
+     * Override BaseAgent.connect() to load native abilities after broker connection.
+     */
+    async connect() {
+        await super.connect();
+        // Load ability-file-local natively (zero-latency file ops, in-process)
+        try {
+            this.nativeFileLocal = await this.client.loadNative('ability-file-local');
+            logger.info(MODULE_AGENT, 'Loaded ability-file-local natively', timer.elapsed('factory'));
+        }
+        catch (err) {
+            logger.warn(MODULE_AGENT, `Could not load ability-file-local natively: ${err.message} — will use broker`, timer.elapsed('factory'));
+        }
+    }
     /**
      * Initialize KĀDI client and connect to broker
      *
@@ -316,14 +359,12 @@ export class BaseWorkerAgent {
      * ```
      */
     async initializeClient() {
-        logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, '🔌 Initializing KĀDI client...', timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, 'Initializing KADI client...', timer.elapsed('factory'));
         try {
             // Step 1: Start client connection to broker
-            logger.info(MODULE_AGENT, '   → Connecting to broker...', timer.elapsed('factory'));
             try {
                 await this.client.connect();
-                logger.info(MODULE_AGENT, '   ✅ Connected to broker', timer.elapsed('factory'));
+                logger.debug(MODULE_AGENT, 'Connected to broker', timer.elapsed('factory'));
             }
             catch (error) {
                 logger.error(MODULE_AGENT, `Client connection error: ${error.message || String(error)}`, timer.elapsed('factory'), error);
@@ -331,23 +372,15 @@ export class BaseWorkerAgent {
             }
             // Step 2: Initialize ability response subscription (if BaseBot available)
             if (this.baseBot) {
-                logger.info(MODULE_AGENT, '   → Initializing ability response subscription...', timer.elapsed('factory'));
                 await this.baseBot['initializeAbilityResponseSubscription']();
-                logger.info(MODULE_AGENT, '   ✅ Ability response subscription initialized', timer.elapsed('factory'));
+                logger.debug(MODULE_AGENT, 'Ability response subscription initialized', timer.elapsed('factory'));
             }
-            logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, '✅ KĀDI client initialized successfully', timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, `   Networks: ${this.networks.join(', ')}`, timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, `   Protocol: Ready`, timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
+            logger.debug(MODULE_AGENT, `KADI client ready (networks: ${this.networks.join(', ')})`, timer.elapsed('factory'));
             // Note: client.serve() continues running in background to handle incoming requests
             // We don't await it because it never resolves (blocks indefinitely)
         }
         catch (error) {
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, 'Failed to initialize KĀDI client', timer.elapsed('factory'), error);
-            logger.error(MODULE_AGENT, `   Error: ${error.message || String(error)}`, timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
+            logger.error(MODULE_AGENT, 'Failed to initialize KADI client', timer.elapsed('factory'), error);
             throw error;
         }
     }
@@ -377,22 +410,15 @@ export class BaseWorkerAgent {
     async subscribeToTaskAssignments() {
         // Subscribe to generic task.assigned topic (role filtering done in handler)
         const topic = `task.assigned`;
-        logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `📡 Subscribing to task assignments...`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `   Topic: ${topic}`, timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `Subscribing to task assignments (topic: ${topic})...`, timer.elapsed('factory'));
         try {
             // Subscribe to event topic with bound callback
             // Using .bind(this) to preserve instance context in callback
             await this.client.subscribe(topic, this.handleTaskAssignment.bind(this), { broker: 'default' });
-            logger.info(MODULE_AGENT, `   ✅ Subscribed successfully`, timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
+            logger.debug(MODULE_AGENT, `Subscribed to ${topic}`, timer.elapsed('factory'));
         }
         catch (error) {
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, `Failed to subscribe to task assignments`, timer.elapsed('factory'), error);
-            logger.error(MODULE_AGENT, `   Topic: ${topic}`, timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, `   Error: ${error.message || String(error)}`, timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
+            logger.error(MODULE_AGENT, `Failed to subscribe to task assignments (topic: ${topic})`, timer.elapsed('factory'), error);
             throw error;
         }
     }
@@ -466,8 +492,9 @@ export class BaseWorkerAgent {
             }
             // Mark task as in-flight before execution
             this.processedTaskIds.add(validatedEvent.taskId);
-            // Capability validation: check if task matches this agent's capabilities
-            if (this.capabilities.length > 0) {
+            // Capability validation: skip if task role matches this agent's role (role-based routing
+            // already ensures correct assignment). Only validate when roles don't match or are missing.
+            if (this.capabilities.length > 0 && validatedEvent.role !== this.role) {
                 const rejectionReason = this.validateTaskCapability(validatedEvent);
                 if (rejectionReason) {
                     logger.warn(MODULE_AGENT, `   ⚠️  Task capability mismatch`, timer.elapsed('factory'));
@@ -479,6 +506,9 @@ export class BaseWorkerAgent {
                 }
                 logger.info(MODULE_AGENT, `   ✅ Capability check passed`, timer.elapsed('factory'));
             }
+            else if (validatedEvent.role === this.role) {
+                logger.info(MODULE_AGENT, `   ✅ Role match (${this.role}) — skipping capability check`, timer.elapsed('factory'));
+            }
             // Worktree scope validation: soft warning only (worker always operates within its worktree directory)
             const outOfScopeReason = this.validateTaskScope(validatedEvent);
             if (outOfScopeReason) {
@@ -579,9 +609,23 @@ export class BaseWorkerAgent {
             }
             // Step 4: Build tool definitions — local tools + dynamic discovery from broker
             const tools = await this.buildToolDefinitionsAsync();
-            logger.info(MODULE_AGENT, `🔧 Available tools: ${tools.length} (prefixes: ${this.toolPrefixes.join(', ') || 'none'})`, timer.elapsed('factory'));
+            logger.info(MODULE_AGENT, `🔧 Available tools: ${tools.length}`, timer.elapsed('factory'));
+            // Step 4.5: Recall relevant past experience (non-blocking, best-effort)
+            let memoryContext = '';
+            if (this.memoryService) {
+                try {
+                    const recallResult = await this.memoryService.recallRelevant(this.role, task.description, this.role, 3, ['*']);
+                    if (recallResult.success && recallResult.data.length > 0) {
+                        memoryContext = formatMemoryContext(recallResult.data);
+                        logger.info(MODULE_AGENT, `Recalled ${recallResult.data.length} past patterns`, timer.elapsed('factory'));
+                    }
+                }
+                catch (err) {
+                    logger.warn(MODULE_AGENT, `Memory recall failed (non-fatal): ${err.message}`, timer.elapsed('factory'));
+                }
+            }
             // Step 5: Build initial system prompt
-            const systemPrompt = this.buildTaskSystemPrompt(task, implementationGuide, verificationCriteria);
+            const systemPrompt = this.buildTaskSystemPrompt(task, implementationGuide, verificationCriteria, memoryContext);
             // Step 6: Enter tool-calling agent loop
             const messages = [
                 { role: 'user', content: systemPrompt }
@@ -598,6 +642,7 @@ export class BaseWorkerAgent {
             const filesModified = [];
             let commitSha = 'unknown';
             let finalResponse = '';
+            let consecutiveFailures = 0;
             for (let iteration = 0; iteration < BaseWorkerAgent.MAX_TOOL_LOOP_ITERATIONS; iteration++) {
                 logger.info(MODULE_AGENT, `🔄 Agent loop iteration ${iteration + 1}/${BaseWorkerAgent.MAX_TOOL_LOOP_ITERATIONS}`, timer.elapsed('factory'));
                 const result = await this.providerManager.chat(messages, chatOptions);
@@ -641,9 +686,11 @@ export class BaseWorkerAgent {
                                 content: resultText,
                                 tool_call_id: toolCall.id
                             });
+                            consecutiveFailures = 0;
                             logger.info(MODULE_AGENT, `   ✅ Tool ${toolName} succeeded`, timer.elapsed('factory'));
                         }
                         catch (error) {
+                            consecutiveFailures++;
                             const errorMsg = `Tool ${toolName} failed: ${error.message || String(error)}`;
                             logger.error(MODULE_AGENT, `   ❌ ${errorMsg}`, timer.elapsed('factory'));
                             messages.push({
@@ -653,6 +700,14 @@ export class BaseWorkerAgent {
                             });
                         }
                     }
+                    // Circuit breaker: if 3+ consecutive tool failures, tell LLM to stop retrying
+                    if (consecutiveFailures >= 3) {
+                        logger.warn(MODULE_AGENT, `⚠️  Circuit breaker: ${consecutiveFailures} consecutive tool failures — instructing LLM to wrap up`, timer.elapsed('factory'));
+                        messages.push({
+                            role: 'user',
+                            content: 'SYSTEM: Multiple consecutive tool failures detected. Stop retrying failed tools and provide your final response summarizing what you accomplished so far.'
+                        });
+                    }
                     // Continue loop — LLM will process tool results
                 }
                 else {
@@ -662,18 +717,49 @@ export class BaseWorkerAgent {
                     break;
                 }
             }
-            // Step 7: Publish completion event
-            const contentSummary = finalResponse.length > 500
-                ? finalResponse.substring(0, 500) + `... (${finalResponse.length} chars total)`
-                : finalResponse;
-            await this.publishCompletion(task.taskId, task.questId, filesCreated, filesModified, commitSha, contentSummary);
+            // Step 7: Safety net — auto-commit if LLM forgot to commit
+            if (commitSha === 'unknown' && (filesCreated.length > 0 || filesModified.length > 0)) {
+                logger.warn(MODULE_AGENT, `⚠️  LLM did not commit — auto-committing staged changes`, timer.elapsed('factory'));
+                try {
+                    const commitMsg = this.commitFormat
+                        ? this.commitFormat.replace('{taskId}', task.taskId)
+                        : `feat(${this.role}): task ${task.taskId}`;
+                    const commitResult = await this.executeRemoteTool('git_git_commit', { path: this.worktreePath, message: commitMsg });
+                    const sha = this.extractCommitSha(commitResult);
+                    if (sha) {
+                        commitSha = sha;
+                        logger.info(MODULE_AGENT, `   ✅ Auto-commit succeeded: ${sha.substring(0, 7)}`, timer.elapsed('factory'));
+                    }
+                    else {
+                        logger.warn(MODULE_AGENT, `   ⚠️  Auto-commit returned no SHA`, timer.elapsed('factory'));
+                    }
+                }
+                catch (err) {
+                    logger.warn(MODULE_AGENT, `   ⚠️  Auto-commit failed: ${err.message}`, timer.elapsed('factory'));
+                }
+            }
+            // Step 8: Publish completion or failure event
+            if (!commitSha || commitSha === 'unknown') {
+                logger.warn(MODULE_AGENT, `⚠️  No valid commit SHA — publishing task.failed instead of review request`, timer.elapsed('factory'));
+                // Clear dedup so agent-lead retries are accepted
+                this.processedTaskIds.delete(task.taskId);
+                await this.publishFailure(task.taskId, new Error('Git commit failed — no valid commit SHA available. Files may have been written but were not committed.'), task.questId, task.retryAttempt);
+            }
+            else {
+                const contentSummary = finalResponse.length > 500
+                    ? finalResponse.substring(0, 500) + `... (${finalResponse.length} chars total)`
+                    : finalResponse;
+                await this.publishCompletion(task.taskId, task.questId, filesCreated, filesModified, commitSha, contentSummary, task.retryAttempt);
+            }
             logger.info(MODULE_AGENT, `✅ Task ${task.taskId} execution completed`, timer.elapsed('factory'));
         }
         catch (error) {
             logger.error(MODULE_AGENT, `Failed to execute task ${task.taskId}`, timer.elapsed('factory'), error);
             logger.error(MODULE_AGENT, `   Error: ${error.message || String(error)}`, timer.elapsed('factory'));
             logger.error(MODULE_AGENT, `   Stack: ${error.stack || 'No stack trace'}`, timer.elapsed('factory'));
-            await this.publishFailure(task.taskId, error, task.questId);
+            // Clear dedup so agent-lead retries are accepted
+            this.processedTaskIds.delete(task.taskId);
+            await this.publishFailure(task.taskId, error, task.questId, task.retryAttempt);
             throw error;
         }
     }
@@ -686,10 +772,13 @@ export class BaseWorkerAgent {
      * Includes task context, role identity, worktree path, and instructions
      * for using available tools (git, file operations).
      */
-    buildTaskSystemPrompt(task, implementationGuide, verificationCriteria) {
+    buildTaskSystemPrompt(task, implementationGuide, verificationCriteria, memoryContext) {
         const retryContext = task.feedback
             ? `\n⚠️ REVISION REQUIRED (Attempt #${task.retryAttempt || 1})\nPrevious attempt was rejected. Feedback:\n${task.feedback}\nPlease carefully address the feedback above.\n`
             : '';
+        const predecessorContext = task.predecessors && task.predecessors.length > 0
+            ? `\n## Predecessor Tasks\nThe following tasks were completed before yours. You can read their output files using git_git_show with the branch name:\n${task.predecessors.map(p => `- **${p.role}** task (${p.taskId}): branch \`${p.branch}\`${p.commitHash ? ` commit \`${p.commitHash}\`` : ''}\n  To read a file: git_git_show with path="${this.worktreePath}" and object="${p.branch}:<filename>"`).join('\n')}\n`
+            : '';
         return `You are a ${this.role} agent working in the KĀDI multi-agent system.
 Your worktree directory is: ${this.worktreePath}
 
@@ -697,28 +786,30 @@ Task ID: ${task.taskId}
 Description: ${task.description}
 Implementation Guide: ${implementationGuide}
 ${verificationCriteria ? `Verification Criteria: ${verificationCriteria}` : ''}
-${retryContext}
+${retryContext}${predecessorContext}
+${memoryContext ? `\n## Past Experience\nThe following are relevant outcomes from past similar tasks. Use these to avoid known mistakes and apply proven patterns:\n${memoryContext}` : ''}
 
 Instructions:
 1. Analyze the task requirements carefully
 2. Create the necessary files in the worktree using available tools
-3. Stage and commit your changes using git tools
-4. When done, provide a brief summary of what you created
+3. Stage ALL changed files with git_git_add (pass path: "${this.worktreePath}")
+4. CRITICAL: You MUST call git_git_commit with path: "${this.worktreePath}" to commit your staged changes. Do NOT return a summary until you have committed.
+5. When done, provide a brief summary of what you created
 
 Important:
 - All file operations must be within the worktree: ${this.worktreePath}
-- Use git_git_add to stage files and git_git_commit to commit
+- For ALL git tools (git_git_add, git_git_commit, etc.), you MUST pass path: "${this.worktreePath}" as a parameter.
+- You MUST complete the full cycle: write files → git_git_add → git_git_commit. Skipping the commit is a failure.
 - If the task description specifies an exact commit message, you MUST use that exact message
 - Default commit message format (use ONLY when no commit message is specified in the task): "${this.commitFormat ? this.commitFormat.replace('{taskId}', task.taskId) : `feat(${this.role}): <description> [${task.taskId}]`}"
-- Focus on ${this.role === 'artist' ? 'creative and artistic elements' : this.role === 'designer' ? 'design principles and aesthetics' : 'code quality and best practices'}`;
+- Focus on ${this.role === 'artist' ? 'creative and artistic elements. IMPORTANT: You cannot generate binary image files (PNG, GIF, JPG). Instead, generate all pixel art and graphics as SVG files using <rect> elements on a grid. Use a limited palette (<=16 colors). Never create placeholder or fake image files — always produce real, renderable SVG that displays the intended artwork when opened in a browser.' : this.role === 'designer' ? 'design principles and aesthetics' : 'code quality and best practices'}`;
     }
     /**
      * Build tool definitions: local tools + dynamic discovery from KĀDI broker
      *
      * 1. Always includes local tools (write_file, read_file)
-     * 2. Discovers network tools from broker via kadi.ability.list
-     * 3. Filters network tools by toolPrefixes from role config
-     * 4. Converts to OpenAI-compatible ToolDefinition format
+     * 2. Discovers all network tools from broker via kadi.ability.list
+     * 3. Converts to OpenAI-compatible ToolDefinition format
      */
     async buildToolDefinitionsAsync() {
         const tools = [];
@@ -752,29 +843,53 @@ Important:
                 }
             }
         });
-        // Discover network tools from broker, filtered by toolPrefixes
-        if (this.toolPrefixes.length > 0 && this.client.isConnected()) {
+        // Include tools from natively loaded ability-file-local (available even without broker)
+        if (this.nativeFileLocal) {
+            const nativeTools = this.nativeFileLocal.getTools();
+            for (const tool of nativeTools) {
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name: tool.name,
+                        description: tool.description || '',
+                        parameters: tool.inputSchema || {
+                            type: 'object',
+                            properties: {},
+                            required: []
+                        }
+                    }
+                });
+            }
+            logger.info(MODULE_AGENT, `Added ${nativeTools.length} tools from native ability-file-local`, timer.elapsed('factory'));
+        }
+        // Discover network tools from broker, filtered by toolPrefixes if configured
+        if (this.client.isConnected()) {
             try {
                 const response = await this.client.invokeRemote('kadi.ability.list', { includeProviders: false });
                 if (response?.tools && Array.isArray(response.tools)) {
                     for (const tool of response.tools) {
-                        // Only include tools matching one of the configured prefixes
-                        if (this.toolPrefixes.some(prefix => tool.name.startsWith(prefix))) {
-                            tools.push({
-                                type: 'function',
-                                function: {
-                                    name: tool.name,
-                                    description: tool.description || '',
-                                    parameters: tool.inputSchema || {
-                                        type: 'object',
-                                        properties: {},
-                                        required: []
-                                    }
-                                }
-                            });
+                        // Skip tools already loaded natively (avoid duplicates)
+                        if (this.nativeFileLocal && BaseWorkerAgent.FILE_LOCAL_TOOLS.has(tool.name)) {
+                            continue;
                         }
+                        // If toolPrefixes configured, filter by prefix; otherwise include all
+                        if (this.toolPrefixes.length > 0 && !this.toolPrefixes.some(prefix => tool.name.startsWith(prefix))) {
+                            continue;
+                        }
+                        tools.push({
+                            type: 'function',
+                            function: {
+                                name: tool.name,
+                                description: tool.description || '',
+                                parameters: tool.inputSchema || {
+                                    type: 'object',
+                                    properties: {},
+                                    required: []
+                                }
+                            }
+                        });
                     }
-                    logger.info(MODULE_AGENT, `Discovered ${tools.length - 2} network tools from broker (filtered by prefixes: ${this.toolPrefixes.join(', ')})`, timer.elapsed('factory'));
+                    logger.info(MODULE_AGENT, `Discovered ${tools.length - 2} network tools from broker${this.toolPrefixes.length > 0 ? ` (filtered by prefixes: ${this.toolPrefixes.join(', ')})` : ''}`, timer.elapsed('factory'));
                 }
             }
             catch (error) {
@@ -783,7 +898,7 @@ Important:
                 this.appendHardcodedGitTools(tools);
             }
         }
-        else if (this.toolPrefixes.length > 0) {
+        else {
             // Not connected to broker — use hardcoded fallback
             logger.warn(MODULE_AGENT, 'Not connected to broker — using hardcoded tool definitions', timer.elapsed('factory'));
             this.appendHardcodedGitTools(tools);
@@ -794,7 +909,7 @@ Important:
      * Fallback: append hardcoded git tool definitions when broker discovery fails
      */
     appendHardcodedGitTools(tools) {
-        if (!this.toolPrefixes.some(p => p.startsWith('git_git_')))
+        if (this.toolPrefixes.length > 0 && !this.toolPrefixes.some(p => p.startsWith('git_git_')))
             return;
         tools.push({
             type: 'function',
@@ -908,8 +1023,17 @@ Important:
             const content = await fs.readFile(filePath, 'utf-8');
             return { success: true, content };
         }
+        // Route to native ability-file-local if loaded (zero-latency, in-process)
+        if (this.nativeFileLocal && BaseWorkerAgent.FILE_LOCAL_TOOLS.has(toolName)) {
+            return await this.nativeFileLocal.invoke(toolName, toolArgs);
+        }
         // Route to MCP tool via KĀDI broker
         const result = await this.client.invokeRemote(toolName, toolArgs);
+        // Check for error responses from the broker/tool
+        if (result?.isError) {
+            const errorText = result?.content?.[0]?.text ?? JSON.stringify(result);
+            throw new Error(`Remote tool ${toolName} returned error: ${errorText}`);
+        }
         // invokeRemote returns { content: [{ type, text }] } — extract text
         if (result?.content?.[0]?.text) {
             try {
@@ -982,8 +1106,8 @@ Important:
      * @returns Formatted commit message
      */
     formatCommitMessage(taskId, files, taskDescription) {
-        if (this.config.customBehaviors?.formatCommitMessage) {
-            return this.config.customBehaviors.formatCommitMessage(taskId, files);
+        if (this.workerConfig.customBehaviors?.formatCommitMessage) {
+            return this.workerConfig.customBehaviors.formatCommitMessage(taskId, files);
         }
         if (taskDescription) {
             const commitMsgMatch = taskDescription.match(/(?:commit.*?(?:with\s+)?message|commit\s+message)[\s:]*['"`]([^'"`]+)['"`]/i);
@@ -996,8 +1120,8 @@ Important:
     /**
      * Publish task completion event
      *
-     * Publishes TaskCompletedEvent to KĀDI broker with topic pattern: {role}.task.completed
-     * Event payload matches TaskCompletedEvent schema exactly for backward compatibility.
+     * Publishes TaskReviewRequestedPayload to KĀDI broker on the qa network.
+     * Per QUEST_WORKFLOW_V2: worker → task.review_requested → agent-qa for validation.
      *
      * Publishing failures are handled gracefully - errors are logged but do not throw.
      * This ensures task execution completes even if event publishing fails.
@@ -1015,42 +1139,53 @@ Important:
      *   [],
      *   'a1b2c3d4e5f6g7h8i9j0'
      * );
-     * // Publishes to: task.completed
+     * // Publishes to: task.review_requested (→ agent-qa)
      * ```
      */
-    async publishCompletion(taskId, questId, filesCreated, filesModified, commitSha, contentSummary) {
-        // Include worktree path for independent verification by agent-producer
-        const worktreePath = this.worktreePath;
-        // Generic topic — agent identity is in the payload (agent, role fields)
-        const topic = `task.completed`;
-        // Create payload matching TaskCompletedEvent schema
+    async publishCompletion(taskId, questId, _filesCreated, _filesModified, commitSha, _contentSummary, retryAttempt) {
+        // Per QUEST_WORKFLOW_V2: worker publishes task.review_requested → agent-qa for validation
+        const topic = `task.review_requested`;
+        // Create payload matching TaskReviewRequestedPayload schema
         const payload = {
             taskId,
-            questId,
-            role: this.role,
-            status: 'completed',
-            filesCreated,
-            filesModified,
-            commitSha,
-            timestamp: new Date().toISOString(),
-            agent: `agent-${this.role}`,
-            ...(contentSummary ? { contentSummary } : {}),
-            ...(worktreePath ? { worktreePath } : {})
+            questId: questId || '',
+            branch: this.worktreePath,
+            commitHash: commitSha,
+            ...(retryAttempt && { revisionCount: retryAttempt }),
         };
         try {
-            logger.info(MODULE_AGENT, `📢 Publishing completion event`, timer.elapsed('factory'));
+            logger.info(MODULE_AGENT, `📢 Publishing review request event`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Topic: ${topic}`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Task ID: ${taskId}`, timer.elapsed('factory'));
             if (questId) {
                 logger.info(MODULE_AGENT, `   Quest ID: ${questId}`, timer.elapsed('factory'));
             }
             logger.info(MODULE_AGENT, `   Commit SHA: ${commitSha.substring(0, 7)}`, timer.elapsed('factory'));
-            await this.client.publish(topic, payload, { broker: 'default', network: 'global' });
-            logger.info(MODULE_AGENT, `   ✅ Completion event published`, timer.elapsed('factory'));
+            await this.client.publish(topic, payload, { broker: 'default', network: 'qa' });
+            logger.info(MODULE_AGENT, `   ✅ Review request published to qa network`, timer.elapsed('factory'));
+            // Store task memory (fire-and-forget) for learning from past outcomes
+            if (this.memoryService) {
+                this.memoryService.storeTaskMemory({
+                    taskId,
+                    questId: questId || '',
+                    agentId: this.client.readAgentJson().name || `agent-worker-${this.role}`,
+                    agentRole: this.role,
+                    taskType: this.role,
+                    description: _contentSummary || `Task ${taskId} completed`,
+                    outcome: 'success',
+                    context: `worktree: ${this.worktreePath}`,
+                    result: `commit: ${commitSha}`,
+                    entities: [],
+                    duration: 0,
+                    timestamp: Date.now(),
+                }).catch((err) => {
+                    logger.warn(MODULE_AGENT, `Failed to store task memory (non-fatal): ${err.message || String(err)}`, timer.elapsed('factory'));
+                });
+            }
         }
         catch (error) {
             // Handle publishing failures gracefully - don't throw
-            logger.error(MODULE_AGENT, `Failed to publish completion event (non-fatal)`, timer.elapsed('factory'), error);
+            logger.error(MODULE_AGENT, `Failed to publish review request event (non-fatal)`, timer.elapsed('factory'), error);
             logger.error(MODULE_AGENT, `   Error: ${error.message || String(error)}`, timer.elapsed('factory'));
             logger.error(MODULE_AGENT, `   Task execution succeeded despite event publishing failure`, timer.elapsed('factory'));
             // Don't throw - event publishing failure should not fail the task
@@ -1078,7 +1213,7 @@ Important:
      * }
      * ```
      */
-    async publishFailure(taskId, error, questId) {
+    async publishFailure(taskId, error, questId, retryAttempt) {
         // Generic topic — agent identity is in the payload (agent, role fields)
         const topic = `task.failed`;
         // Create payload matching TaskFailedEvent schema
@@ -1088,14 +1223,15 @@ Important:
             role: this.role,
             error: error.message || String(error),
             timestamp: new Date().toISOString(),
-            agent: `agent-${this.role}`
+            agent: `agent-${this.role}`,
+            retryAttempt: retryAttempt ?? 0
         };
         try {
             logger.info(MODULE_AGENT, `📢 Publishing failure event`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Topic: ${topic}`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Task ID: ${taskId}`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Error: ${error.message.substring(0, 100)}${error.message.length > 100 ? '...' : ''}`, timer.elapsed('factory'));
-            await this.client.publish(topic, payload, { broker: 'default', network: 'global' });
+            await this.client.publish(topic, payload, { broker: 'default', network: this.role });
             logger.info(MODULE_AGENT, `   ✅ Failure event published`, timer.elapsed('factory'));
         }
         catch (publishError) {
@@ -1188,7 +1324,7 @@ Important:
             logger.info(MODULE_AGENT, `   Topic: ${topic}`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Task ID: ${taskId}`, timer.elapsed('factory'));
             logger.info(MODULE_AGENT, `   Reason: ${reason.substring(0, 100)}${reason.length > 100 ? '...' : ''}`, timer.elapsed('factory'));
-            await this.client.publish(topic, payload, { broker: 'default', network: 'global' });
+            await this.client.publish(topic, payload, { broker: 'default', network: this.role });
             logger.info(MODULE_AGENT, `   ✅ Rejection event published`, timer.elapsed('factory'));
         }
         catch (error) {
@@ -1222,20 +1358,24 @@ Important:
      * ```
      */
     async start() {
-        logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `Starting Worker Agent: ${this.role}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `Broker URL: ${this.config.brokerUrl}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `Networks: ${this.networks.join(', ')}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `Worktree Path: ${this.worktreePath}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `LLM Model: ${this.claudeModel}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
-        // Initialize KĀDI client and connect to broker
-        await this.initializeClient();
+        logger.debug(MODULE_AGENT, `Starting Worker Agent: ${this.role}`, timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `Broker URL: ${this.workerConfig.brokerUrl}`, timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `Networks: ${this.networks.join(', ')}`, timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `Worktree Path: ${this.worktreePath}`, timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `LLM Model: ${this.claudeModel}`, timer.elapsed('factory'));
+        // If already connected (via BaseAgent.connect()), skip client initialization
+        if (!this.connected) {
+            await this.initializeClient();
+        }
+        else {
+            // Still need ability response subscription even if already connected
+            if (this.baseBot) {
+                await this.baseBot['initializeAbilityResponseSubscription']();
+                logger.debug(MODULE_AGENT, 'Ability response subscription initialized', timer.elapsed('factory'));
+            }
+        }
         // Subscribe to task assignment events
         await this.subscribeToTaskAssignments();
-        // TODO: Implement remaining start logic in next tasks
-        // 1. Register tools (if any)
     }
     /**
      * Stop the worker agent
@@ -1255,26 +1395,17 @@ Important:
      * ```
      */
     async stop() {
-        logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, `Stopping Worker Agent: ${this.role}`, timer.elapsed('factory'));
-        logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
+        logger.debug(MODULE_AGENT, `Stopping Worker Agent: ${this.role}`, timer.elapsed('factory'));
         try {
-            // TODO: Unsubscribe from events in next task
-            // Disconnect KĀDI client
-            logger.info(MODULE_AGENT, '   → Disconnecting KĀDI client...', timer.elapsed('factory'));
-            await this.client.disconnect();
-            logger.info(MODULE_AGENT, '   ✅ KĀDI client disconnected', timer.elapsed('factory'));
-            // Clear references
-            this.providerManager = null;
-            logger.info(MODULE_AGENT, '', timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, '✅ Worker agent stopped successfully', timer.elapsed('factory'));
-            logger.info(MODULE_AGENT, '='.repeat(60), timer.elapsed('factory'));
+            // Delegate to BaseAgent.shutdown() which handles:
+            // - ProviderManager disposal
+            // - MemoryService disposal
+            // - Client disconnect
+            await this.shutdown();
+            logger.debug(MODULE_AGENT, 'Worker agent stopped', timer.elapsed('factory'));
         }
         catch (error) {
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
             logger.error(MODULE_AGENT, 'Error during shutdown', timer.elapsed('factory'), error);
-            logger.error(MODULE_AGENT, `   Error: ${error.message || String(error)}`, timer.elapsed('factory'));
-            logger.error(MODULE_AGENT, '', timer.elapsed('factory'));
             // Don't throw - best effort cleanup
         }
     }
@@ -1332,6 +1463,17 @@ Important:
     setProviderManager(pm) {
         this.providerManager = pm;
     }
+    /**
+     * Set the MemoryService for task memory storage and recall
+     *
+     * Called by the agent entry point after constructing BaseAgent
+     * (which creates the MemoryService).
+     *
+     * @param ms - MemoryService instance from BaseAgent
+     */
+    setMemoryService(ms) {
+        this.memoryService = ms;
+    }
     /**
      * Configure role-specific settings from a loaded RoleConfig
      *
@@ -1471,17 +1613,18 @@ export class WorkerAgentFactory {
      */
     static createAgent(config) {
         try {
-            // Validate configuration with Zod schema
-            const validatedConfig = WorkerAgentConfigSchema.parse(config);
-            // Create and return BaseWorkerAgent instance
-            // Agent is not started automatically - caller must call start()
-            return new BaseWorkerAgent(validatedConfig);
+            // Only validate with Zod schema for legacy WorkerAgentConfig
+            if ('anthropicApiKey' in config) {
+                const validatedConfig = WorkerAgentConfigSchema.parse(config);
+                return new BaseWorkerAgent(validatedConfig);
+            }
+            // WorkerAgentFullConfig — skip Zod validation (BaseAgent handles its own)
+            return new BaseWorkerAgent(config);
         }
         catch (error) {
             // Re-throw Zod validation errors with context
             if (error.name === 'ZodError') {
                 logger.error(MODULE_AGENT, 'Worker agent configuration validation failed', timer.elapsed('factory'), error);
-                logger.error(MODULE_AGENT, '   Validation errors:', timer.elapsed('factory'));
                 for (const issue of error.issues || []) {
                     logger.error(MODULE_AGENT, `   - ${issue.path.join('.')}: ${issue.message}`, timer.elapsed('factory'));
                 }