raisedadead/file

File a Task

Current Stage

!dp-engine state 2>/dev/null || printf '{"stage":"idle"}'

Quick-capture minion for ad-hoc tasks, action items, and ideas. Takes a rough description and files a well-formed task under the FILING-CABINET epic, enriched with relevant context.

This skill has NO opinions about planning, execution, or polish. It captures and files — nothing more.

Filed tasks are created with deferred status — they CANNOT be picked up by dp-engine ready or dispatched by run. To begin work on a filed item, it must be explicitly promoted for planning.

Title Convention

Every filed task title MUST use the format VERB: description. Pick the verb that best describes the intent:

| Verb | When to Use | | ---------- | ---------------------------------------------------------------------------- | | BUG | Something is broken or behaving incorrectly | | FEATURE | New capability or skill to build | | IMPROVE | Enhance existing functionality, refactor, polish | | AUDIT | Investigate, compare, verify, assess quality | | ENFORCE | Add or strengthen a guardrail, validation, or gate | | CONSIDER | Open question, trade-off to evaluate, no commitment yet | | FIX | Known issue with a clear fix path (not a bug report — the fix is understood) | | SPIKE | Timeboxed investigation, research prototype — outcome may be DON'T DO IT |

If the user's request doesn't clearly map, default to IMPROVE.

Step 1: Parse the Request

Extract from the user's message:

• What: the core ask (action item, bug, idea, reminder)
• Why: any stated motivation or urgency
• Where: any referenced files, modules, or systems
• Priority: if the user says P0/P1/P2/P3/P4 or urgent/high/low, map it (default: P3)

Priority mapping: urgent/critical → 0, high/P1 → 1, medium/P2 → 2, normal → 3, low/backlog → 4

If the request is vague, ask ONE clarifying question. Do not over-interrogate — the point is fast capture.

Step 1.5: Dedup Check

Before creating a new issue, search for existing closed/deferred items with similar keywords:

dp-engine search "[2-3 keywords from title]" 2>/dev/null

Parse the JSON results. Filter for items where the title is similar to the new filing.

If matches found, present them to the user:

Found existing items that may be related:

• {id} ({status}) — {title}

Options:

1. Reopen an existing item (append new context)
2. File as new (no duplicate)

If the user picks reopen: run dp-engine reopen "{id}", then append the new context as a comment or updated description. STOP — do not create a new issue.

If the user picks file new or no matches found: proceed to Step 2.

Step 2: Enrich with Context

Before filing, silently gather context to make the task self-contained when reviewed later:

1. Conversation context — what are we currently working on? What epic/task is active? Summarize in 1-2 sentences.
2. Tracker memories — run dp-engine memories and check if any stored insight is relevant. If so, reference it.
3. Auto-memory — check ~/.claude/auto-memory/MEMORY.md for relevant user preferences, project context, or feedback that should inform this task.
4. Code pointers — if the request references code, include file paths and line numbers. Do not paste code — just pointers.
5. Active work link — if dp-cto is installed and has an active epic, note its ID so the filed task can be linked later.

Step 3: Compose the Task

Write a task description in this format:

## What
[1-2 sentence clear statement of what needs to happen]

## Context
[Why this was filed, what we were working on, any relevant memories or active work]

## Pointers
[File paths, issue IDs, tracker references, memory keys — anything that helps when this is picked up later]

## Origin
Filed during: [current epic or "ad-hoc session"]
Date: [today's date]

Keep it concise. The goal is capture, not specification.

Step 4: File It

Use ONLY dp-engine subcommands. The FILING-CABINET is an epic with the dp-cab:cabinet label.

Important: Do NOT put inline descriptions inside bash -c '...' — shell metacharacters in the description text will break the command. Call dp-engine directly:

Call 1 — Find or create cabinet:

cabinet=$(dp-engine query "label=dp-cab:cabinet AND type=epic AND (status=open OR status=deferred)" 2>/dev/null | jq -r ".[0].id // empty")
if [ -z "$cabinet" ]; then
  cabinet=$(dp-engine create "FILING-CABINET" --type epic --label dp-cab:cabinet --description "Persistent inbox for ad-hoc tasks and ideas." | jq -r .id)
  dp-engine update-status "$cabinet" deferred 2>/dev/null
fi
echo "$cabinet"

Call 2 — Create the task (pipe description via stdin to avoid escaping):

When the VERB prefix is SPIKE, substitute spike for the literal task issue type in the command below — timeboxed investigations are filed as spikes so they surface as such on the board. All other VERBs use task.

task=$(dp-engine create "[TITLE]" --type task --parent "[CABINET_ID]" --priority [PRIORITY] --description "[DESCRIPTION]" | jq -r .id)
dp-engine update-status "$task" deferred 2>/dev/null
echo "$task"

Quote [DESCRIPTION] and [TITLE] carefully in the caller — dp-engine has no stdin mode; shell escaping is the caller's responsibility.

If the tracker is unavailable, report the enriched task as a markdown block and tell the user to file it manually later.

Step 5: Confirm

Report:

Filed: {task-id} (P{priority}, deferred) — {title} under FILING-CABINET ({cabinet-id}).

If dp-cto is installed and has an active epic, ask: "Link this to the active epic via discovered-from?" If yes:

dp-engine create-side-quest "{title}" --origin "{active-epic-id}" --description "{description}"

NEVER

1. NEVER ask more than one clarifying question — this is fast capture
2. NEVER modify existing tasks or epics — only create new ones
3. NEVER block on a missing tracker DB — fall back to markdown output
4. NEVER invoke any non-dp-engine tracker CLI — always use dp-engine subcommands
5. NEVER set status to open — filed tasks are always deferred until explicitly promoted