@misterscan/sesi 1.2.2 → 1.3.0

package/docs/{SYSTEMS_REASONING.md → REASONING.md}

@@ -1,69 +1,12 @@
-# Systems Reasoning & Logic Guide
+# Reasoning & Simple Logic
 
 ## Overview
 
-Sesi is a **Systems Language** that treats reasoning as a first-class execution primitive. In this paradigm, AI is used to evaluate state, make logical decisions, and handle complex patterns within a systems-level architecture.
+In Sesi, Reasoning is used to evaluate state, make logical decisions, and handle complex patterns. This guide covers how to leverage Sesi's built-in Reasoning functions (`model`, `image` `prompt`, `structured_output`, `tool_call`) to build scripts for your designated needs.
 
-This guide covers how to leverage Sesi's systems-level constructs (`spawn`, `exec`, `try/catch`) alongside its reasoning primitives (`model`, `prompt`, `structured_output`) to build resilient, stateful applications.
+## 1. Prompting
 
-## 1. Concurrency & Systems Coordination
-
-The core of Sesi's power lies in its ability to manage distributed execution. Using the `spawn()` builtin, you can launch multiple concurrent Sesi processes that coordinate via shared state or the filesystem.
-
-A master script can launch concurrent processes and poll for their completion.
-
-```sesi
-spawn("atm_deposit.sesi")
-spawn("atm_withdraw.sesi")
-let finished = false
-while !finished {
-  try {
-    if read_file("bank/done_count.txt") == "2" {
-      finished = true
-    }
-  } catch (e) {
-    // Wait on I/O contention
-    let i = 0 while i < 1000 { i = i + 1 }
-  }
-}
-print "Swarm task completed."
-```
-
-### Coordination & Distributed Locking
-
-When multiple processes access shared resources, use Sesi's `try/catch`, `time()`, and `random()` builtins to implement mutual exclusion (locking) via the **Double-Check Write** pattern.
-
-```sesi
-let id = "With_" + str(time()) + "_" + str(random())
-let locked = true
-while locked {
-  let status = "error"
-  try {
-    status = read_file("bank/lock.txt")
-  } catch (e) {
-    status = "error"
-  }
-  if status == "unlocked" {
-    try {
-      write_file("bank/lock.txt", id)
-      let i = 0 while i < 500 { i = i + 1 }
-      if read_file("bank/lock.txt") == id {
-        locked = false
-      }
-    } catch (e) {
-      status = "error"
-    }
-  } else {
-    let j = 0 while j < 1000 { j = j + 1 }
-  }
-}
-```
-
----
-
-## 2. AI as a Reasoning Primitive
-
-In an orchestrated system, AI is used to make decisions that would be too complex for static logic.
+In Sesi, calling a reasoning model is as simple as defining a string and executing it.
 
 Prompts are **composable message templates** that evaluate to strings.
 
@@ -102,7 +45,7 @@ print translatePrompt(text, language)
 
 ## 2. Model Calls
 
-Call Gemini with a prompt and get back text.
+Call a Reasoning model with a prompt and get back text.
 
 ### Basic Model Call
 
@@ -127,8 +70,8 @@ print creative
 
 ```sesi
 // Fast model for simple tasks
-let text = " Coding with Reasoning systems language is fun!"
-let quick = model("gemini-3.1-flash-lite") {"Summarize this in one sentence:" text}
+let text = "Coding with Reasoning programming language is fun!"
+let quick = model("gemini-3.1-flash-lite") {"Summarize this in one sentence: " text}
 
 // Powerful model for complex reasoning
 let code = "def calculate_sum(n):
@@ -136,25 +79,25 @@ let code = "def calculate_sum(n):
     for i in range(1, n):
         total += i
     return total"
-let smart = model("gemini-3.1-pro-preview") {"Analyze this code for bugs:" code}
+let smart = model("gemini-3.1-pro-preview") {"Analyze this code for bugs: " code}
 
 // Efficient model for many calls
-let item = " Programming Languages"
-let cheap = model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify:" item}
+let item = "Programming Languages"
+let cheap = model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify: " item}
 
 print quick
 print smart
 print cheap
 ```
 
-### Available Models (v1.2)
+### Available Models (v1.3)
 
 - `gemini-2.5-flash` - Legacy, but supported. 1M tokens.
 - `gemini-2.5-pro` - Legacy, but supported. 1M tokens.
 - `gemini-2.5-flash-image` - Standard image model. (No `512` image size support for this model. Only `1K` is supported.)
-- `gemini-3-flash-preview` - Fast, balanced, legacy preview.
+- `gemini-3-flash-preview` - Fast, most balanced model for coding and minimal tasks.
 - `gemini-3.1-flash-lite` - Fastest, most cost-efficient.
-- `gemini-3.5-flash` - Standard GA Model. Fast, balanced, supports all native thinking effort levels (`minimal`, `low`, `medium`, `high`).
+- `gemini-3.5-flash` - Newest GA model. Balanced, but token hungry (USE WISELY) supports all native thinking effort levels (`minimal`, `low`, `medium`, `high`).
 - `gemini-3.1-pro-preview` - Most powerful reasoning model, doesn't support `minimal` thinking (falls back to `low`).
 - `gemini-3.1-flash-image-preview` - Cost efficient image generation model.
 - `gemini-3-pro-image-preview` - High quality image generation model. (No `512` image size support for this model.)
@@ -196,8 +139,7 @@ Get typed responses from Reasoning with field validation.
 ### Basic Structured Output
 
 ```sesi
-let analysis = structured_output({sentiment: string, confidence: number, summary: string})
-(model("gemini-3-flash-preview") {"Analyze sentiment of: " text "Return JSON with sentiment, confidence (0-1), and summary"})
+let analysis = structured_output({sentiment: string, confidence: number, summary: string})(model("gemini-3-flash-preview") {"Analyze sentiment of: " text "Return JSON with sentiment, confidence (0-1), and summary"})
 print analysis["sentiment"]    // "positive"
 print analysis["confidence"]   // 0.85
 print analysis["summary"]      // "..."
@@ -216,12 +158,12 @@ print bookInfo["title"]
 
 - Always include instructions for JSON format
 - Specify the exact schema in the prompt
-- Use "thinkingLevel": "low" for fast, consistent parsing
+- Use "thinkingLevel": "minimal" for fast, consistent parsing
 - Validate output structure in code
 
 ```sesi
 let listText = "eggs, milk, bread, cheese, fruit, vegetables"
-let output = structured_output({items: string})(model("gemini-3.5-flash") {thinkingLevel: "minimal"}{"Return JSON with items array containing: " listText})
+let output = structured_output({items: string})(model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Return JSON with items array containing: " listText})
 
 // Validate
 if type(output["items"]) == "array" {print "Got" str(len(output["items"])) "items"} // Got 6 items
@@ -236,7 +178,8 @@ Let Reasoning call functions in your program.
 ```sesi
 let city = "New York"
 fn getWeather(city: string) -> string
-{let weather = model("gemini-3.1-flash-lite"){"What is the weather like in " city} return weather}
+{let weather = model("gemini-3.1-flash-lite") {"What is the weather like in " city} 
+return weather}
 let result = getWeather(city)
 print result
 
@@ -289,11 +232,11 @@ print response2  // Has context from turn 1
 ```sesi
 memory conversation {"Chat history: "}
 fn chat(userMessage: string) -> string
-{let fullPrompt = conversation + "User:" + userMessage
+{let fullPrompt = conversation + "User: " + userMessage
 let response = model("gemini-3-flash-preview") {fullPrompt}
 
 // Append to memory
-conversation = conversation + "User:" + userMessage + "Assistant:" + response
+conversation = conversation + "User: " + userMessage + "Assistant: " + response
 return response}
 let msg = "What is the capital of France? "
 print "User:" msg
@@ -313,7 +256,7 @@ print "Updated Memory!"
 memory conversation {"User: Hello! Assistant: Hi there! User: How are you? Assistant: I'm great!"}
 fn summarizeMemory()
 {let oldConversation = conversation
-let summary = model("gemini-3.1-flash-lite") {"Summarize this conversation concisely:" oldConversation}
+let summary = model("gemini-3.1-flash-lite") {"Summarize this conversation concisely: " oldConversation}
 conversation = "Previous summary:" + summary + "Recent messages: " + oldConversation}
 print "Original Memory:" conversation
 summarizeMemory()
@@ -329,8 +272,7 @@ print conversation
 let categories = "fruit, vegetable, grain"
 let item = "banana"
 fn classify(item: string, categories: string) -> string
-{return model("gemini-3.5-flash") {thinkingLevel: "minimal"}
-{"Classify this item into one category. Categories: " categories " Item: " item " Return only the category name."}}
+{return model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify this item into one category. Categories: " categories " Item: " item " Return only the category name."}}
 print "Item: " item //banana
 print "Category: " classify(item, categories) //fruit
 ```
@@ -340,8 +282,7 @@ print "Category: " classify(item, categories) //fruit
 ```sesi
 let text = "Elon Musk is the CEO of Tesla and SpaceX."
 fn extractEntities(text: string) -> object
-{let result = structured_output({people: string, places: string, organizations: string})
-(model("gemini-3.5-flash") {thinkingLevel: "minimal"}{"Extract named entities from:" text})
+{let result = structured_output({people: string, places: string, organizations: string})(model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Extract named entities from: " text})
 print "Name(s) found: result"
 return result}
 print extractEntities(text)
@@ -354,9 +295,17 @@ print extractEntities(text)
 let text = "Hello, world!"
 let language = "Spanish"
 fn translate(text: string, language: string) -> string
-{return model("gemini-3-flash-preview") {"Translate to" language ":" text}}
-print "Translation:"
-print translate(text, language)
+{return model("gemini-3-flash-preview") {"Translate to " language ": " text}}
+print "Translation:" translate(text, language)
+```
+
+### Web Search Grounding
+
+Access real-time information by enabling the `search` shorthand configuration natively.
+
+```sesi
+let response = model("gemini-3.1-flash-lite") {search, max_tokens: 200} {"What is the weather in Tokyo right now?"}
+print response
 ```
 
 ### Image Generation
@@ -376,7 +325,7 @@ print "Image generated!"
 ```sesi
 let requirement = "Write a function that reverses a string."
 fn generateCode(requirement: string) -> string
-{return model("gemini-3.5-flash") {thinkingLevel: "low"} {"Generate JavaScript code for:" requirement "Only provide code, no explanation."}}
+{return model("gemini-3.5-flash") {thinkingLevel: "low"} {"Generate JavaScript code for: " requirement " Only provide code, no explanation."}}
 print "Code generation:"
 print generateCode(requirement)
 ```
@@ -386,8 +335,7 @@ print generateCode(requirement)
 ```sesi
 let text = "I love Sesi!"
 fn analyzeSentiment(text: string) -> object
-{return structured_output({sentiment: string, score: number, explanation: string})
-(model("gemini-3-flash-preview") {"Analyze sentiment of:" text})}
+{return structured_output({sentiment: string, score: number, explanation: string})(model("gemini-3-flash-preview") {"Analyze sentiment of: " text})}
 print "Sentiment analysis:"
 print analyzeSentiment(text)
 ```
@@ -396,11 +344,11 @@ print analyzeSentiment(text)
 
 Reasoning operations can fail. Handle gracefully.
 
-### Try/Catch (v1.2)
+### Try/Catch (v1.3)
 
 ```sesi
 try
-{let response = model("gemini-3-flash-preview") {"Analyze" text}
+{let response = model("gemini-3-flash-preview") {"Analyze " text}
 print response}
 catch (e) {print "Reasoning call failed"
 print e}
@@ -418,14 +366,13 @@ print e}
 let text = "Coding is evolving rapidly!"
 fn safeAnalyze(text: string) {
 try
-{let result = structured_output({sentiment: string, score: number})(model("gemini-3.1-flash-lite") {"Analyze sentiment and return JSON for:" text})
+{let result = structured_output({sentiment: string, score: number})(model("gemini-3.1-flash-lite") {"Analyze sentiment, score, and return JSON for: " text})
 if len(keys(result)) == 0 {print "Structured parsing failed"
 return null}
-return result}
-catch (e)
-{print e
+return result
+} catch (e) {print e
 return null}}
-print "Analysis Result: " safeAnalyze(text)
+print "Analysis Result:" safeAnalyze(text)
 ```
 
 ## 8. Performance Tips
@@ -435,11 +382,11 @@ print "Analysis Result: " safeAnalyze(text)
 ```sesi
 // Bad: Calls API 3 times
 for item in items
-{let analysis = model("gemini-3.1-flash-lite") {"Analyze:" item}}
+{let analysis = model("gemini-3.1-flash-lite") {"Analyze: " item}}
 print analysis
 
 // Better: Batch into one call (v2: parallel calls)
-let analyses = model("gemini-3.1-flash-lite") {"Analyze each:" join(items, " ")}
+let analyses = model("gemini-3.1-flash-lite") {"Analyze each: " join(items, " ")}
 print analyses
 ```
 
@@ -447,11 +394,11 @@ print analyses
 
 ```sesi
 // Simple classification → flash-lite
-let category = model("gemini-3.1-flash-lite") {"Classify:" item}
+let category = model("gemini-3.1-flash-lite") {"Classify: " item}
 print category
 
 // Complex reasoning → pro
-let analysis = model("gemini-3.1-pro-preview") {"Deep analysis of:" complex_problem}
+let analysis = model("gemini-3.1-pro-preview") {"Deep analysis of: " complex_problem}
 print analysis
 ```
 
@@ -460,7 +407,7 @@ print analysis
 ```sesi
 // Long prompts waste tokens
 // Bad:
-let response = model("gemini-3-flash-preview") {"Here is a very long system prompt that repeats itself... " "Please analyze the following text very carefully..." text}
+let response = model("gemini-3-flash-preview") {"Here is a very long system prompt that repeats itself... Please analyze the following text very carefully..." text}
 print response
 
 // Better:
@@ -472,14 +419,17 @@ print response
 
 ```sesi
 // Bad: Same analysis done multiple times
-for person in people {let assessment = model("gemini-3.1-flash-lite") {"Assess based on criteria A, B, C: "  person}}
+for person in people 
+{let assessment = model("gemini-3.1-flash-lite") {"Assess based on criteria A, B, C: "  person}}
 print assessment
 
 
 // Better: Reuse cached prompt
 let people = ["Elon Musk", "Bill Gates", "Steve Jobs"]
-fn assessPerson(person: string) -> string {return model("gemini-3.1-flash-lite") {"Assess on A, B, C: "  person}}
-for person in people {print assessPerson(person)}
+fn assessPerson(person: string) -> string
+{return model("gemini-3.1-flash-lite") {"Assess on A, B, C: "  person}}
+for person in people 
+{print assessPerson(person)}
 ```
 
 ## 9. Token Counting (Future)
@@ -494,7 +444,7 @@ print "This costs " str(tokens * PRICE_PER_TOKEN) " cents"
 // Plan memory size
 let remaining = MAX_TOKENS - count_tokens(memory, model)
 if remaining < 500 {summarizeMemory()}
-print "Memory size: " count_tokens(memory, model)
+print "Memory size:" count_tokens(memory, model)
 ```
 
 ## 10. Advanced: Custom Reasoning Workflows
@@ -507,20 +457,21 @@ fn smartSummarize(text: string) -> string
 
 // Chain multiple Reasoning operations
 // Step 1: Extract key points
-{let keyPoints = model("gemini-3.1-pro-preview") {thinkingLevel: "low"} {"Extract 5 key points from:" text}
+{let keyPoints = model("gemini-3.1-pro-preview") {thinkingLevel: "low"} {"Extract 5 key points from: " text}
 
 // Step 2: Analyze topics
-let topics = structured_output({ topics: string })(model("gemini-3.5-flash") {thinkingLevel: "low"} {"Identify topics in:" keyPoints})
+let topics = structured_output({topics: string})(model("gemini-3.5-flash") {thinkingLevel: "low"} {"Identify topics in: " keyPoints})
 
 // Step 3: Generate summary
-let summary = model("gemini-3-flash-preview") {"Summarize with topics " topics ":" keyPoints} return summary}
+let summary = model("gemini-3-flash-preview") {"Summarize with topics " topics ": " keyPoints} 
+return summary}
 print "Summary:" smartSummarize(text)
 ```
 
 ### Reasoning Pattern
 
 ```sesi
-let analysis = model("gemini-3.5-flash") {thinkingLevel: "medium", max_tokens: 8192} {"Reason carefully about:" problem}
+let analysis = model("gemini-3.5-flash") {thinkingLevel: "medium", max_tokens: 8192} {"Reason carefully about: " problem}
 print analysis
 ```
 
@@ -529,12 +480,59 @@ print analysis
 ```sesi
 let text = "banana"
 fn classifyWithExamples(text: string) -> string
-{return model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify as A, B, or C" "Examples:" "'apple' -> A" "'dog' -> B" "'happy' -> C" "Classify: " text}}
+{return model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify as A, B, or C. Examples: 'apple' -> A , 'dog' -> B , 'happy' -> C. Classify: " text}}
 print "Classification:" classifyWithExamples(text)
 ```
 
 ---
 
+## 11. Built-in Tools
+
+### Built-in Workflows
+
+Sesi provides a native `workflow` function to easily chain reasoning steps:
+
+```sesi
+let steps = [
+  {"prompt": "Summarize:"},
+  {"prompt": "Critique:"},
+  {"prompt": "Finalize:"}
+]
+let result = workflow(steps, "Design a landing page brief")
+print result["final"]
+```
+
+### Model Aliases
+
+You can define custom names for models using `set_alias`:
+
+```sesi
+set_alias("fast", "gemini-3.1-flash-lite")
+let answer = model("fast") {"Summarize this paragraph."}
+print answer
+```
+
+### Custom Tools
+
+Sesi allows you to define custom tools that can be invoked during reasoning operations.
+
+```sesi
+fn get_weather(city: string, conditions: string) -> string 
+{return "It is currently " + conditions + " in " + city}
+// Register the tool
+define_tool("weather", get_weather, "Get weather for a city")
+
+// List available tools
+print list_tools()
+
+// Call the tool
+let weatherData = structured_output({city: string, conditions: string})(model("gemini-3.1-flash-lite") {search} {"What is the weather like in London? Return JSON with the exact 'conditions' and 'city' name."})
+let result = tool_call(weather)(weatherData["city"], weatherData["conditions"])
+print result
+```
+
+---
+
 ## See Also
 
 - [Compare to other languages](COMPARISON.md)

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 (13 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,11 +105,12 @@
 ### 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
 
 ### Memory System
 
@@ -121,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
@@ -160,7 +161,7 @@
 
 ### Examples
 
-- [ ] Web scraper with reasoning analysis
+- [x] Web scraper with reasoning analysis
 - [ ] Document processor (PDF, DOCX)
 - [ ] Chatbot with memory
 - [ ] Data pipeline with reasoning
@@ -168,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
@@ -190,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
 
@@ -206,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
@@ -259,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    |     | ⏳  |     |     |
@@ -272,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
 ```
 
 ---
@@ -351,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 |
 
 ---
@@ -366,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
 
@@ -386,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.
 
@@ -401,7 +401,7 @@ The journey from v1 (interpreter) to v4+ (distributed compiler) maintains backwa
 - [Specification](SPECIFICATION.md)
 - [Architecture](ARCHITECTURE.md)
 - [Built-ins](BUILTINS.md)
-- [Systems Reasoning](SYSTEMS_REASONING.md)
+- [Process Execution](PROCESS_EXECUTION.md)
 - [Image Generation](IMAGE_GENERATION.md)
 - [Compare to other languages](COMPARISON.md)
 - [Examples](../examples)