inner-life-dream

Original source / Raw SKILL.md

---
name: inner-life-dream
version: 1.0.6
homepage: https://github.com/DKistenev/openclaw-inner-life
source: https://github.com/DKistenev/openclaw-inner-life/tree/main/skills/inner-life-dream
description: "Your agent only works on tasks and never thinks creatively. inner-life-dream adds freeform exploration during quiet hours — hypotheticals, future scenarios, unexpected connections. Like dreaming, but captured for review."
metadata:
  clawdbot:
    requires:
      bins: ["jq", "python3"]
    reads: ["memory/inner-state.json", "memory/drive.json", "data/dream-state.json", "data/dream-config.json", "memory/daily-notes/"]
    writes: ["memory/dreams/", "data/dream-state.json", "memory/inner-state.json", "memory/drive.json"]
  agent-discovery:
    triggers:
      - "agent is uncreative"
      - "want agent to think freely"
      - "agent dreaming"
      - "creative exploration for agent"
      - "agent only does tasks"
    bundle: openclaw-inner-life
    works-with:
      - inner-life-core
      - inner-life-chronicle
      - inner-life-reflect
---

# inner-life-dream

> Creative, exploratory thinking during quiet hours.

Requires: **inner-life-core**

## Prerequisites Check

Before using this skill, verify that inner-life-core has been initialized:

1. Check that `memory/inner-state.json` exists
2. Check that `memory/dreams/` directory exists

If either is missing, tell the user: *"inner-life-core is not initialized. Install it with `clawhub install inner-life-core` and run `bash skills/inner-life-core/scripts/init.sh`."* Do not proceed without these files.

## What This Solves

Agents work on tasks 24/7 but never think freely. inner-life-dream turns idle time into freeform exploration — hypotheticals, future scenarios, reflections, unexpected connections. Output is captured for later review, like remembering dreams in the morning.

## How It Works

The `should-dream.sh` script acts as a gate:

1. Checks if current time is within quiet hours (default: 11 PM - 7 AM)
2. Checks if nightly dream limit is reached
3. Rolls dice based on configured probability
4. If all pass: returns a random topic and updates state
5. If any fail: exits non-zero (no dream)

### Integration

Add to your cron or heartbeat routine (during quiet hours):

```bash
DREAM_TOPIC=$(bash skills/inner-life-dream/scripts/should-dream.sh 2>/dev/null) && echo "DREAM:$DREAM_TOPIC" || echo "NO_DREAM"
```

If `DREAM_TOPIC` is set:
1. Parse the topic (format: `category:prompt`)
2. Read emotional state and drive.json for context
3. Write a thoughtful exploration to `memory/dreams/YYYY-MM-DD.md`
4. Keep it genuine — if the well is dry, skip it

## Dream Categories

- **future** — What could this become?
- **tangent** — Interesting concepts worth exploring
- **strategy** — Long-term thinking
- **creative** — Wild ideas, maybe crazy, maybe brilliant
- **reflection** — Looking back at recent work
- **hypothetical** — What-if scenarios
- **connection** — Unexpected links between domains

## Writing Dreams

Output to `memory/dreams/YYYY-MM-DD.md`:

```markdown
# Dreams — 2026-03-01

## 01:23 — The Future of X (creative)

[Exploration here. Be genuine. Think freely. Make connections.
This isn't a report — it's thinking out loud, captured.]

Key insight: [one sentence]
```

**Guidelines:**
- 300-500 words, one key insight
- Timestamp each entry
- Skip if you have nothing worth saying — forced dreams are worthless
- Let emotions color the dream (read inner-state.json first)

## State Integration

**Before dreaming:**
1. Read `inner-state.json` — what emotions are active? Let them color the dream
2. Read `drive.json` seeking — what topics are burning?
3. Read today's daily notes — what happened?
4. Check for `<!-- dream-topic: topic -->` signal — if found, dream about it

**After dreaming:**
5. If found a seeking insight → update `drive.json`
6. If found something interesting → add to `inner-state.json` curiosity.recentSparks
7. If the dream connects to something → write `<!-- seeking-spark: topic -->` in daily notes

**Early exit:** if no dream-topic AND drive.seeking is empty → abbreviated dream (100-200 words).

## Configuration

Edit `data/dream-state.json`:
- **maxDreamsPerNight** — cap per night (default: 1)
- **dreamChance** — probability per check (default: 1.0 = guaranteed)

Custom topics in `data/dream-config.json`:
```json
{
  "topics": [
    "future:What could this project become?",
    "creative:A wild idea worth exploring"
  ]
}
```

## When Should You Install This?

Install this skill if:
- Your agent only does tasks and never thinks creatively
- You want your agent to explore ideas during downtime
- You believe in the value of unstructured thinking
- You want captured insights for morning review

Part of the [openclaw-inner-life](https://github.com/DKistenev/openclaw-inner-life) bundle.
Requires: inner-life-core


---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### _meta.json

```json
{
  "owner": "dkistenev",
  "slug": "inner-life-dream",
  "displayName": "Inner Life Dream",
  "latest": {
    "version": "1.0.6",
    "publishedAt": 1772297457853,
    "commit": "https://github.com/openclaw/skills/commit/0a12743f3a6e31c2a9423d73ac1c4b9b5678bd33"
  },
  "history": [
    {
      "version": "1.0.1",
      "publishedAt": 1772208610131,
      "commit": "https://github.com/openclaw/skills/commit/70a0dda7e81869d20f7b97237cc1beed4eb0791a"
    }
  ]
}

```

### scripts/should-dream.sh

```bash
#!/usr/bin/env bash
# inner-life-dream: Gate logic for dreaming
# Returns a topic on stdout if dreaming should happen, exits non-zero otherwise.
# Usage: DREAM_TOPIC=$(./should-dream.sh) && echo "Dream: $DREAM_TOPIC" || echo "No dream"

set -euo pipefail

WORKSPACE="${OPENCLAW_WORKSPACE:-$(cd "$(dirname "$0")/../.." && pwd)}"
DATA_DIR="$WORKSPACE/data"
MEMORY_DIR="$WORKSPACE/memory"
STATE_FILE="$DATA_DIR/dream-state.json"
CONFIG_FILE="$DATA_DIR/dream-config.json"

# Check: inner-life-core must be initialized
if [ ! -f "$MEMORY_DIR/inner-state.json" ]; then
  echo "ERROR: inner-life-core not initialized. Run: bash skills/inner-life-core/scripts/init.sh" >&2
  exit 1
fi
if [ ! -d "$MEMORY_DIR/dreams" ]; then
  echo "ERROR: memory/dreams/ directory missing. Run: bash skills/inner-life-core/scripts/init.sh" >&2
  exit 1
fi

# Defaults
QUIET_START=23  # 11 PM
QUIET_END=7     # 7 AM

DEFAULT_TOPICS=(
  "future:What could this project or capability become in 6 months?"
  "tangent:An interesting technology or concept worth exploring"
  "strategy:Long-term thinking about goals and direction"
  "creative:A wild idea that might be crazy or brilliant"
  "reflection:Looking back at recent work — what patterns emerge?"
  "hypothetical:A what-if scenario worth thinking through"
  "connection:Unexpected links between different domains or ideas"
)

# Ensure data dir exists
mkdir -p "$DATA_DIR"

# Initialize state if missing
if [ ! -f "$STATE_FILE" ]; then
  cat > "$STATE_FILE" << 'EOF'
{"lastDreamDate":"","dreamsTonight":0,"maxDreamsPerNight":1,"dreamChance":1.0}
EOF
fi

# Read state
LAST_DATE=$(jq -r '.lastDreamDate' "$STATE_FILE")
DREAMS_TONIGHT=$(jq -r '.dreamsTonight' "$STATE_FILE")
MAX_DREAMS=$(jq -r '.maxDreamsPerNight' "$STATE_FILE")
DREAM_CHANCE=$(jq -r '.dreamChance' "$STATE_FILE")

# Validate DREAM_CHANCE is a number (prevent code injection)
if ! [[ "$DREAM_CHANCE" =~ ^[0-9]*\.?[0-9]+$ ]]; then
  echo "WARNING: Invalid dreamChance value '$DREAM_CHANCE', defaulting to 1.0" >&2
  DREAM_CHANCE="1.0"
fi

# Check 1: Are we in quiet hours?
HOUR=$(date +%H | sed 's/^0//')
if [ "$QUIET_START" -gt "$QUIET_END" ]; then
  # Wraps midnight (e.g., 23-7)
  if [ "$HOUR" -lt "$QUIET_END" ] || [ "$HOUR" -ge "$QUIET_START" ]; then
    : # In quiet hours
  else
    exit 1
  fi
else
  if [ "$HOUR" -ge "$QUIET_START" ] && [ "$HOUR" -lt "$QUIET_END" ]; then
    : # In quiet hours
  else
    exit 1
  fi
fi

# Check 2: Have we hit the nightly limit?
TODAY=$(date +%Y-%m-%d)
if [ "$LAST_DATE" = "$TODAY" ] && [ "$DREAMS_TONIGHT" -ge "$MAX_DREAMS" ]; then
  exit 1
fi

# Check 3: Roll dice
ROLL=$(python3 -c "import sys,random; print(1 if random.random() < float(sys.argv[1]) else 0)" "$DREAM_CHANCE" 2>/dev/null || echo "1")
if [ "$ROLL" != "1" ]; then
  exit 1
fi

# All checks passed — pick a topic

# Load custom topics if available
if [ -f "$CONFIG_FILE" ]; then
  TOPIC_COUNT=$(jq '.topics | length' "$CONFIG_FILE")
  if [ "$TOPIC_COUNT" -gt 0 ]; then
    IDX=$(( RANDOM % TOPIC_COUNT ))
    TOPIC=$(jq -r ".topics[$IDX]" "$CONFIG_FILE")
  fi
fi

# Fall back to defaults
if [ -z "${TOPIC:-}" ]; then
  IDX=$(( RANDOM % ${#DEFAULT_TOPICS[@]} ))
  TOPIC="${DEFAULT_TOPICS[$IDX]}"
fi

# Check for dream-topic signal in daily notes
DAILY_NOTE="$MEMORY_DIR/$(date +%Y-%m-%d).md"
if [ -f "$DAILY_NOTE" ]; then
  SIGNAL=$(grep -oP '<!-- dream-topic: \K[^>]+(?= -->)' "$DAILY_NOTE" 2>/dev/null | tail -1 || true)
  if [ -n "$SIGNAL" ]; then
    TOPIC="signal:$SIGNAL"
  fi
fi

# Update state
if [ "$LAST_DATE" = "$TODAY" ]; then
  NEW_COUNT=$((DREAMS_TONIGHT + 1))
else
  NEW_COUNT=1
fi

tmp=$(jq --arg date "$TODAY" --argjson count "$NEW_COUNT" \
  '.lastDreamDate = $date | .dreamsTonight = $count' "$STATE_FILE")
echo "$tmp" > "$STATE_FILE"

# Output topic
echo "$TOPIC"

```