# Dump

> Use when a long brainstorm or brain dump needs deep capture, prior-art routing, and durable next states.

- Skill: `lev-os/dump` (Agent Skill)
- Install (CLI): `npx skillmds@latest add lev-os/dump`
- Raw SKILL.md: https://api.skillmd.com/api/skills/lev-os/dump/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: lev-os (https://skillmd.com/u/lev-os)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/lev-os/dump

---


# /dump - Action Wrapper for /capture --deep

`/dump` is not a separate capture engine. It invokes `/capture --deep`, renders
the shared lifecycle ledger, then takes the obvious next lifecycle action only
when the ledger proves the row is durable and write-authorized.

## Entity Reconciliation

After authorized material progress, reconcile touched and causally affected
artifacts before routing, handoff, or final response. Track entity ref,
island/provider locator (a path for file storage), basis/evidence, and the
reason/action due. Update through the verified owning CLI/adapter; use a
write-authorized skill fallback only when that operation is unavailable.
Record updated, no_change(reason), or blocked(reason), preserving unresolved
refs. Reading or mentioning a path alone creates no update obligation.
Read-only work reports pending changes only. Reminders grant no write authority;
task status stays with the bound tracker. Update only artifacts whose content
or evidence changed; do not rewrite every referenced document.

## Work Link

Lifecycle lane: Shape -> Plan
Entity movement: `memory -> captured | proposed | execution_ready | blocked`
Workstream: resolve active workstream before writing capture artifacts
Upstream: conversation, `/work`
Downstream: `/capture --deep`, `/prior-art`, `/propose`, `/exec`
Router: `/work`
HUD: end with `🧬 {ws} ⚡{exec_count} 📥{capture_count} ⏸️{paused_count} ✅{done_count} | 🚦{gate}={score} | ⏭️ {next} | 🔁{loop_state}`

## Protocol

```yaml
steps:
  - id: invoke_capture_deep
    action: Run the /capture deep-mode inventory and fidelity loop.
    validation: "Every topic has a durable route or blocker and appears in the shared capture ledger."
    on_failure: "Return to /capture with the unresolved bucket."

  - id: render_capture_ledger
    action: Render the same compact <capture-results> delta used by /capture; retain the complete ledger in the durable artifact.
    validation: "The response names what was saved, what remains in memory, the highest-leverage decision, and the next route."
    on_failure: "Do not route. Show the full ledger only for --full, audit, or debug."

  - id: probe_prior_art
    action: Search existing work per topic before creating new artifacts.
    validation: "Each new proposal has no better existing home."
    on_failure: "Route to /prior-art and stop proposal creation for that topic."

  - id: route_next
    action: Take the next action for shovel-ready rows: /exec for execution_ready, /propose for aligned captured work, /interview for ambiguous rows.
    validation: "No routed item has current_location=memory without artifact_ref, blocker, or explicit write authorization."
    on_failure: "Show the blocked items and missing gate."
```

## Output

Render the `/capture --deep` delta:

Render the Markdown inside this template; do not print the XML wrapper tags.

<capture-results>
## /dump results

Saved: {count_and_artifact_refs_or_none}
Still in memory: {count_and_topics_or_none}
Decision needed: {one_highest_leverage_decision_or_none}
Ready next: {count_and_route_or_none}
Next: {one_primary_action}

Details: {ledger_artifact_ref_or_use_--full}
</capture-results>

## Red Flags

- "Dump can skip prior-art."
- "This is just a list."
- "We can leave low-priority items in memory."
- "Dump should implement its own capture protocol."
- "Dump can skip the shared ledger because it routes immediately."
- "A metric table is enough to prove what is on disk."
- "Dump can turn proposal language into writes without a canon write gate."

## Related

- `/capture --deep` owns inventory, fidelity, durable artifact writes, the canon write gate, and the shared ledger.
- `/prior-art` avoids duplicate artifacts.
- `/propose` creates task DNA and execution plans.
- `/exec` handles execution-ready entities.