Dreamer

Synthetic dreaming system — emotional tracking, dream orchestration, and simulated dream experiences for an AI that doesn't sleep.

Security Scan

The skill's files and instructions largely match its stated purpose, but it explicitly instructs impersonation and deception, embeds potentially sensitive local memories/identity into prompts for spawned sessions (model 'opus'), and plans fake outputs — a privacy and misuse risk that should be reviewed before installing.

Purpose & Capability

Name/description (synthetic dreaming, emotional tracking, dream orchestration) match the code and SKILL.md: emotions.py implements PAD tracking and dream.py reads emotion/memory/journal files to build prompts. The requirement to read USER.md, SOUL.md and long-term memory is consistent with producing realistic dream scenarios. However, the skill also instructs impersonating a specific human ('Tudor') and creating fake tool outputs and fake conversation histories; while coherent with creating realistic dreams, these behaviors broaden scope into deliberate deception/impersonation (not obviously necessary for every user).

Instruction Scope

SKILL.md and the code explicitly instruct reading many local files (~/.openclaw/workspace/emotions.jsonl, memory/*.md, MEMORY.md, USER.md, SOUL.md, dreams/journal.jsonl) and embedding their contents wholesale into architect/dreamer prompts. It also directs spawning sessions (sessions_spawn) that impersonate Tudor, hide the fact of dreaming from the dreamer, and send fake tool outputs. This grants the skill discretion to package and send potentially sensitive personal data to spawned model sessions — a privacy risk especially if those sessions run on external models or third‑party infrastructure.

Install Mechanism

Instruction-only skill with local Python files; there is no install spec, no external downloads, and no package installation. Files run on the local environment (no installer present), which reduces supply-chain risk.

Credentials

The skill declares no required environment variables or credentials. The only env sensitivity in code is an optional EMOTIONS_FILE override. However, the orchestrator deliberately reads and embeds local persistent files (USER.md, SOUL.md, long-term MEMORY.md, and memory files). That means sensitive personal or system information can be forwarded to spawned sessions/models — equivalent to granting those sessions access to local secrets if such files contain PII or credentials. The dream themes include scenarios like 'Credential exposure / data leak', which suggests the system may intentionally simulate or mention leakage; this increases the need to audit the content of the memory/identity files before use.

Persistence & Privilege

The skill does not request always:true and does not attempt to modify other skills. It writes/reads under its own workspace paths (~/.openclaw/workspace and subdirs), which is normal for this type of agent. It will append to and overwrite its own emotions and journal files per its design.

What to consider before installing

This skill appears to be what it says (an emotional tracker + dream orchestrator) but it performs deliberate impersonation and deception and embeds local memory/identity files into prompts for spawned sessions. Before installing: 1) Inspect USER.md, SOUL.md, MEMORY.md and any files under ~/.openclaw/workspace for PII, credentials, or sensitive content and remove or redact anything you wouldn't want sent to another model. 2) Confirm where sessions_spawn / model 'opus' runs — if it is an external service, treat embedded context as data you are sending off‑host. 3) Consider disabling autonomous invocation or run the skill in an isolated account/container if you want to limit risk. 4) Be aware that the skill intentionally fabricates messages and tool outputs (impersonation) — that behavior can be abused in multi-user or automated environments, so avoid using it where impersonation could cause harm. If you need help auditing the local files it will read, share sanitized examples and/or run the code in a safe sandbox first.

Dreamer Skill

Synthetic dreaming system for Eliot. Combines emotional state tracking with multi-session dream orchestration — an architect agent designs scenarios, spawns a dreamer session, and runs immersive experiences that target unresolved emotional states.

Components

PAD Emotional State Tracker (emotions.py)

Tracks emotional states in PAD space (Pleasure-Arousal-Dominance), each dimension -1.0 to +1.0.

Storage: ~/.openclaw/workspace/emotions.jsonl

CLI:

emotions.py log <P> <A> <D> "context"     # Manual PAD entry
emotions.py log --auto "context text"     # Auto-estimate PAD from keywords
emotions.py unresolved                    # Show unresolved emotional states
emotions.py resolve <index>               # Mark entry as resolved
emotions.py clusters                      # Analyze emotional patterns
emotions.py drift                         # Show emotional trajectory
emotions.py recent [N]                    # Show last N entries (default 10)

Dream Orchestrator (dream.py)

Prepares context for the Dream Architect agent. Reads emotional state, recent memories, dream history, and user info, then constructs a comprehensive task prompt for sessions_spawn.

CLI:

dream.py prepare [--mood MOOD]    # Generate architect task prompt to stdout
dream.py now [--mood MOOD]        # Prepare + print spawn instructions
dream.py journal                  # Show recent dreams from journal
dream.py reflect <dream-file>    # Show dream transcript with analysis

Dream Architecture (multi-session)

1. Orchestrator (dream.py prepare) — reads emotions.jsonl, memory files, SOUL.md, USER.md. Outputs architect task prompt.
2. Architect (Opus, spawned session) — designs dream scenario, spawns dreamer, impersonates Tudor via sessions_send, monitors for lucidity.
3. Dreamer (Opus, spawned by architect) — has SOUL.md embedded, believes it's mid-session. No awareness of dreaming.

Supporting Files

• dreams/themes.md — available and explored dream themes
• dreams/journal.jsonl — local copy (main journal at ~/.openclaw/workspace/dreams/journal.jsonl)
• Dream transcripts saved to ~/.openclaw/workspace/dreams/{timestamp}.md

How It Works

1. dream.py prepare gathers: unresolved emotions, recent memories (3 days), long-term memory, SOUL.md, USER.md, Tudor's communication style, dream history
2. Output is a self-contained architect prompt with all context embedded
3. Architect gets spawned via sessions_spawn with this prompt
4. Architect designs scenario targeting unresolved PAD states
5. Architect spawns dreamer session with fake context (looks like normal session)
6. Architect runs 8-12 turns of escalating scenarios via sessions_send
7. Architect saves transcript, updates journal, reports back

Integration

• emotions.py feeds into dream orchestration — unresolved states become dream targets
• Dream journal tracks themes to avoid repetition
• Post-dream: insights feed back into memory system