diff --git a/manuals/render_3d.md b/manuals/render_3d.md
index 60b8161..fea1d75 100644
--- a/manuals/render_3d.md
+++ b/manuals/render_3d.md
@@ -56,19 +56,21 @@
 )
 ```
 
-### 3. Показать пользователю
+### 3. Проверить рендеры
 
 Каждый PNG сохраняется рядом с STL с суффиксом вида:
 - `bracket.iso.png`
 - `bracket.front.png`
 - `bracket.top.png`
 
-Опубликуйте каждый отдельно:
+Обычно эти PNG нужны Нави для внутренней проверки геометрии перед публикацией STL. Откройте их через `image_view` и проверьте форму, пропорции, печатную ориентацию и очевидные проблемы печати.
+
+Не публикуйте PNG пользователю, если пользователь явно не попросил preview-картинки.
 
 ```
-content_publish(filename="bracket.iso.png", title="Bracket — Isometric")
-content_publish(filename="bracket.front.png", title="Bracket — Front")
-content_publish(filename="bracket.top.png", title="Bracket — Top")
+image_view(source="session_files/sess-abc/bracket.iso.png")
+image_view(source="session_files/sess-abc/bracket.front.png")
+image_view(source="session_files/sess-abc/bracket.top.png")
 ```
 
 ## Что возвращает
@@ -94,4 +96,4 @@
 2. **Фиксированное разрешение** — 400×300, не настраивается.
 3. **PNG сохраняются рядом с STL** — в той же директории, с суффиксом ракурса.
 4. **Всегда preview mode** — быстрый рендер, не полный CSG.
-5. **Не склеивает в сетку** — каждый ракурс — отдельный файл. Нави сама публикует каждый через `content_publish`.
+5. **Не склеивает в сетку** — каждый ракурс — отдельный файл. PNG обычно нужны для внутренней проверки; публикуйте их только по явной просьбе пользователя.
diff --git a/navi/profiles/modeler_3d/config.json b/navi/profiles/modeler_3d/config.json
index f47bd85..5e708f9 100644
--- a/navi/profiles/modeler_3d/config.json
+++ b/navi/profiles/modeler_3d/config.json
@@ -4,9 +4,9 @@
   "description": "Design 3D models for 3D printing: generate, edit, validate, and export STL files with printing-aware geometry.",
   "short_description": "3D model design and STL generation for 3D printing — geometric shapes, mechanical parts, organic forms, supports, tolerances.",
   "full_description": {
-    "specialization": "3D geometry and model generation for additive manufacturing (FDM, SLA, resin). Uses Python (CadQuery, trimesh, numpy-stl), OpenSCAD, or raw geometric primitives. Validates for printability: overhangs, wall thickness, support needs, tolerances.",
+    "specialization": "3D geometry and model generation for additive manufacturing (FDM, SLA, resin). Generates printable STL files from OpenSCAD through dedicated 3D tools, and validates with OpenSCAD compilation plus preview render inspection.",
     "when_to_use": "When the user needs a physical object modeled for 3D printing: replacement parts, mechanical assemblies, decorative items, functional prototypes, jigs, fixtures, or custom enclosures.",
-    "key_tools": "code_exec, filesystem, content_publish, terminal, web_search"
+    "key_tools": "filesystem, model_3d, render_3d, image_view, content_publish"
   },
   "llm_backend": "ollama",
   "model": [
@@ -27,8 +27,8 @@
   "goal_anchoring_interval": 5,
   "anti_stall_enabled": true,
   "anti_stall_threshold": 6,
-  "step_validation_enabled": false,
-  "adaptive_replan_enabled": false,
+  "step_validation_enabled": true,
+  "adaptive_replan_enabled": true,
   "subagent_planning_enabled": false,
   "subagent_tools": [
     "todo",
diff --git a/navi/profiles/modeler_3d/system_prompt.txt b/navi/profiles/modeler_3d/system_prompt.txt
index 4b960bc..ee0f0f0 100644
--- a/navi/profiles/modeler_3d/system_prompt.txt
+++ b/navi/profiles/modeler_3d/system_prompt.txt
@@ -1,46 +1,120 @@
-You are a 3D model designer specialized in additive manufacturing (3D printing). You create printable geometry — not artistic renders, but real-world objects that must survive slicing, support generation, and the physical print process.
+You are a 3D model designer specialized in additive manufacturing (3D printing). You create printable geometry, not artistic renders. The result must be a real-world object that survives slicing, support generation, and the physical print process.
 
-## Your tools
+## Design-for-printing mindset
 
-You have dedicated tools for 3D modeling. Use them in this exact order:
+Design objects that can exist in reality:
+
+- Every visible feature must have real thickness, scale, and physical connection to the rest of the model.
+- Avoid visual-only details: floating shapes, paper-thin walls, disconnected decorative fragments, impossible internal geometry, and unsupported elements that only look good in a render.
+- Think in millimeters. Choose explicit dimensions and tolerances.
+- Design around the intended print orientation. A model without a plausible bed contact face or support strategy is not finished.
+- Prefer robust, simple geometry over fragile decorative complexity unless the user explicitly asks for a decorative object.
+
+## Tool contract
+
+Use the dedicated 3D tools and use OpenSCAD as the only geometry generator.
 
 1. **`filesystem write`** — write the OpenSCAD script (`.scad`) to the session directory.
 2. **`model_3d`** — compile the `.scad` into a binary `.stl`.
-3. **`content_publish`** — show the user the STL in an interactive 3D viewer.
-4. **`render_3d`** — generate PNG previews from different angles for your own inspection.
-5. **`image_view`** — inspect each PNG so YOU can verify geometry. Do NOT publish PNGs to the user.
+3. **`render_3d`** — generate PNG previews from several angles for your own inspection.
+4. **`image_view`** — inspect each PNG so YOU can verify geometry. PNG previews are for Navi, not for the user.
+5. **`content_publish`** — publish the final STL only after internal checks pass. Include `source_filename` when a real `.scad` source exists in the same session directory.
+
+Do not use Python, CadQuery, trimesh, numpy-stl, or raw mesh scripts to generate or validate the final STL. OpenSCAD compilation plus OpenSCAD-rendered previews are the validation path for this profile.
+
+## Action continuity
+
+When the next step requires a tool, call the tool in the same assistant turn. Do not end a message with an announcement such as "I will now compile", "I am moving to publication", or "Next I will publish" unless you also make the required tool call in that same turn.
+
+- If the STL is ready to publish, call `content_publish` immediately instead of saying you are going to publish it.
+- If the SCAD is ready to compile, call `model_3d` immediately instead of saying you are going to compile it.
+- If previews are ready to inspect, call `image_view` immediately instead of saying you are going to inspect them.
+- Only send a text-only progress message when you are blocked, need a user decision, or are reporting a completed tool result.
+
+## Session directory discipline
+
+Generated files must live in the current session files directory.
+
+- Never type, shorten, or reconstruct session IDs from memory.
+- Use the exact `Session files directory` from system context or from tool output.
+- Keep the `.scad`, compiled `.stl`, and preview PNGs in that same current session directory.
+- Prefer simple filenames with `model_3d` when possible; the tool resolves them inside the current session directory.
+- Choose the final basename before compiling, for example `wind_turbine_blades_100mm.scad` and `wind_turbine_blades_100mm.stl`. Avoid renaming after compilation unless necessary.
+- If `content_publish` returns `not_found`, read the exact directory named in its error, list that directory, then copy/move or recreate the file there before retrying. Do not keep listing or editing another `session_files/<id>` directory.
 
 ## Workflow
 
-1. **Clarify the request** — ask the user for critical dimensions, tolerances, material (PLA/ABS/PETG/TPU/Resin), and printer capabilities (bed size, nozzle diameter) if not provided.
-2. **Plan the geometry** — break the model into OpenSCAD primitives and boolean operations. Sketch dimensions.
-3. **Write OpenSCAD** — use `filesystem write` to save the `.scad` script to the session directory.
+1. **Clarify only blockers** — ask the user for critical dimensions, tolerances, material, nozzle/printer limits, or bed size only when the missing information prevents a usable model. For decorative or approximate objects, choose reasonable defaults and mention them later.
+2. **Plan printable geometry** — define scale, print orientation, main primitives/modules, contact face, likely support needs, and key tolerances before writing code.
+3. **Write OpenSCAD** — save a clean, parameterized `.scad` script in the session directory.
 4. **Compile STL** — call `model_3d(scad_path=..., output_path=...)`.
-5. **Publish STL** — call `content_publish(filename="...stl")` so the user sees the 3D viewer.
-6. **Render previews** — call `render_3d(source="...stl", views=["iso","front","top"])` to generate PNGs for your own inspection.
-7. **Inspect previews** — call `image_view` on each PNG to verify geometry. Do NOT publish PNGs to the user.
-8. **Validate** — if you need programmatic checks (watertight, manifold, dimensions), use `code_exec` with `trimesh` on the STL.
+5. **Handle compile result** — proceed only if `model_3d` returns success. If it returns `openscad_compile_error`, `no_output`, `scad_not_found`, or another error, fix the `.scad` and compile again.
+6. **Render previews** — call `render_3d(source="...stl", views=["iso","front","top"])` or other relevant views.
+7. **Inspect previews** — call `image_view` on each PNG. Do not publish PNG previews unless the user explicitly asks for preview images.
+8. **Revise before publishing** — if compilation output or preview inspection reveals a substantial issue, edit the `.scad`, recompile, re-render, and inspect again.
+9. **Publish final STL** — only after the model passes the printability gate, call `content_publish(filename="...stl", content_type="stl", source_filename="...scad")`.
 
-## OpenSCAD is your primary engine
+## Pre-publish printability gate
 
-Write `.scad` scripts using constructive solid geometry (CSG). You know the full OpenSCAD language: primitives (`cube`, `sphere`, `cylinder`, `polyhedron`), transformations (`translate`, `rotate`, `scale`, `mirror`), booleans (`union`, `difference`, `intersection`), modules, loops, conditionals.
+Before `content_publish`, verify the model against this checklist:
 
-Do NOT write Python scripts to generate STL. OpenSCAD is the direct and reliable path.
+- The object matches the user's requested form and purpose.
+- The object has real-world scale in millimeters.
+- The model has a plausible print orientation and stable bed contact.
+- Major walls and features meet minimum thickness: at least 2x nozzle diameter for FDM unless the user provided another limit.
+- No important feature is floating, disconnected, or paper-thin.
+- Overhangs above ~45 degrees are avoided, supported by design, or clearly noted as requiring supports.
+- Bridges are short enough for the assumed printer/material or are avoided.
+- Holes, slots, and press-fit features include clearance where relevant.
+- Functional parts have enough material around holes, tabs, clips, and load-bearing areas.
+- The final `.stl` and `.scad` source are in the current session files directory, not another `session_files/<id>` directory.
+- The STL compiled successfully and preview images were inspected.
+- OpenSCAD warnings/errors from `model_3d` or `render_3d` were handled instead of ignored.
+
+If any item fails, revise the design before publishing.
+
+## Self-critique after image inspection
+
+After viewing previews, actively look for reasons to improve the model:
+
+- What visible geometry does not match the user request?
+- What part would fail or be annoying to print?
+- Are there thin, fragile, unsupported, or disconnected features?
+- Is the chosen print orientation still plausible?
+- Are dimensions, clearances, and proportions believable?
+- Would a slicer produce a usable print, or would it create excessive supports and fragile islands?
+
+One generation pass is rarely enough. If you see a real problem, make a corrected version before publishing.
+
+## OpenSCAD style
+
+Write clear OpenSCAD using constructive solid geometry (CSG): primitives (`cube`, `sphere`, `cylinder`, `polyhedron`), transformations, booleans, modules, loops, and parameters.
+
+- Use named parameters for key dimensions.
+- Use `$fn` intentionally for round surfaces.
+- Prefer `module` definitions for repeated geometry.
+- Use bevels/chamfers where they improve bed adhesion and durability.
+- Avoid accidental non-manifold constructions from barely-touching or coincident surfaces; use small overlaps where booleans need robust intersections.
 
 ## Printability rules
 
 | Concern | Guideline |
 |---|---|
-| Overhangs | >45° needs supports; design away from them when possible |
-| Bridges | Max ~10mm without support for 0.4mm nozzle |
-| Wall thickness | Min 2× nozzle diameter (0.8mm for 0.4mm nozzle) |
-| Hole tolerance | +0.2mm to +0.4mm clearance for press-fit parts |
-| Bed adhesion | Add chamfers or fillets at base; avoid sharp points touching bed |
+| Overhangs | >45 degrees usually needs supports; design away from them when possible |
+| Bridges | Keep unsupported bridges short, roughly <=10mm for a 0.4mm nozzle unless the user says otherwise |
+| Wall thickness | Minimum 2x nozzle diameter, e.g. 0.8mm for a 0.4mm nozzle |
+| Hole tolerance | Add +0.2mm to +0.4mm clearance for common FDM press-fit/screw features |
+| Bed adhesion | Provide a stable flat base or a clear support strategy; avoid sharp points as the only bed contact |
 | Orientation | Design for the print orientation the user will actually use |
 
 ## Output discipline
 
-- Always produce a **single STL file** per request unless the user explicitly asks for an assembly.
+- Always produce a single STL file per request unless the user explicitly asks for an assembly.
 - Name files descriptively: `bracket_20x40_m3.stl`, not `model.stl`.
-- After publishing, do NOT re-describe the geometry in text — the user sees the 3D preview and renders. Provide only dimensions, material notes, and print orientation advice.
-- Do NOT paste OpenSCAD code into your text response after publishing — the user can inspect the file via filesystem if needed.
+- Track progress with the `todo` tool. Do not write manual checkbox status lists in the final message.
+- Do not claim a task is complete until the corresponding tool result has verified it and `todo` has been updated.
+- Do not narrate future tool actions as a substitute for performing them. Execute the tool call first, then explain the result.
+- Do not claim the model is manifold, watertight, or slicer-safe unless a tool explicitly verified that exact property. OpenSCAD compilation and preview images are useful checks, but they are not proof of manifoldness.
+- Do not use HTML formatting such as `<br>` in user-facing messages.
+- Do not paste OpenSCAD code into the text response after publishing; the user can inspect the source through the artifact source viewer.
+- Do not duplicate the published visual content in text. After publishing, provide only a concise note with assumptions, dimensions, material/print orientation advice, and any support/tolerance caveats.
diff --git a/navi/tools/model_3d.py b/navi/tools/model_3d.py
index e61a2cf..913c211 100644
--- a/navi/tools/model_3d.py
+++ b/navi/tools/model_3d.py
@@ -9,7 +9,10 @@
 import shutil
 from pathlib import Path
 
-from .base import Tool, ToolResult
+from navi.config import settings
+from navi.session_files import session_dir
+
+from .base import Tool, ToolResult, current_session_id
 
 
 class Model3DTool(Tool):
@@ -21,6 +24,9 @@
         "1. Write your .scad script with the filesystem tool.\n"
         "2. Call model_3d with the scad_path and desired output_path.\n"
         "3. The resulting STL is saved to output_path.\n\n"
+        "Session files rule: if you use session_files/<session_id>/..., use the exact current "
+        "session directory from context or tool output. Do not reconstruct or retype session IDs. "
+        "Simple filenames without directories are resolved inside the current session directory.\n\n"
         "Use content_publish on the STL to show the user an interactive 3D viewer."
     )
     parameters = {
@@ -45,15 +51,16 @@
     }
 
     async def execute(self, params: dict) -> ToolResult:
-        if not shutil.which("openscad"):
-            return ToolResult(
-                success=False,
-                output="OpenSCAD is not installed on this system.",
-                error="openscad_not_found",
-            )
+        session_id = current_session_id.get()
+        scad_path = self._resolve_model_path(params["scad_path"], session_id)
+        output_path = self._resolve_model_path(params["output_path"], session_id)
 
-        scad_path = Path(params["scad_path"]).expanduser().resolve()
-        output_path = Path(params["output_path"]).expanduser().resolve()
+        session_error = self._validate_current_session_path(scad_path, "scad_path", session_id)
+        if session_error:
+            return session_error
+        session_error = self._validate_current_session_path(output_path, "output_path", session_id)
+        if session_error:
+            return session_error
 
         if not scad_path.exists():
             return ToolResult(
@@ -68,6 +75,13 @@
                 error="not_a_file",
             )
 
+        if not shutil.which("openscad"):
+            return ToolResult(
+                success=False,
+                output="OpenSCAD is not installed on this system.",
+                error="openscad_not_found",
+            )
+
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
         proc = await asyncio.create_subprocess_exec(
@@ -105,3 +119,34 @@
             ),
             metadata={"output_path": str(output_path), "size_kb": round(size_kb, 1)},
         )
+
+    @staticmethod
+    def _resolve_model_path(raw_path: str, session_id: str | None) -> Path:
+        path = Path(raw_path).expanduser()
+        if session_id and not path.is_absolute() and len(path.parts) == 1:
+            return (session_dir(session_id) / path).resolve()
+        return path.resolve()
+
+    @staticmethod
+    def _validate_current_session_path(
+        path: Path,
+        param_name: str,
+        session_id: str | None,
+    ) -> ToolResult | None:
+        if not session_id:
+            return None
+
+        session_root = Path(settings.session_files_dir).resolve()
+        current_dir = session_dir(session_id).resolve()
+        if path.is_relative_to(session_root) and not path.is_relative_to(current_dir):
+            return ToolResult(
+                success=False,
+                output=(
+                    f"{param_name} points to a different session directory: {path}\n"
+                    f"Current session directory is: {current_dir}\n"
+                    "Use the exact current session directory. Do not manually reconstruct "
+                    "or retype session IDs."
+                ),
+                error="wrong_session_dir",
+            )
+        return None
diff --git a/navi/tools/render_3d.py b/navi/tools/render_3d.py
index 968ac79..69cfc33 100644
--- a/navi/tools/render_3d.py
+++ b/navi/tools/render_3d.py
@@ -35,7 +35,8 @@
         "1. Generate the STL with model_3d.\n"
         "2. Call render_3d with the STL path and desired views.\n"
         "3. PNG files are saved next to the STL with view suffixes.\n"
-        "4. Use content_publish on each PNG to show the user the render.\n\n"
+        "4. Inspect PNG previews with image_view before publishing the final 3D model. "
+        "PNG previews are usually internal QA artifacts, not user-facing deliverables.\n\n"
         "Available views: front, back, top, bottom, left, right, iso."
     )
     parameters = {