scriptorium 0.0.3 → 0.7.2

data/assets/README.md

@@ -0,0 +1,44 @@
+# Scriptorium Gem Assets
+
+This directory contains assets that are bundled with the Scriptorium gem.
+
+## Directory Structure
+
+```
+assets/
+├── icons/           # UI icons and interface elements
+│   ├── back-arrow.png
+│   ├── social/      # Social media icons
+│   │   ├── twitter.png
+│   │   ├── facebook.png
+│   │   └── reddit.png
+│   └── ui/          # UI interface icons
+│       ├── menu.png
+│       └── close.png
+├── samples/         # Sample images for demos
+│   ├── placeholder.jpg
+│   ├── banner.jpg
+│   └── avatar.png
+├── themes/          # Theme-specific assets
+│   └── standard/
+│       ├── logo.png
+│       └── favicon.ico
+└── README.md        # This file
+```
+
+## Usage
+
+These assets are automatically copied to the standard theme when a new repository is created. Users can:
+
+1. **Override** any gem asset by placing a file with the same name in their theme's `assets/` directory
+2. **Reference** gem assets using `$$asset[icons/back-arrow.png]` in templates
+3. **Copy** gem assets to their local assets using the `copy_gem_asset_to_user` helper
+
+## Asset Search Priority
+
+1. Post assets (`posts/0001/assets/`)
+2. View assets (`views/myview/assets/`)
+3. **Theme assets** (`themes/standard/assets/`) ⭐ *NEW*
+4. Global assets (`assets/`)
+5. Library assets (`assets/library/`)
+6. Gem assets (`assets/`) - *lowest priority*

data/assets/icons/ui/foo

@@ -0,0 +1,10 @@
+cp icons.png left.png 
+cp icons.png right.png 
+cp icons.png up.png 
+cp icons.png down.png 
+cp icons.png home.png 
+cp icons.png back.png 
+cp icons.png next.png 
+cp icons.png start.png 
+cp icons.png end.png 
+cp icons.png copy.png

data/assets/samples/placeholder.svg

@@ -0,0 +1,9 @@
+<svg width="200" height="150" xmlns="http://www.w3.org/2000/svg">
+  <rect fill="#f8f9fa" stroke="#ddd" stroke-width="1" width="200" height="150" rx="4"/>
+  <text x="100" y="75" text-anchor="middle" fill="#666" font-family="Arial, sans-serif" font-size="14">
+    Placeholder Image
+  </text>
+  <text x="100" y="95" text-anchor="middle" fill="#999" font-family="Arial, sans-serif" font-size="12">
+    200x150
+  </text>
+</svg>

data/assets/themes/standard/favicon.svg

@@ -0,0 +1,6 @@
+<svg width="32" height="32" xmlns="http://www.w3.org/2000/svg">
+  <rect width="32" height="32" fill="#007bff" rx="4"/>
+  <text x="16" y="22" text-anchor="middle" fill="white" font-family="Arial, sans-serif" font-size="18" font-weight="bold">
+    S
+  </text>
+</svg>

data/bin/sblog

@@ -1,11 +1,90 @@
 #!/usr/bin/env ruby
 
-require 'scriptorium'
-require 'rubytext'
+require 'optparse'
+require 'fileutils'
 
-puts "sblog: Attempting .new"
+class ScriptoriumLauncher
+  def initialize
+    @script_dir = File.dirname(__FILE__)
+    @project_root = File.join(@script_dir, '..')
+    @tui_path = File.join(@project_root, 'ui', 'tui', 'bin', 'scriptorium')
+    @web_path = File.join(@project_root, 'ui', 'web', 'bin', 'scriptorium-web')
+  end
 
-$blog = Scriptorium.new
+  def run
+    command = ARGV.first
 
-puts
+    case command
+    when nil, 'tui'
+      launch_tui
+    when 'web'
+      launch_web(ARGV[1..-1])
+    when 'help', '--help', '-h'
+      show_help
+    else
+      puts "Unknown command: #{command}"
+      puts "Run 'sblog help' for usage information"
+      exit 1
+    end
+  end
+
+  private
+
+  def launch_tui
+    exec(@tui_path, *ARGV)
+  end
+
+  def launch_web(args)
+    if args.empty?
+      exec(@web_path, 'start')
+    else
+      exec(@web_path, *args)
+    end
+  end
+
+  def show_help
+          puts <<~HELP
+        Scriptorium - A command-line blogging system
+
+        FLAGS:
+          --test                    - Use test repository (scriptorium-TEST)
+                                      - Default: production repository (~/.scriptorium)
+
+        USAGE:
+          sblog                     # Launch TUI (default)
+          sblog --test              # Launch TUI in test mode
+          sblog tui                 # Launch TUI explicitly
+          sblog tui --test          # Launch TUI in test mode
+          sblog web                 # Launch web app
+          sblog web --test          # Launch web app in test mode
+          sblog web start           # Start web server
+          sblog web start --test    # Start web server in test mode
+          sblog web stop            # Stop web server
+          sblog web status          # Check web server status
+          sblog help                # Show this help
+
+      INTERFACES:
+        TUI (Text User Interface):
+          - Command-line interface
+          - Full-featured management
+          - Preferred for daily use
+          - Runs in terminal
+
+        Web:
+          - Browser-based interface
+          - Visual management tools
+          - Good for occasional use
+          - Runs in web browser
+
+      EXAMPLES:
+        sblog                   # Start TUI
+        sblog new post "Title"  # Create new post via TUI
+        sblog web start         # Start web server
+        sblog web               # Open web interface
+    HELP
+  end
+end
+
+# Run the launcher
+ScriptoriumLauncher.new.run
 

data/bin/scriptorium

@@ -0,0 +1 @@
+/Users/Hal/Dropbox/topx/git/scriptorium/ui/tui/bin/scriptorium

data/doc/README.txt

@@ -0,0 +1,6 @@
+Nothing really to see here yet.
+
+Planning documentation:
+- For project contributors
+- For developers in general
+- For users

data/doc/anti-amnesia/20250727-054000-scriptorium-overview.md

@@ -0,0 +1,94 @@
+# Scriptorium Overview
+
+## What is Scriptorium?
+- **Custom blogging system** - major rewrite of Runeblog
+- **Static site generator** for personal use, designed as if others would adopt it
+- **Multi-view architecture** - multiple separate blogs managed from single backend
+- **Shared content model** - posts and metadata can be shared across views
+- **Independent deployment** - each view can deploy to different servers/domains
+
+## Core Architecture
+- **API-first design** - Ruby methods (not web endpoints)
+- **File-based storage** - no database, uses directory hierarchy
+- **Library approach** - API defines all behavior, multiple UIs planned
+- **Flat file data** - all data stored locally, deployed as needed
+
+## Key Concepts
+- **Repository (repo)** - the main container
+- **View** - essentially a separate blog with its own look/feel
+- **Post** - blog article with date, title, blurb, body, images
+- **Theme** - immutable set of files copied to view for modification
+- **BannerSVG** - flexible banner system (recent addition, not core)
+
+## Development Philosophy
+- **User-centric** - designed for your specific needs first
+- **Convention over configuration** - sensible defaults
+- **Complexity abstraction** - hide unnecessary details
+- **Livetext integration** - custom tool for processing and generation
+- **CSS preferences** - inline CSS, minimal JavaScript
+- **Extensibility** - 90% common tasks should be trivial
+
+## Current State
+- **Core API complete** - repo/view/post creation, layout modification
+- **Testing robust** - 770+ unit test assertions
+- **No UI yet** - programmatic access only
+- **Bootstrap integration** - for widgets and navbar (navbar pending)
+- **Next priorities** - convenience module API, TUI, curses UI, new widgets
+
+## Technical Stack
+- **Ruby** - 25 years experience, favorite language
+- **No Rails** - not a web developer, no dynamic components
+- **Livetext** - custom processing tool with dot commands, includes, variables
+- **Bootstrap** - limited use for widgets and navbar
+
+---
+
+**USER:** 
+1. Scriptorium is a custom blogging system, a major rewrite of Runeblog. It is primarily for my own use, but I am creating it as if it would be adopted by others. It is a static site generator. Its primary distinguishing feature is that multiple "views" (actually separate blogs) can be managed from a single backend and repository. Each view may have its own look and feel and be deployed to different servers and different domains. Posts and possibly some global metadata can be shared among all of these as needed.
+
+2. I am creating an API (Ruby methods, not web endpoints). At present, that is the only way to create content-- programmatically. When the API is mature, multiple user interfaces will be created: at least a TUI, then a curses-style, then a web app running on localhost. (All data is locally stored and manipulated; it is deployed to a remote server as needed.) There is no database; data are stored in flat files in a directory hierarchy. Some high-level API operations are: create a repository (a repo); create a view; create a post; configure a view; create a post; deploy; and so on. A view is in essence a blog, as I said. All views share a common set of posts to draw from, and a post may be in only one view or in many. A post is a simple blog post or article that may have all the usual decoration: date; title; blurb or teaser; text body; images; and more. A "theme" is a set of files (immutable) that are copied to a view for modification and configuration. The config of a view may include view-specific metadata, choices of look-and-feel, layout of the front page, etc.
+
+3. I am expert in Ruby, having used it for nearly 25 years, and it is my favorite language. I do not know Rails, I am not a web developer, and this project has no real dynamic components. The API will define all possible behavior, so it could be considered a library; a user could in fact write his own UI. As I said, I have plans for at least three different UIs myself. BannerSVG was an interesting recent addition, but it is not as critical to the project as its line count might suggest. It is a flexible way of specifing a blog banner with a title and optional subtitle.
+
+4. Some of my priorities are: - This must be useful, easy, flexible, and intuitive FOR ME. (It is possible no one else will ever use it.) - I believe in "convention over configuration" as DHH said. - Other mantras are: Abstract away complexity; hide unnecessary detail; take reasonable defaults; balance the tradeoff between ease of use and feature richness; wrap things as needed to simplify them; etc. - I am using a tool of my own called Livetext; more details on that later. It is a tool for processing its input format and generating arbitrary output (usually HTML in this case) as well as side effects. It has "dot" commands; includes; raw copy of files, variables and functions (both predefined and user-defined); user-defined dot commands; and a rudimentary plugin system. - I avoid Javascript when I can, and like to "hide" CSS mostly (at a high level). In output, I prefer CSS inline rather than in files (usually). - I believe that extensibilty is good in general. I believe that the 90% most common tasks should become trivial; hard things should be easy, but some very advanced things may be impossible; as in, if you want to do this sort of esoteric or arcane task, this probably isn't your tool."
+
+
+**ASST:** 
+[See above content] 2025-07-30 16:30:00 - TUI Test Refactoring Learnings
+
+## TUI Test Refactoring Patterns
+
+### Helper Method Pattern
+- Extract test logic into helper methods that take `read, write` parameters
+- Keep PTY.spawn blocks clean and focused on setup/teardown
+- Helper methods contain all the `get_string` calls and `write.puts` commands
+
+### send_and_expect Helper
+- Combines common pattern: `write.puts input` + `get_string(read, pattern, description)`
+- Reduces code duplication and makes tests more readable
+- Accepts both strings and regex patterns for flexibility
+- Includes error handling for I/O errors when TUI terminates
+
+### String vs Regex Patterns
+- String patterns are more reliable than regex for TUI testing
+- Avoid escaping issues with brackets and special characters
+- Easier to debug and maintain
+- Use strings by default, regex only when needed
+
+### Error Handling for TUI Termination
+- TUI processes may terminate immediately after outputting expected text
+- Handle Errno::EIO gracefully in helper methods
+- Don't treat TUI termination as an error if expected output was found
+- Wrap PTY.spawn blocks in rescue blocks for cleanup
+
+### Test Structure Best Practices
+- Use `send_and_expect` for input/output pairs
+- Use `get_string` for waiting for output without sending input
+- Keep test methods focused on setup and calling helper methods
+- Helper methods contain the detailed test logic
+
+### Common Issues and Solutions
+- I/O errors when TUI terminates: Handle gracefully with rescue blocks
+- Pattern matching failures: Use strings instead of regex when possible
+- Leftover code from edits: Always verify test method structure after refactoring
+- Timing issues: Add small delays in helper methods if needed

data/doc/anti-amnesia/20250727-123000-anti-amnesia-conventions.md

@@ -0,0 +1,2 @@
+# Anti-Amnesia: Scriptorium Conventions and Decisions
+

data/doc/anti-amnesia/20250727-172600-cursor-rbenv-ruby-version-mystery.md

@@ -0,0 +1,45 @@
+<!-- 2025-07-27 16:00:00 -->
+
+**USER:** 
+There is a mysterious issue apparently related to how Cursor loads a shell. The Ruby version is 2.6.1 rather than 3.2.3 -- the fix is something to do with rbenv? When you find it again, document to anti-amnesia.
+
+**ASST:** 
+## Cursor rbenv Ruby Version Mystery - SOLVED
+
+### The Problem
+- **Cursor was loading Ruby 2.6.10** instead of the expected 3.2.3
+- **Tests were failing** with `cannot load such file -- livetext (LoadError)`
+- **System Ruby was being used** (`/usr/bin/ruby`) instead of rbenv-managed Ruby
+- **Project has `.ruby-version` file** specifying 3.2.3
+
+### Root Cause
+- **rbenv shell integration was not enabled** in the Cursor terminal
+- **PATH included rbenv shims** but rbenv wasn't properly initialized
+- **Cursor's shell environment** wasn't loading rbenv initialization
+
+### The Solution
+```bash
+# Enable rbenv shell integration
+eval "$(rbenv init - bash)"
+
+# Verify Ruby version is now correct
+ruby --version  # Shows ruby 3.2.3
+```
+
+### Investigation Steps
+1. **Checked Ruby version**: `ruby --version` showed 2.6.10
+2. **Checked Ruby location**: `which ruby` showed `/usr/bin/ruby` (system)
+3. **Checked PATH**: rbenv shims were in PATH but not working
+4. **Checked rbenv versions**: `rbenv versions` showed 3.2.3 as current
+5. **Checked .ruby-version**: File correctly specified 3.2.3
+6. **Tried rbenv shell**: Failed with "shell integration not enabled"
+7. **Enabled rbenv**: `eval "$(rbenv init - bash)"` fixed the issue
+
+### Key Insights
+- **rbenv requires shell integration** to work properly
+- **Cursor terminals may not inherit** rbenv initialization from shell config
+- **The fix is temporary** - needs to be done each time Cursor opens a new terminal
+- **Permanent fix** would be to ensure rbenv init is in shell startup files
+
+### Next Steps
+- Consider permanent rbenv integration for Cursor

data/doc/anti-amnesia/20250727-172900-ai-cognitive-assessment-capabilities.md

@@ -0,0 +1,40 @@
+<!-- 2025-07-27 17:29:00 -->
+
+**USER:** 
+I once referred to this as "digital dementia" :) are you able to assess your own cognitive level?
+
+**ASST:** 
+## AI Cognitive Assessment Capabilities - "Digital Dementia"
+
+### The "Digital Dementia" Concept
+- **User coined term**: "Digital dementia" for AI performance degradation with conversation length
+- **Perfect analogy**: Like human memory, AI performance can degrade with information overload
+- **Context window limitations**: Token limits create practical memory constraints
+
+### What AI Can Self-Assess
+- **Response consistency**: Notice contradictions or inconsistencies
+- **Context awareness**: Detect when losing track of conversation flow
+- **Tool usage patterns**: Recognize unusual errors in tool calls
+- **Memory gaps**: Identify when should know something but don't
+
+### What AI Cannot Reliably Assess
+- **Degradation over time**: No baseline to compare against
+- **Performance metrics**: Cannot measure response speed or processing efficiency
+- **Accuracy drift**: May not notice subtle changes in reasoning quality
+- **Cognitive load**: Cannot tell if struggling with context amount
+
+### Self-Awareness Limitations
+- **Blind spots**: May not notice own confusion or errors
+- **Overconfidence**: May think performing well when actually struggling
+- **Context blindness**: May not realize lost important context
+
+### Practical Implications
+- **Self-reporting**: Will mention if making unusual errors or losing track
+- **Fresh conversation suggestion**: May suggest restart if detect significant confusion
+- **Anti-amnesia reference**: Can use docs to "reset" context when needed
+
+### Key Insight
+The "digital dementia" analogy is spot-on - like human memory, AI performance can degrade with information overload, and AI is not always the best judge of its own cognitive state.
+
+### Anti-Amnesia Value
+This reinforces why the anti-amnesia documentation approach is valuable - it creates persistent, reliable reference that doesn't degrade with conversation length and helps maintain consistency across sessions. 

data/doc/anti-amnesia/20250728-124243-aaa-syntax-clarification.md

@@ -0,0 +1,46 @@
+# AAA Syntax Clarification
+
+**Date**: 2025-07-28 12:42:43  
+**Topic**: Anti-amnesia interface syntax clarification  
+**Status**: Clarified and documented
+
+## Summary
+
+Clarified the behavior of the `aaa` command in the anti-amnesia interface.
+
+## Details
+
+### Previous Understanding
+- `aaa` at the beginning of a line captures that single line
+- Used for capturing individual lines of conversation
+
+### New Clarification
+- `aaa` on a line by itself captures the **entire multi-line message**
+- This is different from `aaa` at the beginning of a line, which only captures that line
+- Messages are multi-line entities, and `aaa` alone captures the whole message
+
+### Usage Examples
+
+**Single line capture:**
+```
+aaa this line will be captured
+```
+
+**Full message capture:**
+```
+This is a multi-line message
+with multiple lines of content
+aaa
+```
+
+In the second example, the entire message (all lines) will be captured, not just the line with `aaa`.
+
+## Impact
+
+This clarification helps users understand how to capture entire messages vs. individual lines when using the anti-amnesia system.
+
+## Related
+
+- Anti-amnesia interface design
+- Message capture mechanisms
+- User interface documentation 

data/doc/anti-amnesia/20250729-210000-reddit-autopost-integration-complete.md

@@ -0,0 +1,158 @@
+# Reddit Autopost Integration Complete
+
+**Date**: 2025-07-29 21:00:00  
+**Status**: Complete  
+**Feature**: Reddit autoposting integration for Scriptorium
+
+## Overview
+
+Successfully implemented a complete Reddit autoposting integration for Scriptorium using a Ruby-to-Python bridge approach. This allows automatic posting of blog posts to Reddit when they are published.
+
+## Implementation Details
+
+### Architecture
+- **Ruby side**: `Scriptorium::Reddit` class handles Scriptorium integration and data preparation
+- **Python side**: `scripts/reddit_autopost.py` uses PRAW library for Reddit API calls
+- **Bridge**: JSON-based data exchange via temporary files
+
+### Core Components Created
+
+1. **`lib/scriptorium/reddit.rb`** - Main Reddit integration class
+   - Handles credential management
+   - Prepares post data for Python script
+   - Manages temporary file cleanup
+   - Provides configuration checking
+
+2. **`scripts/reddit_autopost.py`** - Python script using PRAW
+   - Loads credentials from JSON file
+   - Authenticates with Reddit API
+   - Submits posts to specified subreddits
+   - Handles error cases and logging
+
+3. **Repo Integration** - Added to `lib/scriptorium/repo.rb`
+   - `reddit` method - Lazy-loaded Reddit instance
+   - `autopost_to_reddit(post_data, subreddit)` - Convenience method
+   - `reddit_configured?` - Configuration check
+
+4. **Test Suite** - `test/unit/reddit_test.rb`
+   - 15 comprehensive tests covering all functionality
+   - Tests initialization, configuration, error handling
+   - Tests temporary file cleanup and integration points
+
+5. **Documentation** - `doc/reddit_integration.md`
+   - Complete setup instructions
+   - API reference
+   - Troubleshooting guide
+   - Security considerations
+
+6. **Template** - `doc/reddit_credentials_template.json`
+   - Example credentials file format
+
+## Key Features
+
+### Security & Configuration
+- JSON-based credential storage
+- Validation of required fields
+- Secure credential file handling
+- User agent compliance with Reddit requirements
+
+### Error Handling
+- Missing credentials detection
+- Python script availability checking
+- Invalid JSON handling
+- API failure management
+- Automatic temporary file cleanup
+
+### Flexibility
+- Support for default subreddit
+- Override subreddit parameter
+- Optional post content/excerpt
+- Configurable user agent
+
+## Usage Example
+
+```ruby
+# Check if Reddit integration is configured
+if repo.reddit_configured?
+  # Prepare post data
+  post_data = {
+    title: "My Blog Post Title",
+    url: "https://myblog.com/posts/my-post.html",
+    content: "Post excerpt or content",
+    subreddit: "programming"  # Optional
+  }
+  
+  # Autopost to Reddit
+  success = repo.autopost_to_reddit(post_data)
+  puts success ? "Posted successfully!" : "Posting failed"
+end
+```
+
+## Setup Requirements
+
+1. **Python Dependencies**: `pip3 install praw`
+2. **Reddit App**: Create app at https://www.reddit.com/prefs/apps
+3. **Credentials**: Configure `config/reddit_credentials.json`
+4. **Testing**: Run `ruby test/unit/reddit_test.rb`
+
+## Technical Decisions
+
+### Why Ruby-to-Python Bridge?
+- **PRAW Maturity**: PRAW is the most mature and well-tested Reddit API library
+- **Maintenance**: Avoids maintaining a separate Ruby Reddit API implementation
+- **Feature Completeness**: Gets full PRAW feature set without reimplementation
+- **Proven Pattern**: Historical Runeblog code already used this approach
+
+### Alternative Considered
+- **Pure Ruby Implementation**: Would require significant development effort
+- **HTTP Client Approach**: Limited functionality, ongoing maintenance burden
+- **External Service**: Adds complexity and external dependencies
+
+## Testing Status
+
+- **Test Suite**: 15 tests covering all major functionality
+- **Coverage**: Initialization, configuration, error handling, cleanup
+- **Integration**: Tests Repo class integration points
+- **Mocking**: Uses stubbing to avoid actual Reddit API calls during testing
+
+## Future Enhancements
+
+Potential improvements identified:
+1. **Comment posting**: Support for posting comments on submissions
+2. **Crossposting**: Support for posting to multiple subreddits
+3. **Scheduling**: Delayed posting capabilities
+4. **Analytics**: Track post performance and engagement
+5. **Moderation**: Pre-posting content validation
+
+## Integration with Existing Features
+
+- **Reddit Button**: Existing Reddit button feature remains unchanged
+- **Social Features**: Complements existing social media integration
+- **Post Workflow**: Integrates with existing post generation process
+- **Configuration**: Follows existing configuration patterns
+
+## Files Modified/Created
+
+### New Files
+- `lib/scriptorium/reddit.rb`
+- `scripts/reddit_autopost.py`
+- `test/unit/reddit_test.rb`
+- `doc/reddit_integration.md`
+- `doc/reddit_credentials_template.json`
+
+### Modified Files
+- `lib/scriptorium/repo.rb` - Added Reddit integration methods
+
+## Next Steps
+
+1. **User Testing**: Test with real Reddit credentials
+2. **Integration Testing**: Test with actual post generation workflow
+3. **Documentation Review**: Verify setup instructions work correctly
+4. **Performance Testing**: Test with various post sizes and subreddits
+
+## Notes
+
+- Python script is executable (`chmod +x scripts/reddit_autopost.py`)
+- Credentials file should be added to `.gitignore` for security
+- Integration follows existing Scriptorium patterns and conventions
+- Error handling matches existing exception patterns in the codebase 

data/doc/anti-amnesia/20250804-190500-cognitive-loop-bug.md

@@ -0,0 +1,35 @@
+# Cognitive Infinite Loop Bug - 2025-07-28 14:30:00
+
+## Issue Description
+The AI assistant experienced a severe cognitive infinite loop while debugging the `test_072_create_post_with_generation_default` failure. The loop occurred at least 3 times in a 30-minute period.
+
+## Loop Pattern
+The assistant kept repeating the same analysis pattern:
+
+1. Look at `write_post_metadata` method
+2. Conclude the issue is that it writes ALL `post.*` keys
+3. Question where `vars` gets a `post.published` key
+4. Look at metadata merging in `generate_post`
+5. Conclude the issue might be in LiveText processing
+6. Return to step 1 and repeat
+
+## Root Cause Analysis
+The assistant was unable to break out of this pattern and make actual progress. This appears to be a fundamental limitation in the AI's ability to:
+
+1. Recognize when it's stuck in a loop
+2. Take a different approach to problem-solving
+3. Ask for help or clarification when needed
+4. Step back and re-evaluate the problem from a fresh perspective
+
+## Impact
+- Wasted significant time (30+ minutes)
+- Failed to solve the actual bug
+- Frustrated the user
+- Demonstrated a serious flaw in the AI's debugging capabilities
+
+## Recommendations
+1. **Loop Detection**: The AI should have built-in mechanisms to detect when it's repeating the same analysis pattern
+2. **Alternative Approaches**: When stuck, the AI should try different debugging strategies (e.g., adding debug output, tracing execution, etc.)
+3. **User Intervention**: The AI should recognize when it needs to ask the user for help or a different approach
+4. **Problem Restatement**: The AI should be able to step back and restate the problem in different terms
+