@ismaelsoilet/synapsejs 1.1.1 → 1.2.0

package/bin/synapse.ts

@@ -534,7 +534,11 @@ async function main() {
     }
 
     case 'test': {
-      const report = await runSliceOracles(root);
+      const enableGate =
+        process.argv.includes('--gate') ||
+        fs.existsSync(path.join(root, '.jev.json')) ||
+        Boolean(process.env.JEV_ACTIVE || process.env.JEV_PROVIDER || process.env.TYPESAFE_API_KEY);
+      const report = await runSliceOracles(root, { enableJevTriage: enableGate });
 
       process.stdout.write(`${JSON.stringify({ operation: 'PBT_ORACLE_TEST_SUITE', ...report }, null, 2)}\n`);
       process.exit(report.status === 'PASS' ? 0 : 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ismaelsoilet/synapsejs",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Bun-only fullstack framework where a feature is a single contiguous file",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -50,6 +50,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@ismaelsoilet/jev-harness": "^0.2.1",
     "@sinclair/typebox": "^0.34.40",
     "fast-check": "^3.23.2",
     "postgres": "^3.4.9",

package/src/compiler/migration-runner.ts

@@ -6,6 +6,7 @@
  * Preserves Locality of Behavior (LoB): each slice owns its own table contracts!
  */
 
+import { type AbortGateResult, shouldAbortTrajectory } from '@ismaelsoilet/jev-harness';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
@@ -34,6 +35,7 @@ export interface MigrationReport {
   code?: SlicesDirErrorCode;
   message?: string;
   candidates?: string[];
+  abortSignal?: AbortGateResult;
 }
 
 export interface BidirectionalDdl {
@@ -404,13 +406,28 @@ export async function runSliceMigrations(
       }
     }
 
+    let abortSignal: AbortGateResult | undefined;
+    if (hasFailure) {
+      try {
+        const failureDetails = migrations
+          .filter((m) => m.status === 'FAILED')
+          .map((m) => `Slice ${m.slice}: ${m.error}`)
+          .join('\n');
+        abortSignal = await shouldAbortTrajectory(
+          `Apply sliceSchema migrations across discovered slices in ${baseDir}`,
+          failureDetails
+        );
+      } catch {}
+    }
+
     return {
       status: hasFailure ? 'FAIL' : 'PASS',
       totalDiscovered: migrations.length,
       appliedCount,
       skippedCount,
       statementsApplied: statementsAppliedTotal,
-      migrations
+      migrations,
+      abortSignal
     };
   } finally {
     if (isPostgres) {

package/src/compiler/oracle-runner.ts

@@ -9,6 +9,7 @@
  * Nothing here may report PASS when no invariant was executed.
  */
 
+import { type TestTriageResult, triageTestFailure } from '@ismaelsoilet/jev-harness';
 import * as fs from 'fs';
 import * as path from 'path';
 import { findSliceFiles, resolveSlicesDir, type SlicesDirErrorCode } from './slice-discovery';
@@ -42,6 +43,7 @@ export interface OracleReport {
   code?: OracleErrorCode;
   message?: string;
   candidates?: string[];
+  triage?: TestTriageResult;
 }
 
 export interface JunitSuite {
@@ -154,6 +156,8 @@ export function oracleWrapperSource(importPath: string, sliceName: string): stri
 export interface OracleRunOptions {
   /** Injected by tests: runs a command and returns its exit code and output. */
   spawn?: (args: string[], cwd: string) => Promise<{ exitCode: number; output: string }>;
+  /** Enable Jev System One semantic test triage on failures. Default: true */
+  enableJevTriage?: boolean;
 }
 
 async function defaultSpawn(args: string[], cwd: string): Promise<{ exitCode: number; output: string }> {
@@ -241,6 +245,12 @@ export async function runSliceOracles(
   );
 
   if (!fs.existsSync(reportPath)) {
+    let triageResult: TestTriageResult | undefined;
+    if (options.enableJevTriage !== false) {
+      try {
+        triageResult = await triageTestFailure(output.trim() || `O runner Bun test falhou com exit ${exitCode}`);
+      } catch {}
+    }
     return {
       status: 'FAIL',
       totalSlices: wrappers.size,
@@ -249,7 +259,8 @@ export async function runSliceOracles(
       passedCases: 0,
       results: [],
       code: 'RUNNER_FAILED',
-      message: `O runner não produziu relatório (exit ${exitCode}). ${output.trim().slice(-400)}`.trim()
+      message: `O runner não produziu relatório (exit ${exitCode}). ${output.trim().slice(-400)}`.trim(),
+      triage: triageResult
     };
   }
 
@@ -268,6 +279,12 @@ export async function runSliceOracles(
   const passedSlices = results.filter((item) => item.passed).length;
 
   if (totalCases === 0) {
+    let triageResult: TestTriageResult | undefined;
+    if (options.enableJevTriage !== false) {
+      try {
+        triageResult = await triageTestFailure(`Nenhum invariante foi executado em ${results.length} fatia(s).`);
+      } catch {}
+    }
     return {
       status: 'FAIL',
       slicesDir: path.relative(root, slicesDir),
@@ -277,17 +294,34 @@ export async function runSliceOracles(
       passedCases: 0,
       results,
       code: 'NO_CASES',
-      message: `Nenhum invariante foi executado em ${results.length} fatia(s).`
+      message: `Nenhum invariante foi executado em ${results.length} fatia(s).`,
+      triage: triageResult
     };
   }
 
+  const isPass = passedSlices === results.length;
+  let triageResult: TestTriageResult | undefined;
+  if (!isPass && options.enableJevTriage !== false) {
+    try {
+      const failedSummaries = results
+        .filter((r) => !r.passed)
+        .flatMap((r) =>
+          r.cases.filter((c) => !c.passed).map((c) => `[${r.slice}] ${c.name}: ${c.message || 'assertion failed'}`)
+        )
+        .join('\n');
+      const failureTrace = failedSummaries || output.trim() || 'Slice oracle invariants failed';
+      triageResult = await triageTestFailure(failureTrace);
+    } catch {}
+  }
+
   return {
-    status: passedSlices === results.length ? 'PASS' : 'FAIL',
+    status: isPass ? 'PASS' : 'FAIL',
     slicesDir: path.relative(root, slicesDir),
     totalSlices: results.length,
     passedSlices,
     totalCases,
     passedCases,
-    results
+    results,
+    triage: triageResult
   };
 }

package/src/mcp/server.ts

@@ -6,6 +6,16 @@
  * directly to AI Agents (Cursor, Claude Code, Windsurf, Antigravity) via JSON-RPC 2.0 over stdio.
  */
 
+import {
+  type AbortGateResult,
+  modulateReasoningEffort,
+  type ReasoningEffortResult,
+  shouldAbortTrajectory,
+  type TestTriageResult,
+  triageTestFailure,
+  type VerificationResult,
+  verifyStepCompletion
+} from '@ismaelsoilet/jev-harness';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
@@ -80,7 +90,7 @@ export class SynapseMcpServer {
             },
             serverInfo: {
               name: 'synapse-mcp',
-              version: '1.1.0'
+              version: '1.2.0'
             }
           }
         };
@@ -201,6 +211,67 @@ export class SynapseMcpServer {
                     steps: { type: 'number', description: 'Number of recent migrations to rollback (default: 1)' }
                   }
                 }
+              },
+              {
+                name: 'synapse_test_gate',
+                description:
+                  'Execute Fast-Check PBT oracles and immediately triage failures with Jev System One semantic test-gate to prevent LLM token waste',
+                inputSchema: {
+                  type: 'object',
+                  properties: {}
+                }
+              },
+              {
+                name: 'synapse_abort_check',
+                description:
+                  'Evaluate plan and error history with Jev System One to detect doomed trajectories, circular loops, or high-risk refactor dead ends',
+                inputSchema: {
+                  type: 'object',
+                  required: ['plan', 'history'],
+                  properties: {
+                    plan: { type: 'string', description: 'Proposed implementation plan or architectural change' },
+                    history: { type: 'string', description: 'Recent attempt history, error logs, or failure reasons' }
+                  }
+                }
+              },
+              {
+                name: 'synapse_verify_completion',
+                description:
+                  'Verify slice implementation and test outputs against acceptance criteria using Jev System One before committing work',
+                inputSchema: {
+                  type: 'object',
+                  required: ['criteria', 'output'],
+                  properties: {
+                    criteria: { type: 'string', description: 'Acceptance criteria or requirement specifications' },
+                    output: {
+                      type: 'string',
+                      description: 'Actual implementation summary, test output, or slice behavior'
+                    }
+                  }
+                }
+              },
+              {
+                name: 'synapse_reasoning_effort',
+                description:
+                  'Dynamically modulate agent reasoning effort (Astra-Jev) to low/medium/high based on step context (lowering effort for mechanical commands like split/migrate/skeleton)',
+                inputSchema: {
+                  type: 'object',
+                  required: ['context'],
+                  properties: {
+                    context: {
+                      type: 'string',
+                      description: 'Immediate command or task context, e.g. "synapse split", "git commit"'
+                    },
+                    provider: {
+                      type: 'string',
+                      description: 'Target LLM provider, e.g. "deepseek", "anthropic", "openai"'
+                    },
+                    sessionContextTokens: {
+                      type: 'number',
+                      description: 'Estimated session context token count to protect prompt cache'
+                    }
+                  }
+                }
               }
             ]
           }
@@ -503,6 +574,29 @@ export class SynapseMcpServer {
               steps: args.steps
             });
             contentText = JSON.stringify(report, null, 2);
+          } else if (toolName === 'synapse_test_gate') {
+            const report = await runSliceOracles(this.root, { enableJevTriage: true });
+            contentText = JSON.stringify(report, null, 2);
+          } else if (toolName === 'synapse_abort_check') {
+            const plan = String(args.plan || '');
+            const history = String(args.history || '');
+            const result: AbortGateResult = await shouldAbortTrajectory(plan, history);
+            contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_verify_completion') {
+            const criteria = String(args.criteria || '');
+            const output = String(args.output || '');
+            const result: VerificationResult = await verifyStepCompletion(criteria, output);
+            contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_reasoning_effort') {
+            const context = String(args.context || '');
+            const provider = args.provider ? String(args.provider) : undefined;
+            const sessionContextTokens =
+              typeof args.sessionContextTokens === 'number' ? args.sessionContextTokens : undefined;
+            const result: ReasoningEffortResult = await modulateReasoningEffort(context, {
+              provider,
+              sessionContextTokens
+            });
+            contentText = JSON.stringify(result, null, 2);
           } else {
             return {
               jsonrpc: '2.0',

package/src/runtime/server.ts

@@ -993,7 +993,7 @@ ${this.renderStylesheets()}
               {
                 status,
                 framework: 'SynapseJS',
-                version: '1.1.0',
+                version: '1.2.0',
                 uptime: process.uptime(),
                 database: dbHealthy ? 'connected' : 'disconnected',
                 ...(dbError ? { databaseError: dbError } : {}),

package/templates/starter/.jev.json

@@ -0,0 +1,6 @@
+{
+  "provider": "opencode",
+  "model": "typesafe/jev",
+  "skip_llm_threshold": 0.65,
+  "abort_threshold": 0.70
+}

package/templates/starter/package.json

@@ -12,6 +12,7 @@
     "mcp": "synapse mcp",
     "skeleton": "synapse skeleton",
     "test": "synapse test",
+    "test:gate": "synapse test --gate",
     "new-slice": "synapse new-slice",
     "split": "synapse split",
     "build": "synapse build",