jiva-core 0.3.2 → 0.3.3-dev.bd250bd

package/dist/core/types/agent-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-context.js","sourceRoot":"","sources":["../../../src/core/types/agent-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/core/types/completion-signal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CompletionSignal - Per-subtask assessment emitted by Client alongside ValidationResult
+ *
+ * Replaces the blunt failureCount escalation with a richer signal that DualAgent
+ * uses to decide corrective strategy per subtask.
+ */
+export interface CompletionSignal {
+    /** How confident the Client is that the subtask was completed correctly */
+    confidence: 'high' | 'medium' | 'low' | 'none';
+    /** Did Worker make any measurable forward progress? */
+    progressMade: boolean;
+    /** Classification of the blocker (if confidence is not 'high') */
+    blockerType?: 'tool_failure' | 'hallucination' | 'scope_drift' | 'partial' | 'loop' | 'capability_gap';
+    /** Suggested corrective strategy for DualAgent */
+    suggestedStrategy?: 'retry' | 'rephrase' | 'decompose' | 'skip' | 'escalate';
+}
+//# sourceMappingURL=completion-signal.d.ts.map

package/dist/core/types/completion-signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-signal.d.ts","sourceRoot":"","sources":["../../../src/core/types/completion-signal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,2EAA2E;IAC3E,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IAE/C,uDAAuD;IACvD,YAAY,EAAE,OAAO,CAAC;IAEtB,kEAAkE;IAClE,WAAW,CAAC,EAAE,cAAc,GACd,eAAe,GACf,aAAa,GACb,SAAS,GACT,MAAM,GACN,gBAAgB,CAAC;IAE/B,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,OAAO,GACP,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,CAAC;CAChC"}

package/dist/core/types/completion-signal.js

@@ -0,0 +1,8 @@
+/**
+ * CompletionSignal - Per-subtask assessment emitted by Client alongside ValidationResult
+ *
+ * Replaces the blunt failureCount escalation with a richer signal that DualAgent
+ * uses to decide corrective strategy per subtask.
+ */
+export {};
+//# sourceMappingURL=completion-signal.js.map

package/dist/core/types/completion-signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-signal.js","sourceRoot":"","sources":["../../../src/core/types/completion-signal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/core/utils/serialize-agent-context.d.ts

@@ -0,0 +1,23 @@
+/**
+ * serializeAgentContext - Produces a consistent, role-appropriate string block
+ * that each agent embeds in its prompt.
+ *
+ * Using the same serializer for all three agents ensures the format is identical;
+ * the `role` parameter governs what is included, not how it is formatted.
+ *
+ * Token budget guidelines (tunable):
+ *   Directive:            ~500 tokens max (truncate with notice if exceeded)
+ *   Conversation summary: ~300 tokens max
+ *   Recent messages:      last 6 messages of all roles, ~800 tokens
+ *   Validation context:   ~400 tokens max
+ */
+import { AgentContext } from '../types/agent-context.js';
+/**
+ * Serialize AgentContext into a role-appropriate string block.
+ *
+ * - manager: directive + conversation (summary + recent). Omits validationContext.
+ * - worker:  directive + conversation (summary + recent, incl. tool messages). Omits validationContext.
+ * - client:  directive + conversation (summary + recent, incl. tool messages) + validationContext. Omits execution persona.
+ */
+export declare function serializeAgentContext(ctx: AgentContext, role: 'manager' | 'worker' | 'client'): string;
+//# sourceMappingURL=serialize-agent-context.d.ts.map

package/dist/core/utils/serialize-agent-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-agent-context.d.ts","sourceRoot":"","sources":["../../../src/core/utils/serialize-agent-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAgCzD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,GACpC,MAAM,CAuCR"}

package/dist/core/utils/serialize-agent-context.js

@@ -0,0 +1,73 @@
+/**
+ * serializeAgentContext - Produces a consistent, role-appropriate string block
+ * that each agent embeds in its prompt.
+ *
+ * Using the same serializer for all three agents ensures the format is identical;
+ * the `role` parameter governs what is included, not how it is formatted.
+ *
+ * Token budget guidelines (tunable):
+ *   Directive:            ~500 tokens max (truncate with notice if exceeded)
+ *   Conversation summary: ~300 tokens max
+ *   Recent messages:      last 6 messages of all roles, ~800 tokens
+ *   Validation context:   ~400 tokens max
+ */
+// Rough estimate: 1 token ≈ 4 characters
+const CHARS_PER_TOKEN = 4;
+const DIRECTIVE_TOKEN_LIMIT = 500;
+const SUMMARY_TOKEN_LIMIT = 300;
+// Recent messages are no longer truncated — the underlying LLM supports a 128k
+// context window and the conversation manager condenses history before this is
+// called, so there is no need for an artificial per-role cap here.
+const VALIDATION_CONTEXT_TOKEN_LIMIT = 400;
+/**
+ * Truncate text to a token-approximate character limit, appending a notice if truncated.
+ */
+function truncate(text, tokenLimit) {
+    const charLimit = tokenLimit * CHARS_PER_TOKEN;
+    if (text.length <= charLimit)
+        return text;
+    return text.substring(0, charLimit) + '\n[...truncated due to token limit]';
+}
+/**
+ * Serialize a single message to a compact string representation.
+ */
+function serializeMessage(msg) {
+    const role = msg.role.toUpperCase();
+    const content = typeof msg.content === 'string'
+        ? msg.content
+        : msg.content.map(c => c.text || '[image]').join(' ');
+    return `[${role}]: ${content}`;
+}
+/**
+ * Serialize AgentContext into a role-appropriate string block.
+ *
+ * - manager: directive + conversation (summary + recent). Omits validationContext.
+ * - worker:  directive + conversation (summary + recent, incl. tool messages). Omits validationContext.
+ * - client:  directive + conversation (summary + recent, incl. tool messages) + validationContext. Omits execution persona.
+ */
+export function serializeAgentContext(ctx, role) {
+    const sections = [];
+    // ── Directive ──────────────────────────────────────────────────────────
+    if (ctx.directive) {
+        sections.push('=== DIRECTIVE ===\n' + truncate(ctx.directive, DIRECTIVE_TOKEN_LIMIT));
+    }
+    // ── Conversation context ──────────────────────────────────────────────
+    const convParts = [];
+    if (ctx.conversation.summary) {
+        convParts.push('[Conversation Summary]\n' + truncate(ctx.conversation.summary, SUMMARY_TOKEN_LIMIT));
+    }
+    if (ctx.conversation.recentMessages.length > 0) {
+        const serialized = ctx.conversation.recentMessages.map(serializeMessage).join('\n');
+        convParts.push('[Recent Messages]\n' + serialized);
+    }
+    if (convParts.length > 0) {
+        sections.push('=== CONVERSATION CONTEXT ===\n' + convParts.join('\n\n'));
+    }
+    // ── Validation context (client only) ──────────────────────────────────
+    if (role === 'client' && ctx.persona?.validationContext) {
+        sections.push('=== VALIDATION CONTEXT ===\n' +
+            truncate(ctx.persona.validationContext, VALIDATION_CONTEXT_TOKEN_LIMIT));
+    }
+    return sections.join('\n\n');
+}
+//# sourceMappingURL=serialize-agent-context.js.map

package/dist/core/utils/serialize-agent-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-agent-context.js","sourceRoot":"","sources":["../../../src/core/utils/serialize-agent-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,yCAAyC;AACzC,MAAM,eAAe,GAAG,CAAC,CAAC;AAC1B,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAChC,+EAA+E;AAC/E,+EAA+E;AAC/E,mEAAmE;AACnE,MAAM,8BAA8B,GAAG,GAAG,CAAC;AAE3C;;GAEG;AACH,SAAS,QAAQ,CAAC,IAAY,EAAE,UAAkB;IAChD,MAAM,SAAS,GAAG,UAAU,GAAG,eAAe,CAAC;IAC/C,IAAI,IAAI,CAAC,MAAM,IAAI,SAAS;QAAE,OAAO,IAAI,CAAC;IAC1C,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,qCAAqC,CAAC;AAC9E,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CAAC,GAAY;IACpC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IACpC,MAAM,OAAO,GAAG,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ;QAC7C,CAAC,CAAC,GAAG,CAAC,OAAO;QACb,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACxD,OAAO,IAAI,IAAI,MAAM,OAAO,EAAE,CAAC;AACjC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAiB,EACjB,IAAqC;IAErC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,0EAA0E;IAC1E,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC;QAClB,QAAQ,CAAC,IAAI,CACX,qBAAqB,GAAG,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,qBAAqB,CAAC,CACvE,CAAC;IACJ,CAAC;IAED,yEAAyE;IACzE,MAAM,SAAS,GAAa,EAAE,CAAC;IAE/B,IAAI,GAAG,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC7B,SAAS,CAAC,IAAI,CACZ,0BAA0B,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,OAAO,EAAE,mBAAmB,CAAC,CACrF,CAAC;IACJ,CAAC;IAED,IAAI,GAAG,CAAC,YAAY,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/C,MAAM,UAAU,GAAG,GAAG,CAAC,YAAY,CAAC,cAAc,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpF,SAAS,CAAC,IAAI,CACZ,qBAAqB,GAAG,UAAU,CACnC,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,gCAAgC,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED,yEAAyE;IACzE,IAAI,IAAI,KAAK,QAAQ,IAAI,GAAG,CAAC,OAAO,EAAE,iBAAiB,EAAE,CAAC;QACxD,QAAQ,CAAC,IAAI,CACX,8BAA8B;YAC9B,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,iBAAiB,EAAE,8BAA8B,CAAC,CACxE,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC"}

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

@@ -12,14 +12,22 @@ import { MCPServerManager } from '../mcp/server-manager.js';
 import { WorkspaceManager } from './workspace.js';
 import { PersonaManager } from '../personas/persona-manager.js';
 import { AgentSpawner } from './agent-spawner.js';
+import { AgentContext } from './types/agent-context.js';
 export interface WorkerSubtask {
     instruction: string;
     context?: string;
 }
+export interface ToolFailure {
+    toolName: string;
+    args: Record<string, any>;
+    lastError: string;
+    attempts: number;
+}
 export interface WorkerResult {
     success: boolean;
     result: string;
     toolsUsed: string[];
+    failedTools: ToolFailure[];
     reasoning: string;
 }
 export declare class WorkerAgent {
@@ -38,7 +46,7 @@ export declare class WorkerAgent {
     /**
      * Execute a subtask assigned by Manager
      */
-    executeSubtask(subtask: WorkerSubtask): Promise<WorkerResult>;
+    executeSubtask(subtask: WorkerSubtask, agentContext?: AgentContext): Promise<WorkerResult>;
     private extractReasoning;
     /**
      * Determine if we should prompt Worker to check for completion

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

@@ -1 +1 @@
-{"version":3,"file":"worker-agent.d.ts","sourceRoot":"","sources":["../../src/core/worker-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAsBlD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,aAAa,CAAsB;gBAGzC,YAAY,EAAE,iBAAiB,EAC/B,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,gBAAgB,EAC3B,aAAa,GAAE,MAAU,EACzB,cAAc,CAAC,EAAE,cAAc;IAqBjC;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAwYnE,OAAO,CAAC,gBAAgB;IAMxB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CAuDlC"}
+{"version":3,"file":"worker-agent.d.ts","sourceRoot":"","sources":["../../src/core/worker-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAsBxD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,aAAa,CAAsB;gBAGzC,YAAY,EAAE,iBAAiB,EAC/B,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,gBAAgB,EAC3B,aAAa,GAAE,MAAU,EACzB,cAAc,CAAC,EAAE,cAAc;IAqBjC;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAI5C;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAkmBhG,OAAO,CAAC,gBAAgB;IAMxB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CA4ClC"}

package/dist/core/worker-agent.js

@@ -45,7 +45,7 @@ export class WorkerAgent {
     /**
      * Execute a subtask assigned by Manager
      */
-    async executeSubtask(subtask) {
+    async executeSubtask(subtask, agentContext) {
         logger.info(`[Worker] Starting: "${subtask.instruction}"`);
         orchestrationLogger.logWorkerStart(subtask.instruction, subtask.context || '');
         // Reset context memory for new subtask
@@ -55,7 +55,41 @@ export class WorkerAgent {
         };
         const conversationHistory = [];
         const toolsUsed = [];
+        // Tracks every exact tool-call signature (toolName + serialized args) executed
+        // during this subtask. Used to prevent the same call from being repeated in a
+        // later iteration — e.g. reading the same file twice in consecutive turns.
+        const executedToolSignatures = new Set();
+        // Tracks consecutive failures per (toolName:args) signature.
+        // Drives the per-tool circuit breaker: warn at 2, hard-stop at 3.
+        const toolFailureCounts = new Map();
         let iterationCount = 0;
+        // ── 2+2 API-level JSON parse failure strategy ─────────────────────────────
+        // Priority: if a dedicated tool-calling LLM is configured, use it from the
+        // very first iteration (it reliably serialises tool args as standard JSON).
+        // The reasoning model then serves as the phase-2 fallback.
+        // If no tool-calling model is configured the roles are reversed: reasoning
+        // model is phase 1 and there is no phase-2 fallback.
+        //
+        // Flow when tool-calling model IS configured:
+        //   Phase 1 – tool-calling model  (up to API_PARSE_FAIL_THRESHOLD=2 failures)
+        //   Phase 2 – reasoning model     (up to SECONDARY_MODEL_ATTEMPTS=2 failures)
+        //   → hard-stop after 4 total failures; failedTools is non-empty so the
+        //     Client's data-driven CompletionSignal fires (prevents infinite retries)
+        //
+        // Flow when NO tool-calling model is configured:
+        //   Phase 1 – reasoning model     (up to API_PARSE_FAIL_THRESHOLD=2 failures)
+        //   → hard-stop immediately (no secondary model available)
+        const API_PARSE_FAIL_THRESHOLD = 2; // phase-1 failures before switching phases
+        const SECONDARY_MODEL_ATTEMPTS = 2; // extra attempts on the phase-2 model
+        let apiJsonParseFailures = 0; // total JSON-parse failures so far
+        // toolCallingIsMain: true when the tool-calling model is the primary model for this run
+        const toolCallingIsMain = this.orchestrator.hasToolCallingModel();
+        // useToolCallingFallback: flag passed to orchestrator.chatWithFallback()
+        //   true  → use the tool-calling model
+        //   false → use the reasoning model
+        let useToolCallingFallback = toolCallingIsMain; // start with tool-calling model if available
+        let phaseSwitched = false; // true once we have swapped phases
+        const API_JSON_PARSE_FAILURE_SIG = 'api_json_parse:{}'; // key in toolFailureCounts
         // Build system prompt for Worker
         const personaPrompt = this.personaManager?.getSystemPromptAddition() || '';
         let systemContent = `You are the Worker Agent in a two-agent system.
@@ -114,12 +148,18 @@ Available tools: ${this.mcpManager.getClient().getAllTools().map(t => t.name).jo
   * persona (required): Persona name - ${availablePersonas.join(', ')}
   * task (required): Specific task for the sub-agent
   * context (optional): Additional domain-specific context (workspace path is automatically included)
+- IMPORTANT: When spawning a sub-agent, include relevant directive constraints and a brief conversation summary in the context parameter so the sub-agent has sufficient background.
 - Example: spawn_agent({ persona: "code-reviewer", task: "Review the authentication code in src/auth/", context: "Focus on security vulnerabilities and best practices" })
 - The sub-agent will complete the task and return results to you`;
         }
         if (personaPrompt) {
             systemContent += `\n\n${personaPrompt}`;
         }
+        // Inject directive into Worker prompt (fixes bug: Worker previously had no directive)
+        const directivePrompt = agentContext?.directive || this.workspace.getDirectivePrompt() || '';
+        if (directivePrompt) {
+            systemContent += `\n\n${directivePrompt}`;
+        }
         // System prompt for Worker
         // Use 'developer' role for Harmony format compatibility (will be converted to 'system' by model)
         conversationHistory.push({
@@ -184,23 +224,114 @@ Please complete this subtask and report your findings.`,
             }
             let response;
             try {
-                response = await this.orchestrator.chat({
+                response = await this.orchestrator.chatWithFallback({
                     messages: conversationHistory,
                     tools: tools.length > 0 ? tools : undefined,
                     temperature: 0.1, // Low temperature for deterministic tool execution
-                });
+                }, useToolCallingFallback);
             }
             catch (error) {
                 // API error (e.g., invalid tool call parameters)
                 const errorMsg = error instanceof Error ? error.message : String(error);
                 logger.warn(`  [Worker] API error - ${errorMsg.substring(0, 100)}...`);
-                // Check if we've used up our retries
+                // Detect the specific "Failed to parse tool call arguments as JSON" pattern.
+                // These 400 errors originate from the model generating malformed JSON for
+                // tool call arguments (e.g. large content with special Unicode characters).
+                // A generic "retry with error feedback" loop cannot fix this — the same model
+                // will keep producing the same malformed output. We need a different approach.
+                const isJsonParseError = errorMsg.includes('Failed to parse tool call arguments as JSON') ||
+                    errorMsg.includes('tool_use_failed');
+                if (isJsonParseError) {
+                    apiJsonParseFailures++;
+                    // Record in toolFailureCounts so failedTools is always non-empty on exit.
+                    // This ensures the Client's data-driven CompletionSignal fires (strategy=escalate)
+                    // rather than the LLM-based path that would return strategy=retry, causing an
+                    // infinite correction-subtask loop.
+                    toolFailureCounts.set(API_JSON_PARSE_FAILURE_SIG, {
+                        count: apiJsonParseFailures,
+                        lastError: errorMsg,
+                    });
+                    const totalBudget = API_PARSE_FAIL_THRESHOLD + SECONDARY_MODEL_ATTEMPTS;
+                    if (!phaseSwitched && apiJsonParseFailures >= API_PARSE_FAIL_THRESHOLD) {
+                        // Phase 1 exhausted — attempt a phase switch
+                        phaseSwitched = true;
+                        if (toolCallingIsMain) {
+                            // Tool-calling model (primary) failed → fall back to reasoning model
+                            useToolCallingFallback = false;
+                            logger.warn(`  [Worker] Tool-calling model failed JSON tool-call serialisation ` +
+                                `${apiJsonParseFailures} time(s) — switching to reasoning model for ` +
+                                `up to ${SECONDARY_MODEL_ATTEMPTS} more attempt(s)`);
+                            conversationHistory.push({
+                                role: 'user',
+                                content: `NOTE: The previous model had trouble formatting its tool call as valid JSON. ` +
+                                    `A different model is now being used. Please re-attempt the task — ` +
+                                    `use the same tools but ensure all argument values are valid JSON ` +
+                                    `(avoid raw special characters inside string values; escape them if needed).`,
+                            });
+                            continue; // retry with reasoning model
+                        }
+                        else if (this.orchestrator.hasToolCallingModel()) {
+                            // Reasoning model (primary) failed → switch to tool-calling model
+                            useToolCallingFallback = true;
+                            logger.warn(`  [Worker] Reasoning model failed JSON tool-call serialisation ` +
+                                `${apiJsonParseFailures} time(s) — switching to tool-calling LLM for ` +
+                                `up to ${SECONDARY_MODEL_ATTEMPTS} more attempt(s)`);
+                            conversationHistory.push({
+                                role: 'user',
+                                content: `NOTE: The previous model had trouble formatting its tool call as valid JSON. ` +
+                                    `A different model is now being used. Please re-attempt the task — ` +
+                                    `use the same tools but ensure all argument values are valid JSON ` +
+                                    `(avoid raw special characters inside string values; escape them if needed).`,
+                            });
+                            continue; // retry with fallback model active
+                        }
+                        else {
+                            // No secondary model configured — hard-stop immediately
+                            logger.error(`  [Worker] JSON serialisation failure — no secondary model configured. ` +
+                                `Hard-stopping after ${apiJsonParseFailures} attempt(s).`);
+                            finalResult =
+                                `Task failed: The reasoning model could not generate valid tool-call JSON ` +
+                                    `after ${apiJsonParseFailures} attempt(s). ` +
+                                    `Error: ${errorMsg}. ` +
+                                    `Tip: configure a tool-calling LLM in Jiva settings to enable automatic fallback.`;
+                            break;
+                        }
+                    }
+                    else if (apiJsonParseFailures >= totalBudget) {
+                        // Phase 2 also exhausted — hard-stop
+                        const primaryLabel = toolCallingIsMain ? 'tool-calling' : 'reasoning';
+                        const secondaryLabel = toolCallingIsMain ? 'reasoning' : 'tool-calling';
+                        logger.error(`  [Worker] Both ${primaryLabel} and ${secondaryLabel} models failed JSON serialisation. ` +
+                            `Hard-stopping after ${apiJsonParseFailures} total attempt(s).`);
+                        finalResult =
+                            `Task failed: Both the ${primaryLabel} model and the ${secondaryLabel} fallback model ` +
+                                `could not generate valid tool-call JSON after ${apiJsonParseFailures} total attempt(s). ` +
+                                `Error: ${errorMsg}.`;
+                        break;
+                    }
+                    // Still within budget — add informative error and let the (possibly switched) model retry
+                    logger.info(`  [Worker] JSON parse failure ${apiJsonParseFailures}/${totalBudget} — ` +
+                        `retrying with ${useToolCallingFallback ? 'tool-calling model' : 'reasoning model'} ` +
+                        `(attempt ${iteration + 2}/${this.maxIterations})`);
+                    conversationHistory.push({
+                        role: 'user',
+                        content: `ERROR: The model produced a tool call with invalid JSON arguments.\n` +
+                            `Specific error: ${errorMsg}\n\n` +
+                            `This usually happens with large file content containing special characters. ` +
+                            `To fix this:\n` +
+                            `1. Escape all special characters in string values (\\n, \\t, \\\\, etc.)\n` +
+                            `2. Wrap Unicode symbols as plain ASCII equivalents (e.g. use [ ] instead of ☐)\n` +
+                            `3. If the content is very long, write it to the file in smaller chunks\n` +
+                            `Please retry the tool call with corrected arguments.`,
+                    });
+                    continue;
+                }
+                // Non-JSON-parse API error — regular retry with error feedback
                 if (iteration >= this.maxIterations - 1) {
                     logger.error(`  [Worker] Max retries reached after API errors`);
                     finalResult = `Failed to complete subtask due to repeated errors: ${errorMsg}`;
                     break;
                 }
-                // Add error feedback to conversation so Worker can correct itself
                 logger.info(`  [Worker] Retrying with error feedback (attempt ${iteration + 2}/${this.maxIterations})`);
                 conversationHistory.push({
                     role: 'user',
@@ -220,32 +351,42 @@ Please complete this subtask and report your findings.`,
                     const args = JSON.parse(tc.function.arguments);
                     return `${tc.function.name}:${JSON.stringify(args)}`;
                 });
-                // Check if we're about to repeat the same tool call
+                // Check if we're about to repeat the same tool call (name-only check)
                 const lastToolCalls = toolsUsed.slice(-2);
                 const isRepetitive = proposedTools.some(proposed => {
                     const toolName = proposed.split(':')[0];
                     return lastToolCalls.filter(t => t === toolName).length >= 2;
                 });
-                if (isRepetitive && iteration >= 2) {
+                // Exact-signature check: catches same tool + same args within a subtask.
+                // This catches the case where the model reads the same file twice in
+                // consecutive iterations before the name-only check triggers.
+                const exactDuplicate = proposedTools.some(sig => executedToolSignatures.has(sig));
+                if ((isRepetitive && iteration >= 2) || exactDuplicate) {
                     logger.warn(`  [Worker] Detected repetitive tool usage - interrupting loop`);
                     conversationHistory.push({
                         role: 'user',
-                        content: `STOP: You are repeating the same action multiple times. This tool has already succeeded. 
+                        content: `STOP: You are calling the same tool with the same arguments repeatedly. Do NOT repeat it again.
 
-For browser tasks:
-1. You already created a new tab - do NOT create another one
-2. Now use playwright__browser_navigate to go to the actual URL
-3. If navigation is already done, the task is COMPLETE - just provide your summary
+You have two choices:
+1. If there is a DIFFERENT next step required to complete the subtask, take it now using the appropriate tool.
+2. If all required work is genuinely complete, respond with a thorough description of everything accomplished — do NOT call any more tools.
 
-Do NOT call the same tool again. Either move to the NEXT required step, or if the task is complete, provide your final summary WITHOUT any tool calls.`,
+Do not assume the task is complete just because one step succeeded. Review what the subtask requires and check whether you have actually finished all of it.`,
                     });
                     continue; // Skip executing the repetitive tools, let model reconsider
                 }
                 for (const toolCall of response.toolCalls) {
                     const toolName = toolCall.function.name;
                     logger.info(`  [Worker] Tool: ${toolName}`);
+                    // Parse args outside the try block so the catch block can reference
+                    // them for the failure signature (circuit breaker key).
+                    let args = {};
+                    try {
+                        args = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch { /* use empty */ }
+                    const failureSig = `${toolName}:${JSON.stringify(args)}`;
                     try {
-                        const args = JSON.parse(toolCall.function.arguments);
                         orchestrationLogger.logWorkerToolCall(toolName, args);
                         // Handle spawn_agent specially
                         if (toolName === 'spawn_agent') {
@@ -260,6 +401,7 @@ Do NOT call the same tool again. Either move to the NEXT required step, or if th
                                 maxIterations: args.maxIterations,
                             });
                             toolsUsed.push(toolName);
+                            executedToolSignatures.add(`${toolName}:${JSON.stringify(args)}`);
                             const resultText = `Sub-agent spawned with persona '${spawnResult.persona}' completed the task.
 
 RESULT:
@@ -276,6 +418,7 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
                         // Regular MCP tool execution
                         const result = await this.mcpManager.getClient().executeTool(toolName, args);
                         toolsUsed.push(toolName);
+                        executedToolSignatures.add(`${toolName}:${JSON.stringify(args)}`);
                         // Check if tool returned images (multimodal support)
                         let toolResultText;
                         let hasImages = false;
@@ -297,14 +440,38 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
                         logger.debug(`  ✓ [Worker] Tool ${toolName} completed`);
                     }
                     catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
                         logger.error(`  ✗ [Worker] Tool ${toolName} failed:`, error);
                         orchestrationLogger.logWorkerToolResult(toolName, false, false);
+                        // Always push the raw tool error so the LLM sees what happened
                         conversationHistory.push({
                             role: 'tool',
                             name: toolName,
                             tool_call_id: toolCall.id,
-                            content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                            content: `Error: ${errorMsg}`,
                         });
+                        // Per-tool circuit breaker: track failure count by exact (tool, args) signature
+                        const prev = toolFailureCounts.get(failureSig) || { count: 0, lastError: '' };
+                        const newCount = prev.count + 1;
+                        toolFailureCounts.set(failureSig, { count: newCount, lastError: errorMsg });
+                        if (newCount === 2) {
+                            // Second failure: explicit warning to the LLM to change approach
+                            conversationHistory.push({
+                                role: 'user',
+                                content: `WARNING: Tool \`${toolName}\` has now failed twice with the same arguments.\nError: ${errorMsg}\n\nDo NOT call this tool with the same arguments again. Try a different approach, different arguments, or a completely different tool to achieve the same goal.`,
+                            });
+                            logger.warn(`  [Worker] Tool ${toolName} has failed twice — warning injected`);
+                        }
+                        else if (newCount >= 3) {
+                            // Third failure: hard stop — block the tool and force honest exit
+                            // Add to executedToolSignatures so the exact-dedup guard prevents further calls
+                            executedToolSignatures.add(failureSig);
+                            conversationHistory.push({
+                                role: 'user',
+                                content: `HARD STOP: Tool \`${toolName}\` has failed ${newCount} times and will NOT succeed with these arguments.\nFinal error: ${errorMsg}\n\nYou MUST stop attempting this tool. Respond now with an honest report of what you tried and why it failed. Do not call any more tools — just describe the failure clearly so the user can be informed.`,
+                            });
+                            logger.warn(`  [Worker] Tool ${toolName} circuit breaker triggered after ${newCount} failures`);
+                        }
                     }
                 }
                 // If images are pending, attach them to next model call
@@ -331,12 +498,19 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
                 }
                 // After processing tool calls, check if we should prompt for completion
                 // This helps Worker recognize when task is done instead of over-iterating
-                const shouldPromptCompletion = this.shouldPromptForCompletion(subtask.instruction, toolsUsed, iteration);
+                const shouldPromptCompletion = this.shouldPromptForCompletion(toolsUsed, iteration);
                 if (shouldPromptCompletion) {
                     logger.debug(`  [Worker] Prompting for task completion check`);
                     conversationHistory.push({
                         role: 'user',
-                        content: `You have successfully executed the required tools. Please confirm if the subtask is now complete and provide a summary of what was accomplished. If complete, do not call any more tools - just respond with your summary.`,
+                        content: `Your most recent tools have run. Review the subtask instruction and the tool results above.
+
+Is the subtask fully complete?
+
+- If YES (all required work is done): respond with a thorough, detailed account of exactly what was accomplished — include file paths, content written, commands run, outputs observed, and any other relevant facts. Do NOT call any more tools.
+- If NO (more work remains): continue immediately with the next required tool call. Do not stop early.
+
+IMPORTANT: Do not claim completion unless the core deliverable (e.g. the file written, the data fetched, the action performed) is confirmed done. A directory being created is NOT the same as the file inside it being written.`,
                     });
                 }
                 // Continue to process tool results
@@ -360,28 +534,56 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
                 return false;
             });
             if (hasSuccessfulTools && !hasToolFailures) {
-                // Tools executed successfully, just model didn't stop naturally
-                finalResult = `Task work completed (${toolsUsed.length} operations performed). Max iterations reached but all tool operations succeeded.`;
-                logger.info(`[Worker] Max iterations reached, but ${toolsUsed.length} tools executed successfully`);
+                // Tools ran but the model never produced a conclusive text response.
+                // Report the actual tools used so the Client coherence check can verify
+                // whether the right work was done — do NOT claim overall success here.
+                finalResult = `Max iterations reached. Tools executed (${toolsUsed.length}): ${toolsUsed.join(', ')}. The model did not produce a final confirmation. Validation required.`;
+                logger.warn(`[Worker] Max iterations reached after ${toolsUsed.length} tool(s) — no conclusive response from model`);
             }
             else if (hasToolFailures) {
-                finalResult = 'Subtask encountered errors and could not be completed within iteration limit.';
-                logger.warn(`[Worker] Max iterations reached with tool failures`);
+                // Build a specific failure summary from the circuit breaker data
+                const failureSummary = [...toolFailureCounts.entries()]
+                    .filter(([, v]) => v.count > 0)
+                    .map(([sig, v]) => {
+                    const name = sig.split(':')[0];
+                    return `${name} (${v.count} attempt${v.count > 1 ? 's' : ''}) — ${v.lastError}`;
+                })
+                    .join('; ');
+                finalResult = `Subtask could not be completed. Tool failures: ${failureSummary || 'see errors above'}.`;
+                logger.warn(`[Worker] Max iterations reached with tool failures: ${failureSummary}`);
             }
             else {
                 finalResult = 'Subtask could not be completed within iteration limit.';
                 logger.warn(`[Worker] Max iterations reached with no work done`);
             }
         }
-        // Determine success: true if we got a result and it doesn't indicate failure
+        // Build structured failedTools list from the circuit breaker map.
+        // Include all failures (count >= 1) so even a single failed attempt is
+        // visible to Client and synthesis — not just those that hit the 3-attempt cap.
+        const failedTools = [...toolFailureCounts.entries()].map(([sig, v]) => {
+            const colonIdx = sig.indexOf(':');
+            const tName = sig.substring(0, colonIdx);
+            let tArgs = {};
+            try {
+                tArgs = JSON.parse(sig.substring(colonIdx + 1));
+            }
+            catch { /* ignore */ }
+            return { toolName: tName, args: tArgs, lastError: v.lastError, attempts: v.count };
+        });
+        // Determine success: only true when the model produced a natural conclusive
+        // response (broke out of the loop normally). The max-iterations fallback
+        // paths are all treated as non-success so the Client validates properly.
         const success = !!finalResult &&
             !finalResult.includes('could not be completed') &&
-            !finalResult.includes('encountered errors');
+            !finalResult.includes('encountered errors') &&
+            !finalResult.includes('Max iterations reached') &&
+            !finalResult.includes('Validation required');
         orchestrationLogger.logWorkerComplete(success, toolsUsed, iterationCount);
         return {
             success,
             result: finalResult,
             toolsUsed,
+            failedTools,
             reasoning: reasoning || 'Task executed',
         };
     }
@@ -394,7 +596,7 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
      * Determine if we should prompt Worker to check for completion
      * This helps prevent over-iteration by asking Worker to confirm task is done
      */
-    shouldPromptForCompletion(instruction, toolsUsed, currentIteration) {
+    shouldPromptForCompletion(toolsUsed, currentIteration) {
         // Don't prompt on first iteration - let Worker do initial work
         if (currentIteration === 0) {
             return false;
@@ -415,24 +617,18 @@ Tools used: ${spawnResult.toolsUsed.join(', ')}`;
         if (currentIteration % 2 !== 0) {
             return false;
         }
-        // Check if this looks like a completion-oriented task
-        const completionIndicators = [
-            'create', 'write', 'generate', 'build', 'make',
-            'read', 'list', 'find', 'search', 'get',
-            'update', 'modify', 'edit', 'change',
-            'delete', 'remove', 'open', 'navigate', 'browse',
-        ];
-        const instructionLower = instruction.toLowerCase();
-        const hasCompletionIndicator = completionIndicators.some(indicator => instructionLower.includes(indicator));
-        // Prompt if we've seen successful file/content or browser operations
+        // Prompt only when genuinely substantive operations have completed.
+        // 'create_directory' is intentionally excluded — it is a setup step, not
+        // evidence that the main deliverable (e.g. file content) has been written.
+        // Pure tool-free responses (e.g. "explain X") never reach this point because
+        // no tools means hasSignificantOperations is false.
         const hasSignificantOperations = toolsUsed.some(tool => tool.includes('write') ||
-            tool.includes('create') ||
             tool.includes('edit') ||
             tool.includes('read') ||
             tool.includes('browser') ||
-            tool.includes('navigate'));
-        // Prompt if we have completion indicators and significant operations
-        return hasCompletionIndicator && hasSignificantOperations && toolsUsed.length >= 2;
+            tool.includes('navigate') ||
+            (tool.includes('create') && !tool.includes('directory') && !tool.includes('dir')));
+        return hasSignificantOperations && toolsUsed.length >= 2;
     }
 }
 //# sourceMappingURL=worker-agent.js.map