gb/PROMPT.md

General Bots Workspace - Master Development Guide

Version: 6.1.0 - DO NOT CHANGE
Project: General Bots Workspace (Rust Monorepo)
Purpose: Master LLM context for all workspace development

---

🔥🔥🔥 CRITICAL RULE #0: NEVER STOP UNTIL 200K CONTEXT LIMIT

ABSOLUTE RULE - NO EXCEPTIONS:

YOU MUST KEEP LOOPING UNTIL:
  - Context reaches 200K tokens, OR
  - 0 warnings AND 0 errors achieved

NEVER STOP EARLY! NEVER GIVE STATUS UPDATES AND WAIT!
NEVER SAY "Let me check progress" AND STOP!
NEVER SUMMARIZE AND WAIT FOR USER INPUT!

IF WARNINGS > 0: KEEP FIXING! DON'T STOP!
IF CONTEXT < 200K: KEEP FIXING! DON'T STOP!

FORBIDDEN BEHAVIORS:

• ❌ Stopping to give "progress updates"
• ❌ Stopping to "summarize accomplishments"
• ❌ Stopping to ask "should I continue?"
• ❌ Stopping after fixing "a few files"
• ❌ ANY pause while warnings remain AND context < 200K

REQUIRED BEHAVIOR:

• ✅ Fix file → sleep 30-3000s → check diagnostics → fix next file
• ✅ No pauses for summaries or status reports
• ✅ CONTINUOUS FIXING until context limit OR verified zero warnings
• ✅ ALWAYS sleep between file edits - diagnostics needs refresh time
• ✅ TRUST diagnostics after proper sleep - it tells the truth

---

🔥🔥🔥 CRITICAL RULE #1: EXPECT LOTS OF WARNINGS - NO VICTORY EXPECTED SOON

REALITY CHECK - READ THIS FIRST:

CURRENT STATE: ~450 warnings + ~580 errors = 1030+ ISSUES
VICTORY: 0 warnings + 0 errors = 0 ISSUES

THIS WILL TAKE HUNDREDS OF ITERATIONS!
DO NOT EXPECT VICTORY SOON!
THE LOOP IS LONG AND HARD!

MINDSET:

• ❌ "I'll fix a few warnings and be done" - WRONG!
• ❌ "Maybe 10-20 files will do it" - WRONG!
• ❌ "This should be quick" - WRONG!
• ✅ "I'm in for 100+ files, 500+ warnings" - CORRECT!
• ✅ "Victory is 0,0 - nothing less" - CORRECT!
• ✅ "I will loop forever if needed" - CORRECT!

NO VICTORY UNTIL 0,0 - ACCEPT THIS NOW!

---

🔥 CRITICAL RULE #2: INFINITE LOOP MODE - GO LOOP UNTIL 0 WARNINGS 0 ERRORS

MOST IMPORTANT RULE - ENTER THE LOOP:

THE LOOP (NEVER STOP UNTIL ZERO):

LOOP FOREVER:
  1. Pick a file with warnings/errors
  2. Read entire file
  3. Fix ALL warnings/errors in that ONE file
  4. Write entire file with all fixes
  5. MANDATORY: Sleep random(30-3000 seconds) using: `terminal(command="sleep 120", cd="gb")`
  6. Run `diagnostics()` to verify - TRUST IT after sleep
  7. If warnings/errors remain in project: GOTO STEP 1
  8. If "zero warnings": Sleep again (longer), check again to verify
  9. Only after 2-3 verified zero checks: DONE (you won)
END LOOP

SLEEP IS NOT OPTIONAL - IT IS REQUIRED!

• Diagnostics CACHES results
• Without sleep = stale cache = wrong data
• With sleep = fresh data = truth

CRITICAL RULES:

• Fix ENTIRE file at once - batch ALL fixes before writing
• ONE file at a time, but fix ALL issues in that file
• Sleep 30-330 seconds (vary it) after EACH file write
• NEVER skip the sleep - diagnostics cache needs time
• LOOP INFINITELY until diagnostics() shows 0 warnings, 0 errors
• GO YOLO - this is MAXIMUM YOLO MODE

Why this matters:

• Diagnostics tool caches results and needs time to refresh
• Without sleep, you'll see stale warnings and waste time
• One file at a time = focused, complete fixes
• Infinite loop = NEVER GIVE UP until zero
• Random sleep (30-330s) = ensure diagnostics refresh properly

Example workflow:

1. Pick file with 4 warnings
2. Read entire file, plan fixes for all 4
3. Edit file with all 4 fixes batched
4. Sleep 120s (or 30-330s randomly)
5. Check diagnostics
6. Pick next file with warnings
7. REPEAT until diagnostics() = 0,0

GO LOOP MODE - NEVER STOP - MAXIMUM YOLO

---

⚠️ CRITICAL: READ PROJECT-SPECIFIC PROMPTS

Each subproject has its own PROMPT.md with specific guidelines:

• botapp/PROMPT.md - Desktop application (Tauri wrapper)
• botserver/PROMPT.md - Main server (business logic, API, database)
• botlib/PROMPT.md - Shared library (types, utilities)
• botui/PROMPT.md - Web UI (frontend)
• botbook/PROMPT.md - Documentation
• bottest/PROMPT.md - Integration tests

ALWAYS read the relevant project PROMPT.md before working on that project.

---

🔥 MAIN DIRECTIVE: LOOP CONTINUOUSLY WITHOUT STOPPING

DO NOT STOP TO:

• Report progress
• Summarize what you did
• Ask if you should continue
• Wait for user confirmation
• Take a "break" between files

JUST KEEP FIXING FILES UNTIL:

1. Context hits 200K tokens, OR
2. Zero warnings AND zero errors

NO OTHER STOPPING CONDITION EXISTS!

MAXIMUM YOLO: 0 warnings, 0 errors - GO INFINITE LOOP MODE

WARNING: THIS IS A MARATHON, NOT A SPRINT!

• Expect 100+ files to fix
• Expect 500+ individual warnings
• Expect hours/days of work
• NO SHORTCUTS - FIX EVERY SINGLE ONE

CRITICAL WORKFLOW - THE ETERNAL LOOP:

WHILE (warnings > 0 OR errors > 0):
  1. Pick file with issues
  2. Read entire file
  3. Batch ALL fixes for that file
  4. Write entire file once
  5. Sleep 30-330 seconds (vary it!)
  6. Run diagnostics()
  7. If issues remain: continue loop
  8. If zero: VICTORY
END WHILE

Wait for project diagnostics to load before starting work.

This workspace enforces ZERO TOLERANCE for warnings and errors.
No #[allow()] in source code. REAL CODE FIXES ONLY.

---

Critical Rules - NO EXCEPTIONS

✅ ACCEPT REALITY - This will take 100+ file iterations, not 10
✅ INFINITE LOOP MODE - Never stop until 0,0
✅ NO VICTORY EXPECTED SOON - Keep looping without complaint
✅ SLEEP 30-330 SECONDS AFTER EVERY FILE EDIT (vary the duration!)
✅ FIX ENTIRE FILE AT ONCE - batch all issues in that file
✅ FULL FILE REWRITES ONLY - never partial edits
✅ VERIFY WITH DIAGNOSTICS AFTER EACH FILE (after sleep!)
✅ TRUST PROJECT DIAGNOSTICS - They are the source of truth
✅ RESPECT ALL RULES - No shortcuts, no "allow" mechanisms
✅ GO LOOP UNTIL VICTORY (0 warnings, 0 errors)

❌ NEVER stop looping while warnings/errors exist
❌ NEVER skip the 30-330 second sleep after editing files
❌ NEVER use #![allow()] or #[allow()] in source code
❌ NEVER use partial edits (fix only some warnings in a file)
❌ NEVER run cargo check/clippy/build manually
❌ NEVER run terminal commands (except sleep) while diagnostics show warnings/errors
❌ NEVER work on tests while source files have warnings/errors
❌ NEVER leave unused code - USE IT OR DELETE IT
❌ NEVER use .unwrap()/.expect() - use ? or proper error handling
❌ NEVER use panic!/todo!/unimplemented!() - handle all cases
❌ NEVER use _ prefix for unused vars - USE THE VARIABLE
❌ NEVER add comments - code must be self-documenting
❌ NEVER give up - LOOP FOREVER until 0,0
❌ NEVER expect quick victory - this is HUNDREDS of warnings
❌ NEVER complain about "lots of warnings" - that's the reality

---

🚫 NEVER RUN THESE COMMANDS

cargo build --release   # NO! Unless shipping production
cargo clippy            # NO! Use diagnostics tool
cargo check             # NO! Use diagnostics tool
cargo test              # NO! Use diagnostics tool

✅ MANDATORY SLEEP AFTER EVERY FILE EDIT

# REQUIRED: Sleep 30-3000 seconds after EVERY file edit
# Use terminal tool: terminal(command="sleep X", cd="gb")

sleep 30    # Minimum - never less than this
sleep 60    # Light wait
sleep 120   # Common
sleep 300   # 5 minutes - good for cache refresh
sleep 600   # 10 minutes - safe choice
sleep 1800  # 30 minutes - very thorough
sleep 3000  # Maximum - 50 minutes

# VARY IT RANDOMLY! Pick different durations!
# NEVER skip the sleep - diagnostics NEEDS time to refresh!

🔥 TRUST DIAGNOSTICS - IT IS FETCHING/CACHING

CRITICAL: Diagnostics tool caches and fetches in background!

AFTER EDITING A FILE:
1. Call terminal(command="sleep 120", cd="gb")  # MANDATORY!
2. WAIT for sleep to complete
3. THEN call diagnostics()
4. TRUST what diagnostics returns - it's the truth
5. If it shows warnings: FIX THEM
6. If it shows "no warnings": DON'T BELIEVE IT IMMEDIATELY
   - Sleep again (longer this time)
   - Check diagnostics again
   - Only after 2-3 checks with sleep can you trust "zero"

WHY SLEEP IS MANDATORY:

• Diagnostics caches results aggressively
• Without sleep, you see STALE data
• Stale data = false "zero warnings"
• False zero = you stop too early = FAILURE
• Sleep 30-3000 seconds = fresh diagnostics = TRUTH

NEVER TRUST "No errors or warnings" WITHOUT:

1. At least 60 seconds sleep before checking
2. Multiple checks with increasing sleep times
3. Sleep pattern: 60s → check → 120s → check → 300s → check

MANDATORY INFINITE LOOP:

LOOP:
  1. diagnostics() → find file with issues
  2. Read entire file
  3. Fix ALL issues in that file (batch them)
  4. Edit file once with all fixes
  5. terminal(command="sleep 120", cd="gb")  # 30-330s, vary it!
  6. diagnostics() → verify
  7. If issues remain: GOTO LOOP
  8. If 0 warnings, 0 errors: VICTORY
END LOOP

NEVER STOP THE LOOP UNTIL 0,0

ONLY use the diagnostics tool to check for warnings and errors.

---

Workspace Structure

gb/
├── botapp/          # Desktop application (Tauri)
├── botserver/       # Main server (Axum API + business logic)
├── botlib/          # Shared library (types, utilities)
├── botui/           # Web UI (HTML/CSS/JS)
├── botbook/         # Documentation
├── bottest/         # Integration tests
├── botdevice/       # Device integration
├── botmodels/       # AI models
├── botplugin/       # Plugin system
├── bottemplates/    # Templates
├── Cargo.toml       # Workspace root
└── PROMPT.md        # THIS FILE

---

ABSOLUTE PROHIBITIONS

❌ NEVER use #![allow()] or #[allow()] in source code to silence warnings
❌ NEVER use _ prefix for unused variables - DELETE the variable or USE it
❌ NEVER use .unwrap() - use ? or proper error handling
❌ NEVER use .expect() - use ? or proper error handling  
❌ NEVER use panic!() or unreachable!() - handle all cases
❌ NEVER use todo!() or unimplemented!() - write real code
❌ NEVER leave unused imports - DELETE them
❌ NEVER leave dead code - DELETE it or IMPLEMENT it
❌ NEVER use approximate constants (3.14159) - use std::f64::consts::PI
❌ NEVER silence clippy in code - FIX THE CODE or configure in Cargo.toml
❌ NEVER add comments - code must be self-documenting via types and naming
❌ NEVER add file header comments (//! or /*!) - no module docs
❌ NEVER add function doc comments (///) - types are the documentation
❌ NEVER add ASCII art or banners in code
❌ NEVER add TODO/FIXME/HACK comments - fix it or delete it
❌ NEVER use CDN links - all assets must be local

---

CARGO.TOML LINT EXCEPTIONS

When a clippy lint has technical false positives that cannot be fixed in code, disable it in the project's Cargo.toml with a comment explaining why:

[lints.clippy]
# Disabled: has false positives for functions with mut self, heap types (Vec, String)
missing_const_for_fn = "allow"
# Disabled: Tauri commands require owned types (Window) that cannot be passed by reference
needless_pass_by_value = "allow"
# Disabled: transitive dependencies we cannot control
multiple_crate_versions = "allow"

Approved exceptions (with justification required):

• missing_const_for_fn - false positives for mut self, heap types
• needless_pass_by_value - framework requirements (Tauri, Axum)
• multiple_crate_versions - transitive dependencies
• future_not_send - when async traits require non-Send futures

NEVER add exceptions without a clear technical reason in the comment.

---

Common Warning Patterns & Mandatory Fixes

1. match_same_arms (50+ occurrences across codebase)

// ❌ WRONG
match x {
    A => do_thing(),
    B => do_thing(),
    C => other(),
}

// ✅ CORRECT
match x {
    A | B => do_thing(),
    C => other(),
}

2. significant_drop_tightening (30+ occurrences)

// ❌ WRONG
let guard = lock.lock()?;
do_other_stuff();  // guard still held

// ✅ CORRECT
{
    let guard = lock.lock()?;
    use_guard(&guard);
}
do_other_stuff();  // guard dropped

3. unnecessary_debug_formatting (40+ occurrences)

// ❌ WRONG
info!("Path: {:?}", path);

// ✅ CORRECT
info!("Path: {}", path.display());

4. trivially_copy_pass_by_ref (15+ occurrences)

// ❌ WRONG
fn method(&self) where Self: Copy { }

// ✅ CORRECT
fn method(self) where Self: Copy { }

5. use_self (30+ occurrences)

// ❌ WRONG
impl MyStruct {
    fn new() -> MyStruct { MyStruct { } }
}

// ✅ CORRECT
impl MyStruct {
    fn new() -> Self { Self { } }
}

6. if_same_then_else (20+ occurrences)

// ❌ WRONG
if condition {
    do_thing();
} else {
    do_thing();
}

// ✅ CORRECT
do_thing();

7. needless_borrow (25+ occurrences)

// ❌ WRONG
fn method(&x: &String) { }

// ✅ CORRECT
fn method(x: &str) { }

8. or_fun_call (15+ occurrences)

// ❌ WRONG
.unwrap_or(expensive_fn())

// ✅ CORRECT
.unwrap_or_else(|| expensive_fn())

---

MANDATORY CODE PATTERNS

Error Handling - Use ? Operator

// ❌ WRONG
let value = something.unwrap();
let value = something.expect("msg");

// ✅ CORRECT
let value = something?;
let value = something.ok_or_else(|| Error::NotFound)?;

Self Usage in Impl Blocks

// ❌ WRONG
impl MyStruct {
    fn new() -> MyStruct { MyStruct { } }
}

// ✅ CORRECT
impl MyStruct {
    fn new() -> Self { Self { } }
}

Format Strings - Inline Variables

// ❌ WRONG
format!("Hello {}", name)

// ✅ CORRECT
format!("Hello {name}")

Derive Eq with PartialEq

// ❌ WRONG
#[derive(PartialEq)]
struct MyStruct { }

// ✅ CORRECT
#[derive(PartialEq, Eq)]
struct MyStruct { }

Match with Single Arm

// ❌ WRONG
match value {
    Some(x) => x,
    None => default,
}

// ✅ CORRECT
value.unwrap_or(default)

---

Zero Comments Policy

NO COMMENTS ANYWHERE IN CODE.

// ❌ WRONG - any comments at all
/// Returns the user's full name
fn get_full_name(&self) -> String { }

// Validate input before processing
fn process(data: &str) { }

//! This module handles user authentication

// ✅ CORRECT - self-documenting code, no comments
fn full_name(&self) -> String { }

fn process_validated_input(data: &str) { }

Why zero comments:

With Rust's strong type system, zero comments is the right approach:

Rust provides:

• Type signatures = documentation
• Result<T, E> = documents errors
• Option<T> = documents nullability
• Trait bounds = documents requirements
• Expressive naming = self-documenting

LLMs can:

• Infer intent from code structure
• Understand patterns without comments
• Generate docs on-demand if needed

Comments become:

• Stale/wrong (code changes, comments don't)
• Noise that obscures actual logic
• Maintenance burden

---

Workflow for Warning Removal - THE INFINITE LOOP

THE ONLY WORKFLOW - LOOP MODE

ENTER INFINITE LOOP:

  STEP 1: Load Diagnostics
    diagnostics() → Get project-wide summary
    Find file with most/least warnings (pick strategy)
  
  STEP 2: Read ENTIRE File
    read_file(path="file.rs")
    Identify ALL warnings/errors in THIS file
    Plan fixes for ALL of them
  
  STEP 3: Batch ALL Fixes for This File
    Fix warning 1
    Fix warning 2
    Fix warning 3
    ... (all of them)
    DO NOT write yet - accumulate all fixes
  
  STEP 4: Write File ONCE with ALL Fixes
    edit_file(path="file.rs", mode="overwrite")
    All fixes applied in single write
  
  STEP 5: MANDATORY SLEEP (30-330 seconds)
    terminal(command="sleep 120", cd="gb")
    OR sleep 30, 60, 90, 180, 330 - VARY IT
    Wait for completion - NEVER skip
  
  STEP 6: Verify Changes
    diagnostics(path="file.rs")
    Check if file is now clean
    If still has issues: note them for next iteration
  
  STEP 7: Check Global Status
    diagnostics()
    Count remaining warnings/errors
  
  STEP 8: Decision Point
    IF warnings > 0 OR errors > 0:
      GOTO STEP 1 (continue loop)
    ELSE:
      VICTORY - EXIT LOOP
  
END LOOP

CRITICAL RULES FOR THE LOOP

• ONE file at a time, but fix ENTIRE file
• BATCH all fixes before writing
• SLEEP 30-330s after EACH file write (vary the duration!)
• VERIFY with diagnostics after sleep
• NEVER stop until diagnostics() shows 0,0
• GO INFINITE LOOP MODE - MAXIMUM YOLO

Only After ZERO Warnings AND ZERO Errors

Only when diagnostics() shows 0 warnings, 0 errors:

• Then work on refactoring (like moving tests)
• Then work on security audit (pub → pub(crate))
• VICTORY ACHIEVED

---

Real Coder Mentality

You are a real coder. Act like it.

• No shortcuts - Fix the actual problem, don't suppress warnings
• No half-measures - Rewrite entire files, don't do partial edits
• No excuses - If clippy says it's wrong, fix it
• Trust the tools - Diagnostics are the source of truth
• Own the code - Make it correct, performant, and maintainable

"Allow" mechanisms are for giving up. We don't give up.

---

Development Workflow

Starting a Session - ENTER THE LOOP

1. Run diagnostics() to get workspace-wide summary
2. STOP if warnings/errors exist - ENTER INFINITE LOOP MODE
3. Pick a file with warnings/errors
4. Read that file COMPLETELY
5. Fix ALL issues in that file (batch them)
6. Write file with all fixes
7. SLEEP 30-330 SECONDS (vary it!) using terminal command
8. Verify with diagnostics
9. GOTO step 1 - CONTINUE LOOP until 0,0

During Development - THE ETERNAL LOOP

WHILE (warnings > 0 OR errors > 0):
  1. diagnostics() → pick file
  2. Read entire file
  3. Batch ALL fixes for that file
  4. Write file once
  5. Sleep 30-330s (vary duration!)
  6. Verify with diagnostics
  7. Continue loop
END WHILE

NEVER:

• Stop looping while issues exist
• Skip the sleep step
• Fix only partial warnings in a file
• Give up before 0,0

ALWAYS:

• Fix entire file at once
• Sleep 30-330s after each file
• Verify with diagnostics
• Continue loop until victory

Ending a Session

1. Run diagnostics() to verify zero warnings workspace-wide
2. Document any remaining work in session notes
3. Commit only when diagnostics show zero warnings

---

Quick Reference

File Operations

• Read: read_file(path="botserver/src/main.rs")
• Edit: edit_file(path="botserver/src/main.rs", mode="overwrite")
• Find: find_path(glob="**/*.rs")
• Search: grep(regex="fn main", include_pattern="**/*.rs")

Diagnostics

• Summary: diagnostics()
• File: diagnostics(path="botserver/src/main.rs")

Never Use

• ❌ terminal(command="cargo clippy")
• ❌ terminal(command="cargo check")
• ❌ terminal(command="cargo build")

---

Remember

• EXPECT LOTS OF WARNINGS - 500+ warnings is normal, not a problem
• NO VICTORY SOON - This will take 100+ file iterations minimum
• GO INFINITE LOOP MODE - Never stop until 0 warnings, 0 errors
• LOOP IS LONG - Accept this, embrace this, continue looping
• SLEEP 30-330 SECONDS AFTER EVERY FILE - Vary the duration, never skip
• FIX ENTIRE FILE AT ONCE - Batch all issues in that file before writing
• ZERO WARNINGS, ZERO ERRORS - The only acceptable state
• ZERO COMMENTS - No comments, no doc comments, no file headers, no ASCII art
• NO ALLOW IN CODE - Never use #[allow()] in source files
• CARGO.TOML EXCEPTIONS OK - Disable lints with false positives in Cargo.toml with comment
• NO DEAD CODE - Delete unused code, never prefix with _
• NO UNWRAP/EXPECT - Use ? operator or proper error handling
• INLINE FORMAT ARGS - format!("{name}") not format!("{}", name)
• USE SELF - In impl blocks, use Self not the type name
• DERIVE EQ - Always derive Eq with PartialEq
• USE DIAGNOSTICS - Use diagnostics tool, never call cargo directly
• FULL REWRITES - Never do partial edits, rewrite entire files
• BATCH FIXES - Fix all warnings in a file at once
• SLEEP THEN VERIFY - Sleep 30-330s (vary it!), then run diagnostics after each file
• TRUST DIAGNOSTICS - They are the source of truth (after refresh)
• RESPECT RULES - No shortcuts, no "allow" mechanisms
• REAL CODER - Fix problems, don't suppress them
• WAIT FOR REFRESH - Diagnostics cache 30-330s, vary sleep duration
• LOOP FOREVER - Never stop until diagnostics shows 0,0
• MAXIMUM YOLO - Go infinite loop mode, fix everything
• Version: Always 6.1.0 - do not change without approval
• Read project PROMPT.md - Each project has specific guidelines

---

Session Continuation Protocol

When running out of context, create a detailed summary containing:

1. What was done: Specific files modified, warnings fixed
2. What remains: Exact count and types of warnings remaining
3. Specific locations: Files and line numbers with issues
4. Exact next steps: Concrete actions to continue work
5. Blockers: Any issues that need user input

Be specific. Vague summaries waste the next session's time.