Skip to main content
skill CX Codex

dream · wrg32786 — Claude Code skill: lessons and installation

The dream Claude Code skill synthesizes session evidence into lessons and proposed changes. Run it to review recent sessions, consolidate notes, or spot recurring patterns.

MIT ★ 26 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add wrg32786/aigent-os --skill dream -a claude-code
Open on GitHub

What dream does

The skill gathers evidence from capsules, session logs, failure records, and other sources, then writes lessons and improvement candidates. Lessons go to vault/memory/runtime/LESSONS.jsonl; synthesis goes to vault/memory/DREAM_LOG.md. Each run appends a dated section, even when no lessons qualify.

A lesson is admitted when a pattern recurs across independent events, an operator directive has a separately observed outcome, or a mechanical check supplies exit codes. Generated candidates begin as proposed; only the operator’s exact decision can approve one. The skill does not apply changes or edit system instructions.

An explicit run needs Node and the aigent-os project root. It creates a temporary snapshot, then checks the written result with daemons/nightly-contracts.mjs. A nightly run uses the snapshot made by nightly-pass begin.

What it helps with

  • find recurring patterns across sessions
  • store evidence-backed lessons in JSONL
  • draft testable system-improvement candidates
  • filter one-off observations and unsupported claims

Example prompts for the agent

  • Run /dream to synthesize lessons from recent sessions.
  • Use /dream --window nightly for the nightly synthesis pass.
  • Set a candidate’s status with /dream --set-status <candidate-id> approved --operator-evidence "<direct operator reference>".

How to install dream

1Skills CLI (Vercel)

npx skills add wrg32786/aigent-os --skill dream -a claude-code

2Manually: put the files in place

~/.claude/skills/dream/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/dream/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about dream

How do I install dream in Claude Code?

Run npx skills add wrg32786/aigent-os --skill dream -a claude-code. The skill file is placed at ~/.claude/skills/dream/SKILL.md.

What does dream do?

It reviews operating evidence, records lessons, and drafts system-improvement candidates. Candidates remain proposed until the operator makes an explicit decision.

What does dream need to run?

An explicit run needs Node and the aigent-os project root. Nightly runs use a snapshot created by nightly-pass begin.

Source text

SKILL.md · MIT
---
name: dream
agent: none
description: "Synthesize lessons and propose improvements from recent operating evidence. Use when reviewing sessions, consolidating notes, or finding patterns."
allowed-tools: Read, Write, Bash
user-invocable: true
status: PRODUCTION - canonical writer and propose-only
triggers:
  - dream
  - offline consolidation
  - consolidation pass
  - improvement candidates
  - review recent sessions
---

# /dream - evidence-gated synthesis

`/dream` is the canonical writer for lessons and Dream synthesis. It never
applies an improvement, promotes its own proposal, edits system instructions,
or treats an agent-authored claim as verification.

## Canonical ownership

- Lessons: `vault/memory/runtime/LESSONS.jsonl`.
- Dream synthesis: `vault/memory/DREAM_LOG.md`.
- The documented `memory/` fallback is valid only for minimal installations.
- Any older `runtime/DREAM_LOG.md` copy is not an input or output.
- `/close` and `/nightly` invoke this protocol instead of carrying a competing
  inline writer.
- Candidate status transitions also go through this writer.

## Invocation

```text
/dream
/dream --window nightly
/dream --set-status <candidate-id> <approved|merged|rejected|blocked> \
  --operator-evidence "<direct operator reference>"
```

`proposed -> approved` always requires the operator's exact decision. Never
infer approval from silence, an automated status, another agent, or prior prose.

## Sources

Read, in order:

1. The newest five valid capsules by frontmatter `created_at`.
2. The newest five dated live Session Log blocks.
3. Open Trust Decay captures.
4. The newest three dated Honesty Ledger sessions.
5. Recent Failed Experiments and Failure Modes entries.
6. Existing Lessons JSONL for dedupe and prior evidence chains.
7. Staged `NIGHTLY_CAPTURE_CANDIDATES.jsonl` rows from the prior fire as
   discovery and pressure signals only.
8. Explicitly supplied local Git or command evidence.

Record exact source references. A capsule or Session Log entry can establish
that a claim occurred; it cannot prove the claim true.

## Lesson admission predicate

Append a lesson only when one is true:

- the same pattern appears in at least two independent source events;
- one explicit operator directive is paired with a separately observed
  outcome; or
- one mechanical red-before/green-after predicate supplies an artifact and
  literal exit codes.

Two retellings of one event are not independent. Discard one-off observations,
unverified causal stories, and self-confirmation.

Each admitted lesson has:

- `lesson_id`: next max numeric `lNNN` suffix plus one;
- `type`: `procedural | calibration | strategic | failure-mode | doctrine`;
- `confidence`: `0.0..1.0`, capped at `0.85` for one mechanical event;
- `source_events`: at least two refs unless an allowed exception applies;
- `created_at`: the configured local `YYYY-MM-DD`;
- `admission`: one of:
  - `{kind: "two-source"}`;
  - `{kind: "operator-outcome", operator_ref, outcome_ref}`;
  - `{kind: "mechanical-red-green", red_exit, green_exit: 0, artifact_ref}`.

Serialize UTF-8 JSON, parse the complete JSONL file after append, and confirm
the new line round-trips. Historical duplicate ids do not authorize a new
collision.

## Improvement candidate predicate

When evidence names a repeatable system gap, append this inside the same dated
Dream section:

```markdown
### ni-YYYYMMDD-NN - short name
- **status:** proposed
- **evidence:** source-ref-1; source-ref-2
- **failure class:** concise class
- **proposed_change:** smallest testable change
- **mutation proof:** break condition -> named red; restore -> named green
- **operator gate:** approve / reject / revise
- **operator evidence:** pending
```

Generated candidates always start with the literal field `status: proposed`.
Any generated `approved`,
`merged`, or self-ratifying wording is a hard failure.

## Canonical dated entry

Append one `## YYYY-MM-DD (...)` section every time synthesis runs, even with
zero admitted lessons. It must contain nonempty forms of all eight labels:

- Sources reviewed
- Lessons extracted
- Improvement candidates proposed
- Patterns observed
- Discarded as one-off
- Calibration miscalls
- Productive surprises
- Open trust-decay items to watch

A quiet run writes a minimal zero-lesson entry and appends no Lessons row.
Never overwrite an earlier entry.

## Executable postcondition

A nightly fire uses the snapshot created by `nightly-pass begin`. Explicit
`/dream` creates an operating-system temp snapshot first:

```text
node daemons/nightly-contracts.mjs snapshot --root <aigent-root> \
  --out <os-temp>/dream-contract-before.json
```

After writing:

```text
node daemons/nightly-contracts.mjs dream --root <aigent-root> \
  --date <YYYY-MM-DD> --snapshot <os-temp>/dream-contract-before.json
```

Only `DREAM_CONTRACT PASS` is green. The validator proves byte-prefix
preservation, parses JSONL, derives ids, validates admission, masks fenced
examples, requires the eight sections and current configured date, and rejects
a newly generated candidate that does not start `proposed`.

Return:

```text
DREAM PASS date=<YYYY-MM-DD> sources=<N> lessons=<N> candidates=<N>
```

© wrg32786 · MIT · wrg32786/aigent-os

Similar skills

SKILL.md skills catalog →

dream by other authors comes first.

dream sneg55 dream reviews an agent’s memory files, merges useful notes, and refreshes their index. Run it periodically to keep stored context organized. CX Codex +1 ★ 75repo stars dream-loop achimala dream-loop is a Claude Code skill that iteratively matches game or app visuals to a target rendering using screenshots. It supports tasks requiring high graphical fidelity. CX Codex +1 1,200installs memory_dream nwverse The memory_dream Claude Code prompt maintains a short note of stable user preferences and recurring workflows. It updates the note with explicit corrections and recent messages. GP ChatGPT ★ 395repo stars find-skills vercel-labs find-skills is a Claude Code skill that locates agent skills for a task and helps assess the results. It activates when someone asks for a capability that may already be installable. CX Codex +1 4,400,000installs frontend-design official anthropics The frontend-design skill guides intentional visual design for new interfaces and redesigns. Use it when a generic generated UI is not enough. CX Codex +1 1,025,790installs agent-browser vercel-labs This Claude Code skill automates browser interaction for tasks like navigating sites, filling forms, and testing web apps. It also supports exploratory QA and Electron app automation. CX Codex +1 1,600,000installs design-taste-frontend Leonxlnx The design-taste-frontend Claude Code skill sets design rules and checks for websites. It activates for new pages, redesigns, and requests to fix a generic-looking site. CX Codex +1 802,600installs grill-me Matt Pocock grill-me interviews you about a plan or design to expose gaps and sharpen decisions. Use it before implementation starts. CX Codex +1 1,424,476installs grill-with-docs Matt Pocock The grill-with-docs skill interviews you about a plan or design and creates ADRs and a glossary along the way. Use it when decisions need sharper definition. CX Codex +1 1,219,756installs

From the same set58

The whole set →
first-win This Claude Code skill offers three starter tasks that end with a usable artifact. Run /first-win to turn a post into social content, shape an idea into a plan, or sort email into priorities. CX Codex +1 ★ 26repo stars First 10 Moves First 10 Moves — a Claude Code skill for exploring an unfamiliar repository before changing code. It starts when a task involves tracing a bug, locating a module, or finding a place to begin. CX Codex +1 ★ 26repo stars find-weakness find-weakness — a skill for Claude Code and Codex isolates the single strongest objection and the riskiest unstated assumption in any architectural choice or claim. CX Codex +1 ★ 26repo stars Envelope The Envelope Claude Code skill sorts requests into three actions: proceed, ask one question, or propose a plan first. It activates when an agent must decide whether to act or pause for clarification. CX Codex +1 ★ 26repo stars digest The digest Claude Code skill reviews staged entries in MEMORY_CANDIDATES.md. It presents choices for each one: promote it, skip it, or replace an existing entry. CX Codex +1 ★ 26repo stars Diagnose Diagnose — a Claude Code skill that traces faults across aigent-OS components and settings. It investigates broken hooks, skill routing failures, and unexpected changes in agent behavior. CX Codex +1 ★ 26repo stars deep-recon The deep-recon Claude Code skill coordinates several agents to investigate a topic and create a structured recon document. It can draw on notes and web sources, with interactive or autonomous rounds. CX Codex +1 ★ 26repo stars decide This Claude Code skill weighs a decision against selected criteria and returns a structured recommendation. Run /decide to compare options or ask for help choosing a course of action. CX Codex +1 ★ 26repo stars

Project sponsors

Companies that keep this analytics open