@kognai/orchestrator-core 0.2.8 → 0.2.9

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';

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.8",
+  "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",