dream — human judgment over the ranked docket

Purpose: the compounding engine (Primitive #4), now run as a deliberate human
session. Not scheduled.
Constitution: ../context-engineering/SKILL.md (load it first — taxonomy, homes,
hygiene rules all come from there).
Dockets (input): scripts/memory-rollup.py --json (knowledge substrate) +
../skill-builder/scripts/friction-rollup.py --view dream (friction ledger) — computed
live on every read, never stored; ac-human's cards read the same two. Status: MANUAL.

What dream is now

A deliberate, human-run session with the agent present. Not scheduled, not headless.
The docket is the input; the session is judgment, mining, and ruling. The operator reads the
ranked docket, rules each item, and the agent captures the decisions — and mines what
the sweep only flagged.

Nothing in dream runs unattended. No cron invokes it. The scheduled weekly CYCLE and
the daily review-queue job are gone — the jobs in <your-deployment>/jobs/weekly.json
sit disabled (see The polish gate). A session starts because a human starts it.

The automated leg — the sweep (findings only)

The mechanical sweep (<your-deployment>/dream-cycle/docket-sweep.py, optional —
write your own) does four things, and nothing else:

1. Verifies premises live — every pending proposal memo and open dream bead gets
   a verdict against HEAD: LIVE / ANSWERED / UNJUDGED / STALE-EVIDENCE.
2. Leaves ranking to the two rollups (above) — it writes no docket file.
3. Mints the single combined docket-review bead ('review dream dockets') if none
   is open (idempotent — the session's handle on the board; it never closes it).
4. Never decides anything. Findings only.

The sweep also closes answered-at-birth items, citing the deciding artifact. It never
rules on what remains. Judgment is the session's, not the sweep's.

Session workflow — three phases

Phase 1 — GATHER

Run both rollups (above) — the ranked rows and the flagged re-entries. Scan fresh ledgers since the last session
— friction logs, memory homes, wiki, pending proposals — so nothing the sweep's last
pass predates is missed. The dockets are the input; the fresh scan is the check.

Phase 2 — JUDGE (with the operator)

Rule each ranked item with the operator. Mine the consolidations and wiki refinements the
sweep flagged. Capture every ruling in EXACT phrasing — never paraphrase: the words
are the decision, and a paraphrase is a new decision nobody ruled on.

Phase 3 — EMIT

• Approved items become task beads born refined at apply time — implementation-ready
  because the human ruled in-session. Every bead carries the born-verified contract
  below.
• Rejected items are memo-marked so they do not re-enter the docket as live.
• The session ends with a gap analysis — what the substrate still doesn't know.
  The next session's GATHER starts there.

The gates stay (the born-verified contract)

Every task bead born in EMIT carries:

• evidence: / consequence: / recommendation:
• a Probe: line a gate can run
• origin:dream

Unverified premises do not file. A premise that no longer holds at HEAD is not
emitted — it stays on the docket for the sweep's next pass. (Bead conventions:
../beads-standards/reference/bead-conventions.md.)

The polish gate

Automation does not scale back up — crons, filing, auto-tier — until the manual loop
has run enough sessions to trust its output. The disabled jobs in
<your-deployment>/jobs/weekly.json are the marker: while they sit disabled, dream stays
a human session.

Common mistakes