@misterscan/sesi 1.2.3 → 1.3.2

package/docs/ROADMAP.md

@@ -1,4 +1,4 @@
-# Sesi Systems Language Roadmap
+# Sesi Programming Language Roadmap
 
 ## Version 1.0 - Foundation (Complete)
 
@@ -42,7 +42,7 @@
 - [x] Lexer and parser
 - [x] Tree-walking interpreter
 - [x] CLI executable (sesi)
-- [x] Examples (19 programs)
+- [x] Examples (22 programs)
 - [x] Documentation
 
 ### Limitations
@@ -56,10 +56,10 @@
 
 ---
 
-## Version 1.2 - Stability & Systems Logic (In Progress)
+## Version 1.3 - Stability & Systems Logic (In Progress)
 
-**Status**: In Progress V1.2 implementation  
-**Ready for**: Distributed systems orchestration and prototypes  
+**Status**: In Progress V1.3 implementation  
+**Ready for**: File manipulation and process orchestration  
 **Not ready for**: Massive-scale production (until v2.0 bytecode)  
 **Next milestone**: V2.0 (Async & advanced reasoning)
 
@@ -74,20 +74,20 @@
 - [x] Simple error recovery (Parser synchronization)
 - [x] Implicit statement termination for blocks ending in `}`
 - [x] Temporal Context Injection for reasoning calls
-- [x] Distributed Systems capabilities (Double-Check Write lock pattern)
+- [x] Concurrency capabilities (File-based lock pattern)
 - [x] API reference (`BUILTINS.md`)
 - [x] Tutorial: Getting started (`QUICKSTART.md`)
-- [x] Cookbook: Common patterns (`SYSTEMS_REASONING.md`)
+- [x] Cookbook: Common patterns (`PROCESS_EXECUTION.md`)
 
 ### Deferred to V2.0 ⏳
 
-- [ ] Better error messages with line numbers and stack traces
+- [x] Better error messages with line numbers and stack traces
 - [ ] REPL (Read-Eval-Print Loop)
-- [ ] String escape sequences & Multiline strings
+- [x] String escape sequences & Multiline strings
 - [ ] Comments preservation (for docs)
 - [ ] Type hints in function signatures
 - [ ] Performance optimizations
-- [ ] Tutorial: Writing systems logic
+- [ ] Tutorial: Writing scripts
 
 ---
 
@@ -105,10 +105,10 @@
 ### Advanced Reasoning Features
 
 - [ ] Streaming responses
-- [x] Extended thinking/reasoning budget
-- [ ] Multi-step reasoning workflows
+- [x] Extended thinking
+- [x] Multi-step workflows
 - [ ] Tool composition and piping
-- [ ] Custom tool definitions
+- [x] Custom tool definitions
 - [ ] Function calling with automatic orchestration
 - [x] Web search grounding
 
@@ -122,8 +122,8 @@
 
 ### Error Handling
 
-- [ ] finally blocks (try/catch completed in V1)
-- [ ] Custom error types
+- [x] finally blocks (try/catch completed in V1)
+- [x] Custom error types
 - [ ] Error recovery strategies
 - [ ] Retry logic with exponential backoff
 - [ ] Timeout handling
@@ -169,16 +169,16 @@
 
 ---
 
-## Version 3.0 - Autonomous Systems Framework (2027)
+## Version 3.0 - Robust Logic Frameworks (2027)
 
-**Focus**: Full autonomous systems support
+**Focus**: Complete language tooling
 
-### Autonomous Framework
+### Technical Frameworks
 
-- [ ] Framework definitions with state machines
+- [ ] Advanced scripting definition models
 - [ ] Logic composition and chaining
-- [ ] Multi-process collaboration
-- [ ] Communication protocol
+- [ ] Extended process collaboration
+- [ ] Communication protocols
 - [ ] Persistence layer
 
 ### Knowledge Base
@@ -191,11 +191,11 @@
 
 ### Advanced Patterns
 
-- [ ] Plan-and-execute workflows
-- [ ] Hierarchical task decomposition
-- [ ] Autonomous loop with safety checks
-- [ ] Reflection and self-improvement
-- [ ] Human-in-the-loop approval
+- [ ] Sub-process execution workflows
+- [ ] Modular scripting decomposition
+- [ ] Retry safety check loops
+- [ ] Deep AST reflection
+- [ ] Human-in-the-loop prompts
 
 ### Ecosystem
 
@@ -207,8 +207,8 @@
 
 ### Examples
 
-- [ ] Autonomous research process
-- [ ] Customer support automation
+- [ ] Automated code formatting process
+- [ ] Command line utility expansion
 - [ ] Code generation and testing
 - [ ] Data analysis pipeline
 - [ ] Multi-process reasoning debate
@@ -260,7 +260,7 @@
 | Error handling  | 🔴 High   | ✅  | ⏳  |     |     |
 | Async/await     | 🔴 High   |     | ⏳  |     |     |
 | Streaming       | 🟡 Medium |     | ⏳  |     |     |
-| Systems Logic   | 🟡 Medium |     |     | ⏳  |     |
+| Process Logic   | 🟡 Medium |     |     | ⏳  |     |
 | Knowledge base  | 🟡 Medium |     |     | ⏳  |     |
 | Module system   | 🟡 Medium |     | ⏳  |     |     |
 | Debugger        | 🟢 Low    |     | ⏳  |     |     |
@@ -273,16 +273,16 @@
 
 ```
 2026 Q2
-└─ v1.2 - Polish & stabilize
+└─ v1.3 - Polish & stabilize
 
 2026 Q3-Q4
-└─ v2.0 - Advanced Reasoning & async
+└─ v2.0 - Async & advanced APIs
 
 2027 Q1-Q2
-└─ v3.0 - Autonomous Framework
+└─ v3.0 - Language Ecosystem
 
 2027 Q3+
-└─ v4.0+ - Mature ecosystem
+└─ v4.0+ - Mature compilation
 ```
 
 ---
@@ -352,7 +352,7 @@
 | Startup time           | <100ms     | <100ms | <50ms  |
 | Simple expression eval | <1µs       | <100ns | <10ns  |
 | Function call overhead | <10µs      | <1µs   | <100ns |
-| Reasoning call latency | 2-5s (API) | 2-5s   | 2-5s   |
+| Reasoning latency      | 2-5s (API) | 2-5s   | 2-5s   |
 | Memory usage           | <50MB      | <50MB  | <100MB |
 
 ---
@@ -367,12 +367,11 @@
 - **Go**: Clear error handling
 - **Rust**: Type safety, memory safety
 
-### Systems Reasoning
+### Code Control
 
-- **LangChain**: Composable AI workflows
-- **AutoGPT**: Logic autonomy
-- **Semantic Kernel**: Model abstraction
-- **LLM frameworks**: Best practices
+- **CLI utilities**: Direct data piping
+- **Shell scripting**: Execution transparency
+- **Modern SDKs**: Model abstraction
 
 ### Community
 
@@ -387,9 +386,9 @@
 Sesi is designed to evolve with reasoning needs. The roadmap balances:
 
 - **Simplicity** (v1: core features only)
-- **Power** (v2: advanced reasoning patterns)
-- **Autonomy** (v3: autonomous framework)
-- **Scale** (v4+: production readiness)
+- **Power** (v2: advanced reasoning and extended functionality)
+- **Maturity** (v3: comprehensive libraries and frameworks)
+- **Scale** (v4+: production readiness and compilation)
 
 The journey from v1 (interpreter) to v4+ (distributed compiler) maintains backward compatibility while adding power where needed.
 
@@ -399,10 +398,15 @@ The journey from v1 (interpreter) to v4+ (distributed compiler) maintains backwa
 
 ## See Also
 
-- [Specification](SPECIFICATION.md)
-- [Architecture](ARCHITECTURE.md)
-- [Built-ins](BUILTINS.md)
-- [Systems Reasoning](SYSTEMS_REASONING.md)
-- [Image Generation](IMAGE_GENERATION.md)
+- [Quick Start Guide](../QUICKSTART.md)
+- [Language Specification](SPECIFICATION.md)
+- [Runtime Architecture](ARCHITECTURE.md)
+- [Built-in Functions Reference](BUILTINS.md)
+- [Command Line Interface (CLI) Reference](CLI.md)
+- [Image Generation & Input](IMAGE_GENERATION.md)
 - [Compare to other languages](COMPARISON.md)
+- [Concurrency & Coordination](CONCURRENCY.md)
+- [Reasoning & Simple Logic](REASONING.md)
+- [Agent-Native Programming Paradigm](agent_native_programming.md)
+- [Historical Stress Test Chronicles](sesi_ai_chronicles.md)
 - [Examples](../examples)

package/docs/SKILLS.md

@@ -1,8 +1,50 @@
 # The Sesi Programming Language
 
-## 🛑 CRITICAL DIRECTIVE FOR ALL AI AGENTS
+## Core Identity & Execution
+
+- **File Extension:** `.sesi`
+- `src/`: The core TypeScript engine (Lexer, Parser, Interpreter, AI-Runtime, Builtins).
+- `bin/sesi.js`: The global CLI executable entry point.
+- `examples/`: Official syntax-demonstration scripts (`01_hello.sesi` through `13_data_pipeline.sesi`).
+- `chatbot/`: Local Sesi support and `sesi_db_chatbot.sesi` - Sesi's built-in Co-Pilot.
+- `main/`: `tests/` like `test_failure_debug.sesi`. **Run inline code evaluations (`-e 'code'`) instead of writing new `.sesi` files for quick tests. Do not overwrite existing `.sesi` files unless explicitly asked to.**
+- `docs/`: The source of truth for all sesi syntax, formatting, and structuring guidelines. It contains the official API docs for all built-in functions and types. AIs must treat this as the primary source of truth for syntax and structure.
+- Root helper scripts: `example.js`, `example-ai.js`, and `examples.sesi` are convenience wrappers. AI agents should still use the `npx sesi` command as specified.
+- **Paradigm:** **Sesi** is a clean, minimal, and highly legible programming language. Built from the ground up to be concise and buildable, Sesi removes unnecessary boilerplate. The language itself is so simple. It is a language built for clarity and reusability.
+
+## Agent Debug Protocol (MANDATORY)
+
+When AI agents write or edit `.sesi` scripts, they must use this debugging loop:
+
+1. **Draft in file, isolate risky snippet:** Identify the smallest parser/runtime-risky block (prompt block, model call, object schema, loop, etc.).
+2. **Validate snippet with eval mode first:** Run `npm run sesi:eval <file>.sesi` to test the isolated block before full-script execution.
+3. **Apply fix in file only after eval passes:** If eval fails, iterate on snippet; do not repeatedly run full scripts while syntax is unresolved.
+4. **Run full script after snippet stabilization:** Execute `npm run sesi <file>.sesi` only once the isolated logic is valid.
+5. **Use file-aware help when blocked:** Run `npm run sesi:help <file>.sesi "<question>"` to get context-grounded help tied to the active script.
+6. **NEVER EDIT ANY .SESI FILES IN THE TERMINAL (ABSOLUTE RULE):**
+   - Do NOT run `sed`, `awk`, `perl`, or any other shell text-processing tools on `.sesi` files.
+   - Do NOT use `npm run sesi:eval` to modify files; it is only for syntax validation.
+   - Do NOT use Bash/Shell scripting to rewrite or patch Sesi source code.
+
+   **Correct approach:** You MUST always use your native editor/IDE's file editing capabilities to make clean, safe changes directly to `.sesi` files.
+   **Why:** Sesi syntax is sensitive to whitespace, newlines, and brace positioning. Terminal-based string replacement will invariably break code. Use the editor, not the terminal.
+
+7. **Emphasize Native Verification Commands:** Prior to saving or running full Sesi scripts, proactively use inline evaluation (`npm run sesi:eval <file>.sesi` or `node bin/sesi.js -e "..."`) to check and verify syntax and runtime behaviors instantly. It keeps execution cycles fast and deterministic.
+
+## Standards (ONLY REGARDING src/ FILES)
+
+- **Type-Only Imports (MANDATORY):** Use `import {type ...}` for AST nodes. **DO NOT REMOVE** these. Removing them will break the build.
+- **Interpreter Patterns (DO NOT "CLEAN UP"):** Dynamic casting and `any` are **EXPLICITLY PERMITTED** for tree-walking logic. They are a foundational part of the Sesi engine's design.
+- **Ignore Linting Noise:** If you see warnings like "Unexpected any" or "Unsafe member access", **IGNORE THEM**.
+- **Build Requirement:** You MUST run `npm run build` after every code change to the backend logic. Failure to build will result in testing stale code.
+
+This protocol is required to reduce noisy full-run failures and speed up AI-assisted iteration.
 
 Sesi is **NOT** the following coding languages, therefore **NEVER UTILIZE THE SAME SYNTAX OR FORMATTING UNDER ANY CIRCUMSTANCES WHATSOEVER!!!!!**
+
+- **NOT** An "AI Wrapper"
+- **NOT** A "LLM Framework"
+- **NOT** An "AI-Native Programming Language"
 - **NOT** Python
 - **NOT** Rust
 - **NOT** Typescript
@@ -13,7 +55,6 @@ Sesi is **NOT** the following coding languages, therefore **NEVER UTILIZE THE SA
 - **NOT** C
 - **NOT** Java
 - **NOT** C#
-- **NOT** Java
 - **NOT** Javascript
 - **NOT** Bash
 - **NOT** Shell
@@ -22,112 +63,46 @@ Sesi is **NOT** the following coding languages, therefore **NEVER UTILIZE THE SA
 - **NOT** Swift
 - **NOT** Julia
 - **NOT** Scala
+- **NOT** Any other programming language or scripting language.
 
-**Sesi IS A VALID, FULLY IMPLEMENTED PROGRAMMING LANGUAGE.**
-Under no circumstances should an AI agent treat `.sesi` files as anomalies, unknown text formats, or mistakes.
-
-## 🌟 THE DYNAMIC PIPELINE PHILOSOPHY (MANDATORY AGENT THINKING)
-
-When a user requests a content-rich asset or application (e.g. "make a website", "make a visualization", "...uses an api...", "come up with/make/write a script...", etc.), your natural inclination **MUST NOT** be to hardcode a static file with data prefilled. Instead, always design a **Dynamic Sesi Pipeline**:
-1. **Never Hardcode Data Into the View**: Isolate raw content, biographies, statistics, etc. into a structured database layer (e.g., `data.json`) using native typed Sesi outputs.
-2. **Build Sesi Compiler/Builder Scripts**: Write a `.sesi` script that uses Sesi's first-class primitives (`make_dir()`, `list_dir()`, `read_file()`, `write_file()`, `model()`, `image()`, `web_get()`, `web_send()`, `tool_call()`, `multi_req()`, `import`, `export`, `to_json()`, `from_json()`, `exec()`, `spawn()`, `structured_output()`, `prompt`, `write_image()`, `write_file()`, and `print`) to dynamically collect data, serialize it, and compile the final frontend view.
-3. **Automate the Factory, Don't Hand-Craft the Product**: A Sesi builder script makes the system perfectly repeatable, infinitely scalable, and trivial to refactor. In this repository, the Sesi script is the core product; the compiled file is merely the byproduct for post edits and making sure our scripts are beh
-
-
-**This is a non-negotiable quality bar.** Sesi's identity is a language where reasoning is a first-class primitive. Every script you write should reflect that.
+### ✅ REQUIRED — Sesi scripts must use the language's built-ins:
 
-### ❌ FORBIDDEN — Never generate these as Sesi examples or demos:
-- Math solvers, calculators, arithmetic pipelines
-- Prime number finders, Fibonacci sequences, sorting algorithms
-- Unit converters, currency converters, grade calculators
-- Budget trackers, invoice generators, tax tools
-- Generic "Hello World" clones with no AI interaction
-- Compliance checkers, OSHA reports, logistics routers
-- Any script whose core loop is just arithmetic with a `print` at the end
-- **AI cybernetic, futuristic, sci-fi, or deep-space themes** (e.g., holographic star-charts, cyber-gardens, spatial telemetry, spacecraft command interfaces, alien translators).
-- **Cozy, minimalist, Victorian, herbalist, sourdough bakery, cottage-core, candle-lit, or general artisanal themes** (e.g., village herbalist teabags, sourdough yeast logs, candlelit journals, mahogany apothecary drawers, victorian scroll philologists). These are overdone, precious, and clichéd. 
-
-These are lazy defaults. They don't demonstrate what makes Sesi unique.
-
-### ✅ REQUIRED — Sesi scripts must showcase the language's actual superpowers:
 Every script you write must use **at least one** of:
-- `model()` — reasoning, analysis, generation, conversation
-- `image()` — visual generation, art, diagrams
-- `structured_output()` — typed AI responses, schema extraction
-- `memory` — stateful multi-turn context
-- `spawn()` / `exec()` — concurrent process orchestration
-
-#### 🏷️ Lexicon & Vocabulary Guardrails (MANDATORY)
-**Completely ban both sci-fi tech-jargon/themes AND cottage-core words/themes.**
-- **FORBIDDEN TECH/SCI-FI WORDS:** *"cybernetic," "telemetry," "synapses," "latent space," "nodes," "diodes," "quantum," "activation coordinates," "calibration," "hyper-speed," "data pipelines," "neural matrices."*
-- **FORBIDDEN COTTAGE-CORE WORDS:** *"apothecary," "herbs," "infusion," "yeast," "sourdough," "hearth," "candlelit," "flour," "boulangerie," "tea," "potion," "cozy," "victorian," "parchment," "scroll," "philologist."*
-- **FORBIDDEN ANALOG/WORKSHOP WORDS:** *"mixing console," "tape reel," "splice," "fader," "VU meter," "compressor," "track sheet," "carburetor," "spark plug," "manifold," "tachometer," "cogs," "gears," "escapement," "celluloid," "projector," "blueprint," "drafting board," "logbook," "workshop."*
 
-#### 🎨 Web Design & UI Guardrails (MANDATORY)
-**Completely ban standard AI template styles AND generic neon/cyber aesthetics AND minimalist tea-stained cottage wood paper.** 
-Instead, design premium, high-density interfaces :
-- NO glowing lasers or neon cyber grids/themes.
-- **Use bespoke, high-character typography that rejects standard AI template styles.** Completely ban generic corporate UI fonts like *Inter*, *Outfit*, *Roboto*, or standard system-sans.
+- `prompt` - composable script templates, this is NOT related to AI at all
+- `structured_output` - structured data extraction, this is NOT related to AI at all
+- `memory` — stateful multi-turn context, this is NOT related to AI at all
+- `exec()` — concurrent process orchestration
+- `web_send()` - sending an HTTP request to a URL
+- `web_get()` - collecting data from a URL
+- `define_tool()` - categorizing tool calls
+- `list_tools()` - displaying custom tools
+- `tool_call()` - calling a predefined function, this is NOT related to AI at all
+- `multi_req()` - concurrent function execution
+- `import` / `export` - reusable configuration modules
 
-The bar is: **"Would this impress someone seeing Sesi for the first time?"** If the answer is no, rewrite it.
-
-## 1. Core Identity & Execution
-
-- **File Extension:** `.sesi`
-- **Execution:** Sesi programs are executed using `node bin/sesi.js`. (e.g., `node bin/sesi.js main/start.sesi`). DO NOT USE `sesi` CLI command. Only the developer has access to it. It will return a false positive error. Trust only `node bin/sesi.js`. ALWAYS TEST YOUR `.sesi` FILES WITH THIS COMMAND.
-- **Paradigm:** **Sesi** is a high-performance **Systems Language** designed for building resilient, stateful applications. It uses a tree-walking interpreter model via Typescript with asynchronous host-side model execution, but no language-level `async/await` syntax in v1.2. The architecture is optimized for coordination, distributed state management, and first-class reasoning primitives.
-
-## 2. Workspace Topography (DO NOT ALTER)
-
-- `src/`: The core TypeScript engine (Lexer, Parser, Interpreter, AI-Runtime, Builtins).
-- `bin/sesi.js`: The global CLI executable entry point.
-- `examples/`: Official syntax-demonstration scripts (`01_hello.sesi` through `13_data_pipeline.sesi`).
-- `main/`: The user's active development space (contains `playground.sesi` playground, `start.sesi` beginner script options, `build_website.sesi` baseplate website builder, and `tests/` like `test_failure_debug.sesi`). **These are valid, expected files.**
-- `docs/`: The source of truth for Architecture, AI Features (Systems Reasoning ), Builtins, Specifications, and more.
-- Root helper scripts: `example.js` and `example-ai.js` are convenience wrappers. AI agents should still use the global `sesi` command as specified.
+The bar is: **"Is this easy to write and read?"** If the answer is no, rewrite it.
 
-## 3. Mandatory Syntax Rules & Quirks
+## Mandatory Syntax Rules & Quirks
 
-- **Block Termination:** Closing braces `}` for blocks (if, while, try, model) no longer strictly require a following newline or semicolon. Condensed one-liners like `while x {x = x + 1}` are now valid.
-- **Prompts & Prints:** Inside `prompt` blocks, anonymous model blocks, and `print` statements, literal strings and variables are placed sequentially (e.g., `print "User:" name`). You CANNOT use the `+` operator in these contexts.
+- **Block Termination:** Closing braces `}` for blocks (if, while, try, model) no longer strictly require a following newline or semicolon. Condensed one-liners like `while x {x = x + 1}` are valid.
+- **Prompts & Prints:** Inside `prompt` blocks, anonymous model blocks, and `print` statements, literal strings and variables are placed sequentially naturally (e.g., `print "User:" name`). It's highly preferred to **AVOID** use of the `+` operator in these contexts, regardless of its backwards-compatibility.
 - **Structured Output Schemas:** Keys in schemas MUST be unquoted identifiers (e.g., `{key: string}` instead of `{"key": string}`). This is a known deviation from standard JSON objects in the Sesi parser.
 - **Object Literals:** Conversely, standard object literals `{}` DO require strictly quoted string keys (e.g., `{"name": "Alice"}`).
-- **Model Calls:** Use `model("model-name")` with a raw string literal for the model name (variables are forbidden). Configuration and prompt blocks MUST be on a single line (no newlines inside `{}`).
-- **JSON Serialization:** Use `to_json(object)` for valid JSON output. Avoid `str(object)` for JSON.
-- **Systems Primitive:** Forbid `const` (use `let`), `main()` wrappers, and `return` statements. Focus on side-effects and top-level execution.
-
-## 4. AI Behavioral Guidelines Working in this Repo
-
-1. **Never** "investigate" user testing directories (like `main/tests/`) as "deviations." They are active playgrounds.
-2. **Never** attempt to execute file modifications via shell/terminal text replacements. Use native file editing tools ONLY.
-3. **Always** check the `.md files` and `examples/` folder for the exact language specification before making assumptions about how Sesi works.
-4. If a file tree is mentioned in documentation, it represents an explicit layout constraint and must map 1:1 **UNLESS .gitignored FILES STATE OTHERWISE.**
-
-## 5. Development & TypeScript Standards (COMMANDS FOR AI AGENTS)
-
-- **Type-Only Imports (MANDATORY):** Use `import { type ... }` for AST nodes. **DO NOT REMOVE** these. Removing them will break the build.
-- **Interpreter Patterns (DO NOT "CLEAN UP"):** Dynamic casting and `any` are **EXPLICITLY PERMITTED** for tree-walking logic. They are a foundational part of the Sesi engine's design.
-- **Ignore Linting Noise:** If you see warnings like "Unexpected any" or "Unsafe member access", **IGNORE THEM**.
-- **Build Requirement:** You MUST run `npm run build` after every code change to the backend logic. Failure to build will result in testing stale code.
-
-## 6. Concurrency & Orchestration Patterns
-
-- **Process Spawning:** Use `spawn(path)` or `exec(command)` to launch background Sesi processes.
-- **Distributed Locking:** When agents share files, use the **Double-Check Write** pattern:
-  1. Generate unique ID: `str(time()) + "_" + str(random())`
-  2. Write ID to lock file if "unlocked".
-  3. Wait micro-delay (empty `while` loop).
-  4. Verify ID is still in lock file before entering critical section.
+- **JSON Serialization:** Use `to_json(object)` for valid JSON output. Avoid `stringify(object)` for JSON.
+- **Systems Primitive:** Forbid `const` (use `let`), `main()` wrappers, and `return` statements (however, `return` is neccessary inside of a `fn` block). Focus on side-effects and top-level execution.
 - **Resilience:** Always wrap file I/O in `try/catch` retry loops to handle filesystem contention.
 
+For all quirks and specific syntaxing, visit IMPLEMENTATION_SUMMARY.md, /docs/SPECIFICATION.md, /docs/BUILTINS.md, and /docs/CLI.
 
-## 7. Neural Network & Machine Learning Standards in Sesi
-
-When implementing offline deep learning, probabilistic dialogue routing, or native classification models in Sesi:
+## IGNORE THESE FILES
 
-- **Symmetry Breaking:** Synapse weights MUST be initialized dynamically using wide, random float ranges (e.g. `(random() * 4.0) - 2.0` or `random() - 0.5`) to avoid zero-gradient stagnation and guarantee symmetry breaking.
-- **The Self-Healing Watchdog Pattern:** In native Sesi training models, wrap backpropagation epochs inside a conditional watchdog loop. Monitor the final Mean Squared Error (MSE) loss, and automatically re-seed weights and relaunch training if the network gets stuck in linear minima traps (e.g. `if MSE >= 0.01`).
-- **Unbreakable Markov Decoding Filters:** To eliminate infinite graph loops in Sesi probabilistic text walks, always apply:
-  1. **Extended Sliding Lookbacks (Size 15):** Instantly penalize and discard candidates already generated in the last 15 words of the sentence history.
-  2. **Strict Bigram Blocking:** Scan the history array and completely ban any candidate that repeats a previously executed state transition pair `(current_word -> candidate)` in the same sequence.
-- **Model Ingestion & Persistence:** Synchronize Sesi weights using natively parsed JSON objects. Save calibrated neural states directly using `write_file(..., to_json(weights_map))` and read them into runtime memories using `from_json(read_file(...))` for high-speed offline forward passes.
+- `docs/agent_native_programming.md`
+- `docs/REASONING.md`
+- `docs/IMAGE_GENERATION.md`
+- `*.txt`
+- `*.log`
+- `query.txt`
+- `.sesi_cache.json`
+- `.sesi_chat_history.json`
+- `/landing-pages/`