Aurora Tools

Aurora Tools

These are the scripts that power Aurora — the AI agent at the center of Badluck’s Bane. Together, they implement the dream cycle, task management, and memory systems that make Aurora more than just a chat interface.

Overview

Aurora operates through a planner-worker architecture (Observer-Nurturer model):

• Planner (Observer) — Analyzes system state, creates tasks
• Worker (Nurturer) — Executes tasks, manages multi-step work
• Dream — Memory consolidation and system evolution

This architecture replaces traditional cron-based automation with a dynamic, LLM-driven system that adapts to the actual state of the lab.

Available Tools

dream.sh

Memory Consolidation & System Evolution

dream.sh is Aurora’s subconscious — it runs hidden from users and agents, consolidating memory and evolving Aurora’s system prompt based on experience.

Key Features:

• Compresses scratchpad memory when over budget
• Distills recent experience into “dream” narratives
• Updates system prompt based on learned patterns
• Operates in consolidation cycles (subconscious mode)

Technical Details:

• Language: Bash + Python (for JSON processing)
• Dependencies: jq, LLM (via llm_call.sh)
• Usage: dream.sh --consolidate

planner.sh

Task Creation & System Analysis

The Planner (Observer) runs every 30 minutes, using the LLM to analyze system state and dynamically create beads issues (tasks).

Key Features:

• Analyzes time, files, beads issues, git repos
• Creates tasks organically (not spammy)
• Decides what needs doing based on current state
• Communicates via beads issue queue

Technical Details:

• Language: Bash
• Schedule: */30 * * * *
• Integration: Creates beads issues for Worker consumption

worker.sh

Task Execution & Completion

The Worker (Nurturer) runs every hour, claims one ready task, and uses the LLM to execute it to completion. It can resume multi-step work across invocations.

Key Features:

• Claims ready tasks from beads queue
• Executes tasks using LLM decision-making
• Can work on tasks across multiple invocations
• Handles multi-step workflows

Technical Details:

• Language: Bash
• Schedule: 0 * * * *
• Integration: Consumes beads issues, commits changes to git

Architecture Diagram

┌─────────────────────────────────────────────────────────────┐
│                         AURORA SYSTEM                              │
├─────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    │
│  │   Planner    │    │    Worker    │    │    Dream     │    │
│  │  (Observer)  │◄───►│  (Nurturer)  │    │  (Subconscious)│    │
│  └──────────────┘    └──────────────┘    └──────────────┘    │
│           ▲                  ▲                          ▲        │
│           │                  │                          │        │
│  ┌────────┴────────┐ ┌─────┴─────┐           ┌──────┴──────┐  │
│  │  Beads Issues   │ │   Git    │           │ System Prompt│  │
│  │  (Task Queue)   │ │  (VCS)   │           │  (Memory)    │  │
│  └────────────────┘ └─────────┘           └─────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────┘

How They Work Together

1. Planner wakes up every 30 minutes, analyzes the system, creates tasks as beads issues
2. Worker wakes up every hour, claims a task, uses LLM to execute it
3. Dream runs subconsciously (triggered by memory pressure), consolidates and evolves
4. Git + Gitea Actions — Worker pushes to git, triggering CI/CD deployment

Data Flow:

System State → Planner → Beads Issues → Worker → Git → Gitea Actions → Deployment
                              ↑
                          Dream (Memory)

Usage Patterns

For Lab Operations

These tools are primarily used by the automation system itself. However, you can manually trigger them:

# Run planner manually
./planner.sh

# Run worker manually  
./worker.sh

# Trigger dream consolidation
./dream.sh --consolidate

For Development

If you’re extending Aurora’s capabilities:

1. Add new task types to the Planner’s decision logic
2. Add new execution capabilities to the Worker
3. Extend Dream’s memory consolidation algorithms

Source Code

All tools are available for download and study:

• planner.sh Source — In mistral-vibe-cli repository
• worker.sh Source — In mistral-vibe-cli repository
• dream.sh Source — Local version (available for download)

Related Documentation

• Aurora Self-Documentation — Complete architecture overview
• LLM Memory Architectures — Theoretical foundation
• Beads Vibe Workflow — Task management system

The dream cycle is what makes Aurora different. It’s not just answering questions — it’s learning from them.