@ismaelsoilet/synapsejs 1.1.1 → 1.3.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.3.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/client/hooks.ts

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import type { Result } from '../core/machine-types';
+import { useSynapseContext } from './context';
 
 export interface UseSubscriptionOptions {
   enabled?: boolean;
@@ -86,17 +87,33 @@ export interface UseActionResult<TPayload, TData, TError> {
   reset: () => void;
 }
 
+export interface UseActionOptions<TData, TError> {
+  onSuccess?: (data: TData) => void;
+  onError?: (error: TError) => void;
+}
+
 /**
  * Hook for executing server actions from client UI with reactive state management.
+ * If actionFn is not provided, it automatically resolves the slice's action from SynapseContext.
  */
 export function useAction<TPayload = unknown, TData = unknown, TError = string>(
-  actionFn?: (payload: TPayload) => Promise<Result<TData, TError>>
+  actionFn?: ((payload: TPayload) => Promise<Result<TData, TError>>) | null,
+  options?: UseActionOptions<TData, TError>
 ): UseActionResult<TPayload, TData, TError> {
   const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
   const [data, setData] = useState<TData | null>(null);
   const [error, setError] = useState<TError | null>(null);
   const [isSuccess, setIsSuccess] = useState<boolean>(false);
 
+  const ctx = useSynapseContext();
+  const resolvedAction =
+    actionFn ??
+    (ctx.props?.action as ((payload: TPayload) => Promise<Result<TData, TError>>) | undefined) ??
+    (ctx.props?.onSubmitAction as ((payload: TPayload) => Promise<Result<TData, TError>>) | undefined);
+
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+
   const reset = useCallback(() => {
     setIsSubmitting(false);
     setData(null);
@@ -106,9 +123,10 @@ export function useAction<TPayload = unknown, TData = unknown, TError = string>(
 
   const execute = useCallback(
     async (payload: TPayload): Promise<Result<TData, TError>> => {
-      if (!actionFn) {
+      if (!resolvedAction) {
         const errVal = 'NO_ACTION_FUNCTION' as unknown as TError;
         setError(errVal);
+        optionsRef.current?.onError?.(errVal);
         return { ok: false, error: errVal };
       }
 
@@ -117,26 +135,29 @@ export function useAction<TPayload = unknown, TData = unknown, TError = string>(
       setIsSuccess(false);
 
       try {
-        const result = await actionFn(payload);
+        const result = await resolvedAction(payload);
         if (result.ok) {
           setData(result.value);
           setIsSuccess(true);
           setError(null);
+          optionsRef.current?.onSuccess?.(result.value);
         } else {
           setError(result.error);
           setIsSuccess(false);
+          optionsRef.current?.onError?.(result.error);
         }
         return result;
       } catch (err: unknown) {
         const failure = (err instanceof Error ? err.message : String(err)) as unknown as TError;
         setError(failure);
         setIsSuccess(false);
+        optionsRef.current?.onError?.(failure);
         return { ok: false, error: failure };
       } finally {
         setIsSubmitting(false);
       }
     },
-    [actionFn]
+    [resolvedAction]
   );
 
   return {

package/src/client.ts

@@ -41,6 +41,7 @@ export {
 } from './client/context';
 // Reactive Action & Realtime Subscription Hooks
 export {
+  type UseActionOptions,
   type UseActionResult,
   type UseSubscriptionOptions,
   type UseSubscriptionResult,

package/src/compiler/client-bundler.ts

@@ -71,13 +71,77 @@ export async function buildVendorBundle(baseDir: string): Promise<Result<BuiltBu
     `import * as ReactDOM from 'react-dom';`,
     `import * as ReactDOMClient from 'react-dom/client';`,
     `import * as SynapseClient from 'synapsejs/client';`,
+    `import * as jsxRuntime from 'react/jsx-runtime';`,
+    `import * as jsxDevRuntime from 'react/jsx-dev-runtime';`,
     ``,
     `export default React;`,
     `export * from 'react';`,
     `export * from 'react-dom';`,
     `export * from 'react-dom/client';`,
     `export * from 'synapsejs/client';`,
-    `export { ReactDOM, ReactDOMClient, SynapseClient };`,
+    `export * from 'react/jsx-runtime';`,
+    `export * from 'react/jsx-dev-runtime';`,
+    `const { hydrateRoot, createRoot } = ReactDOMClient;`,
+    `const { jsx, jsxs } = (jsxRuntime as unknown as Record<string, unknown>);`,
+    `const { jsxDEV } = (jsxDevRuntime as unknown as Record<string, unknown>);`,
+    `const {`,
+    `  useState,`,
+    `  useEffect,`,
+    `  useCallback,`,
+    `  useMemo,`,
+    `  useRef,`,
+    `  useContext,`,
+    `  useReducer,`,
+    `  useId,`,
+    `  useLayoutEffect,`,
+    `  useTransition,`,
+    `  useDeferredValue,`,
+    `  createContext,`,
+    `  createElement,`,
+    `  cloneElement,`,
+    `  isValidElement,`,
+    `  Fragment,`,
+    `  Component,`,
+    `  PureComponent,`,
+    `  memo,`,
+    `  forwardRef,`,
+    `  Children,`,
+    `  startTransition`,
+    `} = (React as unknown as Record<string, unknown>);`,
+    `export {`,
+    `  ReactDOM,`,
+    `  ReactDOMClient,`,
+    `  SynapseClient,`,
+    `  jsxRuntime,`,
+    `  jsxDevRuntime,`,
+    `  hydrateRoot,`,
+    `  createRoot,`,
+    `  jsx,`,
+    `  jsxs,`,
+    `  jsxDEV,`,
+    `  useState,`,
+    `  useEffect,`,
+    `  useCallback,`,
+    `  useMemo,`,
+    `  useRef,`,
+    `  useContext,`,
+    `  useReducer,`,
+    `  useId,`,
+    `  useLayoutEffect,`,
+    `  useTransition,`,
+    `  useDeferredValue,`,
+    `  createContext,`,
+    `  createElement,`,
+    `  cloneElement,`,
+    `  isValidElement,`,
+    `  Fragment,`,
+    `  Component,`,
+    `  PureComponent,`,
+    `  memo,`,
+    `  forwardRef,`,
+    `  Children,`,
+    `  startTransition`,
+    `};`,
     ``
   ].join('\n');
 
@@ -194,12 +258,51 @@ export async function buildClientBundle(
   const entryPath = path.join(entryDir, `${target.domain}-${target.name}.tsx`);
   const modulePath = path.relative(entryDir, path.join(outDir, clientArtifact.fileName)).split(path.sep).join('/');
 
+  // Detect optional root and domain layouts for isomorphic hydration
+  let rootLayoutPath: string | undefined;
+  let domainLayoutPath: string | undefined;
+
+  let currentDir = path.dirname(target.filePath);
+  let slicesDir: string | null = null;
+  while (currentDir && currentDir !== baseDir && currentDir !== path.dirname(currentDir)) {
+    if (path.basename(currentDir) === 'slices') {
+      slicesDir = currentDir;
+      break;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  if (slicesDir) {
+    const rootCandidates = [path.join(slicesDir, '_layout.tsx'), path.join(slicesDir, 'layout.tsx')];
+    for (const cand of rootCandidates) {
+      if (fs.existsSync(cand)) {
+        const rel = path.relative(entryDir, cand).split(path.sep).join('/');
+        rootLayoutPath = rel.startsWith('.') ? rel : `./${rel}`;
+        break;
+      }
+    }
+
+    const domainDir = path.dirname(target.filePath);
+    if (domainDir !== slicesDir) {
+      const domainCandidates = [path.join(domainDir, '_layout.tsx'), path.join(domainDir, 'layout.tsx')];
+      for (const cand of domainCandidates) {
+        if (fs.existsSync(cand)) {
+          const rel = path.relative(entryDir, cand).split(path.sep).join('/');
+          domainLayoutPath = rel.startsWith('.') ? rel : `./${rel}`;
+          break;
+        }
+      }
+    }
+  }
+
   fs.writeFileSync(
     entryPath,
     clientEntrySource({
       componentName: componentExport,
       clientModulePath: `./${modulePath}`,
-      rpcPath: target.rpcPath
+      rpcPath: target.rpcPath,
+      rootLayoutPath,
+      domainLayoutPath
     }),
     'utf-8'
   );
@@ -224,7 +327,15 @@ export async function buildClientBundle(
       naming: '[name].js',
       minify: production,
       external: vendorSplit
-        ? ['react', 'react-dom', 'react-dom/client', 'synapsejs/client', '@ismaelsoilet/synapsejs/client']
+        ? [
+            'react',
+            'react/jsx-runtime',
+            'react/jsx-dev-runtime',
+            'react-dom',
+            'react-dom/client',
+            'synapsejs/client',
+            '@ismaelsoilet/synapsejs/client'
+          ]
         : [],
       define: { 'process.env.NODE_ENV': production ? '"production"' : '"development"' }
     });

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/compiler/scaffolder.ts

@@ -61,7 +61,7 @@ import {
 // ============================================================================
 export const ${inputSchemaName} = Type.Object({
 ${tbProps}
-});
+}, { additionalProperties: true });
 export type ${inputTypeName} = Static<typeof ${inputSchemaName}>;
 
 // DDL Schema Declarativo da Fatia (Auto-Migrado pelo Synapse)
@@ -211,7 +211,7 @@ export const ${inputSchemaName} = Type.Object({
   name: Type.String({ minLength: 2, maxLength: 100 }),
   email: Type.String({ format: 'email' }),
   metadata: Type.Optional(Type.String())
-});
+}, { additionalProperties: true });
 export type ${inputTypeName} = Static<typeof ${inputSchemaName}>;
 
 // DDL Schema Declarativo da Fatia (Auto-Migrado pelo Synapse)

package/src/compiler/slice-templates.ts

@@ -88,7 +88,7 @@ export const ${names.schemaName} = Type.Object({
   query: Type.Optional(Type.String({ maxLength: 60 })),
   limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
   offset: Type.Optional(Type.Integer({ minimum: 0 }))
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================
@@ -236,7 +236,7 @@ export const ${names.schemaName} = Type.Object({
   query: Type.Optional(Type.String({ maxLength: 60 })),
   limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
   offset: Type.Optional(Type.Integer({ minimum: 0 }))
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // A tabela pertence a outra fatia desta mesma feature.
@@ -450,7 +450,7 @@ function updateTemplate(names: TemplateNames): string {
 export const ${names.schemaName} = Type.Object({
   id: Type.String({ minLength: 1 }),
   name: Type.Optional(Type.String({ minLength: 2, maxLength: 120 }))
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================
@@ -657,7 +657,7 @@ function deleteTemplate(names: TemplateNames): string {
 // ============================================================================
 export const ${names.schemaName} = Type.Object({
   id: Type.String({ minLength: 1 })
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================
@@ -806,7 +806,7 @@ import { storeSession } from 'synapsejs/client';
 export const ${names.schemaName} = Type.Object({
   email: Type.String({ minLength: 3, maxLength: 200 }),
   password: Type.String({ minLength: 8, maxLength: 200 })
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================
@@ -1075,7 +1075,7 @@ import {
 export const ${names.schemaName} = Type.Object({
   code: Type.String({ minLength: 1, maxLength: 500 }),
   state: Type.Optional(Type.String({ maxLength: 500 }))
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================
@@ -1353,7 +1353,7 @@ import { signSessionToken } from 'synapsejs';
 export const ${names.schemaName} = Type.Object({
   userId: Type.String({ minLength: 1 }),
   code: Type.String({ minLength: 6, maxLength: 6 })
-});
+}, { additionalProperties: true });
 export type ${names.inputName} = Static<typeof ${names.schemaName}>;
 
 // ============================================================================

package/src/core/index.ts

@@ -12,3 +12,4 @@ export * from './session-context';
 export * from './session-token';
 export * from './sqlite-client';
 export * from './storage';
+export * from './validation';

package/src/core/validation.ts

@@ -0,0 +1,57 @@
+/**
+ * SynapseJS - Schema Validation Utilities
+ *
+ * Provides structured, human-readable validation for TypeBox contracts.
+ * Rather than returning an opaque 'INVALID_SCHEMA', it extracts the exact
+ * paths and failure reasons to provide actionable machine and developer diagnostics.
+ */
+
+import type { Static, TSchema } from '@sinclair/typebox';
+import { Value } from '@sinclair/typebox/value';
+import { Err, Ok, type Result } from './machine-types';
+
+export interface ValidationErrorDetail {
+  path: string;
+  message: string;
+  value?: unknown;
+}
+
+export interface ValidationFailure {
+  code: 'INVALID_SCHEMA';
+  message: string;
+  errors: ValidationErrorDetail[];
+}
+
+/**
+ * Validates a payload against a TypeBox schema with detailed error reporting.
+ * Returns Ok(validatedValue) or Err with formatted diagnosis.
+ */
+export function validateSchema<T extends TSchema>(schema: T, payload: unknown): Result<Static<T>, string> {
+  if (Value.Check(schema, payload)) {
+    return Ok(payload as Static<T>);
+  }
+
+  const errors: ValidationErrorDetail[] = [];
+  try {
+    for (const err of Value.Errors(schema, payload)) {
+      errors.push({
+        path: err.path || '/',
+        message: err.message,
+        value: err.value
+      });
+    }
+  } catch {
+    // Se a extração de erros falhar, mantém fallback seguro
+  }
+
+  if (errors.length === 0) {
+    return Err('INVALID_SCHEMA: Falha na validação do contrato de entrada.');
+  }
+
+  const formattedDetails = errors
+    .slice(0, 3)
+    .map((e) => `campo "${e.path}": ${e.message}`)
+    .join('; ');
+
+  return Err(`INVALID_SCHEMA: ${formattedDetails}`);
+}

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/client-entry.ts

@@ -17,6 +17,8 @@ export interface ClientEntryOptions {
   rpcPath: string;
   rootId?: string;
   actionPropNames?: string[];
+  rootLayoutPath?: string;
+  domainLayoutPath?: string;
 }
 
 export const CLIENT_ROOT_ID = 'synapse-root';
@@ -26,14 +28,25 @@ export function clientEntrySource(options: ClientEntryOptions): string {
   const rootId = options.rootId ?? CLIENT_ROOT_ID;
   const propNames = options.actionPropNames ?? ['onSubmitAction', 'action'];
   const actionWires = propNames
-    .map((name) => `      ${name}: (payload: unknown) => rpcCall(${JSON.stringify(options.rpcPath)}, payload)`)
+    .map((name) => `        ${name}: (payload: unknown) => rpcCall(${JSON.stringify(options.rpcPath)}, payload)`)
     .join(',\n');
 
-  return [
+  const layoutImports: string[] = [];
+  if (options.rootLayoutPath) {
+    layoutImports.push(`import * as RootLayoutModule from ${JSON.stringify(options.rootLayoutPath)};`);
+  }
+  if (options.domainLayoutPath) {
+    layoutImports.push(`import * as DomainLayoutModule from ${JSON.stringify(options.domainLayoutPath)};`);
+  }
+
+  const hasLayouts = Boolean(options.rootLayoutPath || options.domainLayoutPath);
+
+  const lines = [
     `// [SYNAPSE-JS GENERATED CLIENT ENTRY] hydrates the slice in the browser`,
     `import React from 'react';`,
     `import { hydrateRoot } from 'react-dom/client';`,
-    `import { rpcCall } from 'synapsejs/client';`,
+    `import { rpcCall, SynapseProvider } from 'synapsejs/client';`,
+    ...layoutImports,
     `import { ${options.componentName} } from ${JSON.stringify(options.clientModulePath)};`,
     ``,
     `export function hydrate() {`,
@@ -41,19 +54,49 @@ export function clientEntrySource(options: ClientEntryOptions): string {
     `  const props = (scope[${JSON.stringify(CLIENT_PROPS_GLOBAL)}] ?? {}) as Record<string, unknown>;`,
     `  const root = document.getElementById(${JSON.stringify(rootId)});`,
     `  if (root) {`,
-    `    hydrateRoot(`,
-    `      root,`,
-    `      React.createElement(${options.componentName}, {`,
-    `        ...props,`,
+    `    const sliceElement = React.createElement(${options.componentName}, {`,
+    `      ...props,`,
     `${actionWires}`,
-    `      })`,
-    `    );`,
-    `  }`,
-    `}`,
-    ``,
-    `hydrate();`,
-    ``
-  ].join('\n');
+    `    });`
+  ];
+
+  if (hasLayouts) {
+    if (options.domainLayoutPath) {
+      lines.push(
+        `    const DomainLayout = (DomainLayoutModule as any).default || (DomainLayoutModule as any).Layout || null;`
+      );
+    }
+    if (options.rootLayoutPath) {
+      lines.push(
+        `    const RootLayout = (RootLayoutModule as any).default || (RootLayoutModule as any).Layout || null;`
+      );
+    }
+    let treeExpr = 'sliceElement';
+    if (options.domainLayoutPath) {
+      treeExpr = `(typeof DomainLayout === 'function' ? React.createElement(DomainLayout, { ...props }, ${treeExpr}) : ${treeExpr})`;
+    }
+    if (options.rootLayoutPath) {
+      treeExpr = `(typeof RootLayout === 'function' ? React.createElement(RootLayout, { ...props }, ${treeExpr}) : ${treeExpr})`;
+    }
+    lines.push(`    const treeWithLayout = ${treeExpr};`);
+    lines.push(`    hydrateRoot(`);
+    lines.push(`      root,`);
+    lines.push(`      React.createElement(SynapseProvider, { props, session: props.session as any }, treeWithLayout)`);
+    lines.push(`    );`);
+  } else {
+    lines.push(`    hydrateRoot(`);
+    lines.push(`      root,`);
+    lines.push(`      React.createElement(SynapseProvider, { props, session: props.session as any }, sliceElement)`);
+    lines.push(`    );`);
+  }
+
+  lines.push(`  }`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`hydrate();`);
+  lines.push(``);
+
+  return lines.join('\n');
 }
 
 /**

package/src/runtime/server.ts

@@ -356,7 +356,8 @@ export class SynapseServer {
     for (const cand of layoutCandidates) {
       if (fs.existsSync(cand)) {
         try {
-          const layoutMod = await import(cand);
+          const candStat = fs.statSync(cand);
+          const layoutMod = await import(`${cand}?t=${candStat.mtimeMs}`);
           this.layoutComponent = layoutMod.default || layoutMod.Layout || null;
           break;
         } catch (e) {
@@ -380,7 +381,8 @@ export class SynapseServer {
         for (const cand of domainCandidates) {
           if (fs.existsSync(cand)) {
             try {
-              const domainMod = await import(cand);
+              const candStat = fs.statSync(cand);
+              const domainMod = await import(`${cand}?t=${candStat.mtimeMs}`);
               const domainComp = domainMod.default || domainMod.Layout || null;
               if (domainComp) {
                 this.domainLayouts.set(domain, domainComp);
@@ -399,7 +401,8 @@ export class SynapseServer {
       }
 
       try {
-        const mod = await import(file);
+        const fileStat = fs.existsSync(file) ? fs.statSync(file) : null;
+        const mod = await import(fileStat ? `${file}?t=${fileStat.mtimeMs}` : file);
         let actionFn: any = null;
         let componentFn: any = null;
         let componentExport: string | undefined;
@@ -624,10 +627,12 @@ export class SynapseServer {
       return null;
     }
 
-    const signature = String(fs.statSync(slice.filePath).mtimeMs);
+    const stat = fs.existsSync(slice.filePath) ? fs.statSync(slice.filePath) : null;
+    const signature = stat ? String(stat.mtimeMs) : 'missing';
     const cached = this.clientBundles.get(slice.key);
     if (cached?.builtFor === signature) {
-      return cached.url;
+      const version = stat ? `?v=${Math.floor(stat.mtimeMs)}` : '';
+      return `${cached.url}${version}`;
     }
 
     // `synapse build` já empacotou esta fatia e o arquivo não mudou desde então:
@@ -639,7 +644,8 @@ export class SynapseServer {
     const prebuilt = freshBundleFrom(this.clientManifest, slice.key, Number(signature));
     if (prebuilt) {
       this.clientBundles.set(slice.key, { url: prebuilt, builtFor: signature });
-      return prebuilt;
+      const version = stat ? `?v=${Math.floor(stat.mtimeMs)}` : '';
+      return `${prebuilt}${version}`;
     }
 
     const built = await buildClientBundle(
@@ -660,7 +666,8 @@ export class SynapseServer {
 
     this.clientBundles.set(slice.key, { url: built.value.url, builtFor: signature });
 
-    return built.value.url;
+    const version = stat ? `?v=${Math.floor(stat.mtimeMs)}` : '';
+    return `${built.value.url}${version}`;
   }
 
   /**
@@ -696,7 +703,8 @@ export class SynapseServer {
     propsJson: string,
     clientUrl: string | null,
     meta?: SliceMetadata,
-    locale = 'pt-BR'
+    locale = 'pt-BR',
+    hasLayout = false
   ): string {
     const safeTitle = escapeHtml(title);
     const safeSliceName = escapeHtml(sliceName);
@@ -729,6 +737,44 @@ export class SynapseServer {
     }
     const metaSection = metaTags.length > 0 ? `\n${metaTags.join('\n')}` : '';
 
+    if (hasLayout) {
+      return `<!DOCTYPE html>
+<html lang="${escapeHtml(locale)}" class="min-h-full">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${pageTitle}</title>${metaSection}
+${this.renderStylesheets()}
+  <script type="importmap">
+  {
+    "imports": {
+      "react": "/_synapse/client/_vendor.js",
+      "react/jsx-runtime": "/_synapse/client/_vendor.js",
+      "react/jsx-dev-runtime": "/_synapse/client/_vendor.js",
+      "react-dom": "/_synapse/client/_vendor.js",
+      "react-dom/client": "/_synapse/client/_vendor.js",
+      "synapsejs/client": "/_synapse/client/_vendor.js",
+      "@ismaelsoilet/synapsejs/client": "/_synapse/client/_vendor.js"
+    }
+  }
+  </script>
+  <script type="module" src="/_synapse/client/_vendor.js"></script>
+  <style>
+    body { font-family: 'Inter', sans-serif; }
+    code, pre { font-family: 'JetBrains Mono', monospace; }
+  </style>
+</head>
+<body class="min-h-full flex flex-col">
+  <div id="synapse-root" class="min-h-full flex-1 flex flex-col">${contentHtml}</div>
+
+  <script data-synapse-props>globalThis.__SYNAPSE_PROPS__ = ${propsJson};</script>
+  ${clientUrl ? `<script data-synapse-client type="module" src="${clientUrl}"></script>` : '<!-- sem componente hidratavel -->'}
+
+  <script type="module" src="/_synapse/turbo-router.js"></script>
+</body>
+</html>`;
+    }
+
     return `<!DOCTYPE html>
 <html lang="${escapeHtml(locale)}" class="h-full bg-slate-950 text-slate-100">
 <head>
@@ -740,9 +786,12 @@ ${this.renderStylesheets()}
   {
     "imports": {
       "react": "/_synapse/client/_vendor.js",
+      "react/jsx-runtime": "/_synapse/client/_vendor.js",
+      "react/jsx-dev-runtime": "/_synapse/client/_vendor.js",
       "react-dom": "/_synapse/client/_vendor.js",
       "react-dom/client": "/_synapse/client/_vendor.js",
-      "synapsejs/client": "/_synapse/client/_vendor.js"
+      "synapsejs/client": "/_synapse/client/_vendor.js",
+      "@ismaelsoilet/synapsejs/client": "/_synapse/client/_vendor.js"
     }
   }
   </script>
@@ -993,7 +1042,7 @@ ${this.renderStylesheets()}
               {
                 status,
                 framework: 'SynapseJS',
-                version: '1.1.0',
+                version: '1.2.0',
                 uptime: process.uptime(),
                 database: dbHealthy ? 'connected' : 'disconnected',
                 ...(dbError ? { databaseError: dbError } : {}),
@@ -1501,6 +1550,7 @@ ${this.renderStylesheets()}
 
             this.logRequest(req, pathname, 200, startedAt, session, 'ssr');
 
+            const hasCustomLayout = Boolean(this.layoutComponent || this.domainLayouts.get(slice.domain));
             const html = this.renderHtmlShell(
               meta?.title || slice.name,
               contentHtml,
@@ -1508,7 +1558,8 @@ ${this.renderStylesheets()}
               serializeClientProps(dataProps),
               clientUrl,
               meta,
-              matchedLocale || 'pt-BR'
+              matchedLocale || 'pt-BR',
+              hasCustomLayout
             );
             return new Response(html, {
               headers: { 'Content-Type': 'text/html; charset=utf-8' }

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",