@kognai/orchestrator-core 0.2.6 → 0.2.8

package/dist/lib/engine-coding-agent.js

@@ -68,6 +68,16 @@ class CodingAgent {
             delete task._escalateNext;
             (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.magenta, `  ⤴ [ESCALATE] ${task.id}: prior ${escalation} → upgrading to ${model}`);
         }
+        // TICKET-349 (trigger fix): when the previous attempt was rejected for
+        // truncation by the supervisor (authoritative), force the multi-pass
+        // continuation loop on this attempt's generated file(s) — even if the coder's
+        // detectTruncation() heuristic thinks the file looks complete. The supervisor
+        // already determined it isn't. Consumed once here.
+        const forceContinuation = task._forceContinuation === true;
+        if (forceContinuation) {
+            delete task._forceContinuation;
+            (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.magenta, `  ⤴ [ASSEMBLE] ${task.id}: prior TRUNCATION reject → forcing multi-pass continuation on this attempt`);
+        }
         (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.gray, `  -> Using ${model} [${routingReason}]`);
         // B.12: Compress context before cloud calls to reduce token spend 70-80%
         if (provider === 'clawrouter' || provider === 'anthropic') {
@@ -320,36 +330,58 @@ Write ONLY the content for "${filepath}". Rules:
                         fileContent = await this.fixJsonWithOllama(fileContent, filepath);
                     }
                 }
-                // TRUNCATION PRE-CHECK: Detect if MiniMax cut off output mid-function
-                // If code ends inside an open block (unclosed braces) or with an incomplete statement,
-                // retry once with a "continue" prompt before sending to supervisor review.
-                const truncationDetected = this.detectTruncation(fileContent);
-                if (truncationDetected && (provider === 'clawrouter' || provider === 'ollama')) {
-                    (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.yellow, `  ! TRUNCATION detected in ${filepath} — retrying with continuation prompt...`);
-                    const continuationPrompt = `The previous response for "${filepath}" was TRUNCATED — it ended mid-function or with an incomplete block. Here is what was generated so far:
+                // TICKET-349: multi-pass chunked generation. The OpenClaw gateway clamps
+                // output to ~4096 tokens regardless of the requested max_tokens, so a file
+                // larger than one chunk gets cut mid-statement → [TRUNCATION] reject, no
+                // matter how capable the model is (deepseek AND sonnet truncate at the
+                // same length). Decompose the GENERATION: keep issuing continuation passes
+                // and appending until the file is complete (no truncation) or we hit the
+                // chunk cap. Works for ALL providers (previously clawrouter/ollama-only).
+                // Bounded by KOGNAI_MAX_CONTINUATION_CHUNKS (default 5 → ~5×4k≈20k output)
+                // and a no-progress guard so it can never loop forever.
+                const MAX_CONTINUATION_CHUNKS = parseInt(process.env.KOGNAI_MAX_CONTINUATION_CHUNKS ?? '5', 10);
+                let chunk = 0;
+                // TICKET-349 (trigger fix): fire on detectTruncation OR a forced first
+                // pass (set when the supervisor truncation-rejected the prior attempt).
+                // The forced pass only applies to chunk 0; after that the loop continues
+                // purely on detectTruncation, and the no-progress guard stops it if the
+                // file is actually complete (a continuation that adds nothing → break).
+                while ((this.detectTruncation(fileContent) || (forceContinuation && chunk === 0)) && chunk < MAX_CONTINUATION_CHUNKS) {
+                    chunk++;
+                    (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.yellow, `  ! TRUNCATION in ${filepath} — continuation pass ${chunk}/${MAX_CONTINUATION_CHUNKS} (gateway ~4k output cap)...`);
+                    const continuationPrompt = `The previous response for "${filepath}" was TRUNCATED — it ended mid-function or with an incomplete block. Here is the tail of what exists so far:
 
 \`\`\`typescript
 ${fileContent.substring(fileContent.length - 1500)}
 \`\`\`
 
-Continue from where it left off and output ONLY the remaining code (no duplicated content). Output a COMPLETE, valid TypeScript/JavaScript file ending with the final closing brace.`;
+Continue EXACTLY from where it left off and output ONLY the remaining code (no duplicated content, no preamble, no markdown fences). End the file with its final closing brace.`;
+                    let grew = false;
                     try {
-                        const contResponse = await (0, orchestrate_engine_1.callLLM)(provider, model, this.systemPrompt, continuationPrompt, 120000, this.name, `${task.id}_continuation`);
+                        const contResponse = await (0, orchestrate_engine_1.callLLM)(provider, model, this.systemPrompt, continuationPrompt, 120000, this.name, `${task.id}_continuation_${chunk}`);
                         let contContent = contResponse.choices?.[0]?.message?.content || '';
                         contContent = contContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
                         const contBlocks = this.extractCodeBlocks(contContent);
                         const continuation = contBlocks.length > 0 ? contBlocks[0] : this.stripResidualFences(contContent);
                         if (continuation.length > 50) {
-                            // Merge: use the original up to the last complete line, then append continuation
-                            fileContent = fileContent + '\n' + continuation;
-                            fileContent = this.stripResidualFences(fileContent);
-                            (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.green, `  ✓ Continuation merged for ${filepath} (+${continuation.length} chars)`);
+                            fileContent = this.stripResidualFences(fileContent + '\n' + continuation);
+                            grew = true;
+                            (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.green, `  ✓ Pass ${chunk} merged for ${filepath} (+${continuation.length} chars, total ${fileContent.length})`);
                         }
                     }
                     catch (contErr) {
-                        (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.yellow, `  ! Continuation failed: ${contErr.message}`);
+                        (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.yellow, `  ! Continuation pass ${chunk} failed: ${contErr.message}`);
+                    }
+                    // No-progress guard: if a pass added nothing usable, stop — further
+                    // passes won't help and would just burn budget.
+                    if (!grew) {
+                        (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.yellow, `  ! Continuation made no progress — stopping at pass ${chunk}`);
+                        break;
                     }
                 }
+                if (chunk > 0 && !this.detectTruncation(fileContent)) {
+                    (0, orchestrate_engine_1.log)(orchestrate_engine_1.c.green, `  ✓ ${filepath} assembled complete over ${chunk + 1} pass(es)`);
+                }
                 createdFiles.push({ path: filepath, content: fileContent });
             }
             catch (error) {

package/dist/lib/engine-orchestrator.js

@@ -915,6 +915,15 @@ ONLY output the JSON array. No markdown, no explanation.`;
                     // escalation at typical token volumes — well under the daily wallet.
                     // Cleared in CodingAgent.execute after consumption.
                     task._escalateNext = 'TRUNCATION';
+                    // TICKET-349 (trigger fix): the supervisor's truncation verdict is the
+                    // AUTHORITATIVE "this file is incomplete" signal — stronger than the
+                    // coder's detectTruncation() brace-heuristic, which lets balanced-but-
+                    // incomplete files through (verified 2026-06-13: 0 continuation passes
+                    // fired despite repeated truncation rejects). Force the coder's
+                    // multi-pass continuation loop on the next attempt so it ASSEMBLES the
+                    // file across passes instead of one-shot-regenerating (which re-truncates
+                    // even on Sonnet). Consumed + cleared in CodingAgent.execute.
+                    task._forceContinuation = true;
                 }
                 else if (task._integrityFailed) {
                     (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, `\n↻ Task ${task.id} REJECTED on attempt ${attempt} (${review.score}/100) [INTEGRITY-FAILED]`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognai/orchestrator-core",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Kognai sovereign orchestrator — core engine (template-agnostic). Shared by all products (Kognai/coding, Voxight/market-intel, Invoica/fin-compliance); each supplies only its template. Replaces per-repo forks of orchestrate-agents-v2 / sprint-runner / lib.",
   "license": "MIT",
   "author": "SkinGem",