feat(cli): multi-harness batch reflection

[sarahwooders]

Summary

letta dream can now form memory from recorded coding sessions across multiple harnesses — Claude Code, Codex, OpenHands, Letta conversations, or pre-normalized files — not just the agent's own conversation history. It follows the batch-reflection prototype's design (normalize → batch → reflect → aggregate), adapted to letta-code's production subagent and memfs machinery.

How it works

 --from claude --from codex ...
        │
        ▼
 ┌─ normalize ─┐   sessions from each harness's local store are converted to a
 │             │   shared "normalized-v1" transcript format (one isolated
 └─────────────┘   module, src/agent/trajectories/)
        │
        ▼
 ┌─── batch ───┐   sessions are sorted by start time and greedily packed into
 │             │   batches under a token budget (default 60k, measured on the
 └─────────────┘   normalized content); an oversized session gets a solo batch
        │
        ▼
 ┌── reflect ──┐   ALL batches run at once, each as a fresh conversation on one
 │  (parallel) │   persistent hidden "dream-reflector" agent. Each batch edits
 └─────────────┘   its own GIT CLONE of the agent's real memory (taken at a
        │          shared base revision): it reconciles learnings against what
        │          is already stored — updating files in place, skipping what's
        │          already captured — and commits. Its diff vs the base is the
        ▼          batch's distilled output.
 ┌─ aggregate ─┐   one pass, by a persistent hidden "dream-aggregator" agent
 │             │   (default system prompt + the prototype's aggregator persona).
 └─────────────┘   Working in a memory worktree of the real memfs, it surveys
        │          the per-file change map across all diffs, decides structure
        │          changes (reorganize / combine / add / delete), optionally
        ▼          dispatches subagents for focused aspects (e.g. all human.md
     commit        changes), and lands ONE synthesized edit — no git merges.
                   The commit is merged back with recompile via the existing
                   reflection-finalize path.

Sources (--from, repeatable):

Spec	Selects
claude / codex	every session in ~/.claude/projects / ~/.codex/sessions
claude:<session-id-or-prefix>	that session and everything after it (time cursor)
openhands:<conversation-dir>	that conversation's events
letta / letta:<conv-id> / letta:<agent-id>	a recorded Letta conversation transcript
transcript:<file|dir>	already-normalized transcript files
<conversation-id> (bare)	the agent's own history — unchanged legacy single-reflection path

Every run is recorded under ~/.letta/transcripts/<agent>/.dream/runs/<run-id>/, one self-contained directory per batch (input/, output/ clone, diff.patch, trajectory.json, report.json — trajectories are fetched from the conversations API and normalized to the same format as the inputs), plus aggregate/ and a self-contained viz.html showing every agent's trajectory, report, inputs, memory tree, diffs, and agent/conversation ids.

Commands

# 1. Preview: which sessions would be selected, and how they pack into batches
letta dream --plan --from claude --from codex

# 2. Dream: reflect + aggregate into the agent's memory
letta dream --from claude --from codex                  # everything in both stores
letta dream --from "claude:<session-id>" --timeout 3000 # that session onwards

# 3. Inspect: regenerate/open the visualization for a recorded run
letta dream --viz latest        # also accepts a run id or path

# 4. Iterate: re-run ONLY the aggregation over a recorded run's batch outputs
letta dream --aggregate latest  # e.g. after changing the aggregator prompt

# Optional: --budget / --max-sessions (batch packing), --concurrency (cap
# parallel batches; default = all at once), -i "<instruction>" (focus the
# pass), --to ./AGENTS.md (maintain a doc from memory as part of the run)

Verified end-to-end on Letta Cloud (opus-4.6), on a fresh agent: 20 sessions (10 Claude Code + 10 Codex) → 9 concurrent batch reflections, 9/9 committed, 683 diff lines total → one synthesized aggregation commit producing 7 cohesive memory files, ~15 min wall clock.

Changes outside the new modules (kept minimal)

• subagents/manager.ts — reflection deploys get the same prompt-surface flags as fresh reflection agents; provider-fallback retry now forwards memoryScope (latent bug).
• tools/impl/shell-env.ts — the cross-agent memory guard recognizes the parent's .dream/ directory as parent-scoped (batch clones live there; without this the guard silently unset $MEMORY_DIR).
• headless.ts — subagent sessions no longer auto-enable memfs on cloud for deployed memfs-less workers.
• agent/create.ts — asSubagent option to create harness-managed worker agents (hidden, no memfs) from a non-subagent process.
• utils/transcript-paths.ts — getDreamRootDir (shared with the memory guard).
• Removed cli/subcommands/dream-sources/ — replaced by the trajectories module; transcript: now means normalized-v1 files.

Test plan

• bun run check — 10/10 pass
• Full unit suite — 0 fail (55 new tests: normalizer fixtures per harness, message conversion, batching, source-spec parsing, CLI arg validation)
• Live cloud runs exercising: multi-source selection + cursors, concurrent batch conversations against memfs clones, diff synthesis by the persona aggregator, aggregation-only re-runs, viz generation