@kognai/orchestrator-core 0.2.7 → 0.2.9

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') {
@@ -331,7 +341,12 @@ Write ONLY the content for "${filepath}". Rules:
                 // 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;
-                while (this.detectTruncation(fileContent) && chunk < MAX_CONTINUATION_CHUNKS) {
+                // 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:

package/dist/lib/engine-orchestrator.js

@@ -795,8 +795,19 @@ ONLY output the JSON array. No markdown, no explanation.`;
                     (0, engine_primitives_1.safeResetLastCommit)(task.id, task.agent, task.type, '  ');
                     (0, code_failure_logger_1.logCodeFailure)({ taskId: task.id, sprintId: (0, orchestrate_engine_1.resolveActiveSprintId)(), agentId: (0, orchestrate_engine_1.resolveAgentDid)(task.agent), attemptNum: attempt, score: 0, model: taskRun.model_used || result?.model || task.model || 'unknown', rejectionReason: qaResult.reason, issues: [], failType: 'qa_gate' });
                     monotask_state_machine_1.MonotaskSM.release(task.agent, task.id, `QA gate: ${qaResult.reason}`);
+                    // TICKET-352: feed the QA-gate failure to the coder on retry. Previously
+                    // the QA reason was only logged, so the coder repaired BLIND (lastReview
+                    // stayed stale/undefined). A red paired-test's output (expected X, got Y)
+                    // is the most actionable repair signal there is — surface it as the review.
+                    lastReview = {
+                        verdict: 'REJECTED',
+                        score: 0,
+                        summary: `QA gate failed: ${qaResult.reason}`,
+                        issues: [{ severity: 'critical', file: (task.deliverables.code?.[0] || task.id), description: qaResult.reason }],
+                        strengths: [],
+                    };
                     if (attempt < MAX_RETRIES) {
-                        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  QA gate failed — retrying without supervisor...');
+                        (0, engine_primitives_1.log)(engine_primitives_1.c.yellow, '  QA gate failed — retrying with the failure as feedback...');
                         continue;
                     }
                     taskRun.status = 'rejected';
@@ -915,6 +926,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/dist/lib/engine-primitives.js

@@ -46,6 +46,16 @@ exports.callAnthropicCached = callAnthropicCached;
 exports.compressContext = compressContext;
 exports.localQAGate = localQAGate;
 exports.httpPost = httpPost;
+/**
+ * engine-primitives.ts — shared low-level primitives extracted from orchestrate-engine.ts
+ * (TICKET-231 engine split 4). Token accounting, AgentTask/ReviewResult/CTO* types,
+ * the LLM gateway (callLLM/callAnthropicCached/compressContext), credit/budget alerts,
+ * provider classification, and the QA/debug helpers (localQAGate/typecheckChangedFiles/
+ * tieredDebug/httpPost). This is a LEAF module — it imports only sibling leaf modules,
+ * never back from orchestrate-engine, so the prior split modules can depend on it without
+ * a cycle (orchestrate-engine re-exports the primitives they import for back-compat).
+ */
+const fs_1 = require("fs");
 const child_process_1 = require("child_process");
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
@@ -544,6 +554,50 @@ function detectRumination(content) {
     const wordCount = Math.max(1, content.split(/\s+/).filter(Boolean).length);
     return { hits, ratio: hits / wordCount };
 }
+// TICKET-352: green-test approval gate. The remaining wall after 347-351 is
+// CONTENT CORRECTNESS — a well-shaped single-concern logic file still rejects at
+// ~50/100 because the supervisor's read is subjective and the repair loop has no
+// ground truth. This makes correctness OBJECTIVE: when a task's generated set
+// includes a paired test file, EXECUTE it and fail QA if it's red — and the
+// failure output flows back to the coder as concrete repair feedback (expected X,
+// got Y) instead of prose. No-op when no test files are present (back-compat).
+// Disable with KOGNAI_TEST_GATE=0. NOTE: this executes model-generated test code
+// in-repo, bounded by a timeout — same trust surface as the swarm already
+// committing generated code.
+const TEST_GATE_ENABLED = (process.env.KOGNAI_TEST_GATE ?? '1') !== '0';
+const TEST_RUN_TIMEOUT_MS = parseInt(process.env.KOGNAI_TEST_TIMEOUT_MS ?? '90000', 10);
+function runPairedTests(fileContents) {
+    if (!TEST_GATE_ENABLED)
+        return { pass: true, reason: 'test gate disabled (KOGNAI_TEST_GATE=0)' };
+    const testFiles = fileContents.filter(f => /\.(test|spec)\.[tj]sx?$/.test(f.path) && (0, fs_1.existsSync)(f.path));
+    if (testFiles.length === 0)
+        return { pass: true, reason: 'no paired tests' };
+    for (const tf of testFiles) {
+        const isTs = /\.tsx?$/.test(tf.path);
+        // node:test auto-runs on execution and sets a non-zero exit code if any test
+        // fails → execSync throws. TS runs via ts-node transpile-only (the typecheck
+        // gate already validated types); JS via `node --test`.
+        const cmd = isTs
+            ? `npx ts-node --transpile-only ${JSON.stringify(tf.path)}`
+            : `node --test ${JSON.stringify(tf.path)}`;
+        try {
+            (0, child_process_1.execSync)(cmd, {
+                cwd: process.cwd(),
+                timeout: TEST_RUN_TIMEOUT_MS,
+                stdio: 'pipe',
+                env: { ...process.env, TS_NODE_TRANSPILE_ONLY: 'true' },
+            });
+        }
+        catch (e) {
+            if (e?.signal === 'SIGTERM' || /ETIMEDOUT|timed out/i.test(String(e?.message || ''))) {
+                return { pass: false, reason: `Paired test TIMED OUT (${TEST_RUN_TIMEOUT_MS}ms): ${tf.path} — likely an infinite loop/hang in the code under test.` };
+            }
+            const out = `${e?.stdout?.toString?.() || ''}\n${e?.stderr?.toString?.() || ''}`.trim();
+            return { pass: false, reason: `Paired test FAILED: ${tf.path}\n--- test output (tail) ---\n${out.slice(-1500)}` };
+        }
+    }
+    return { pass: true, reason: `${testFiles.length} paired test(s) green` };
+}
 async function localQAGate(_task, fileContents) {
     // Fail only on structurally empty files (< 50 chars indicates the model returned nothing useful)
     const emptyFiles = fileContents.filter(f => (f.content || '').trim().length < 50);
@@ -584,7 +638,14 @@ async function localQAGate(_task, fileContents) {
             };
         }
     }
-    return { pass: true, reason: `${fileContents.length} file(s) non-empty + no rumination + typecheck PASS — proceeding to supervisor review` };
+    // TICKET-352: objective correctness gate — run any paired test file(s) and
+    // fail QA (with the test output as the reason → fed to the coder on retry) if
+    // red. No-op when the task generated no test files.
+    const testResult = runPairedTests(fileContents);
+    if (!testResult.pass) {
+        return { pass: false, reason: testResult.reason };
+    }
+    return { pass: true, reason: `${fileContents.length} file(s) non-empty + no rumination + typecheck PASS + ${testResult.reason} — proceeding to supervisor review` };
 }
 // TICKET-085 (v2 — TICKET-088 fix): project-aware typecheck. v1 used
 // loose-file mode + `npx -y typescript@5 tsc` and silently passed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kognai/orchestrator-core",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "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",