# Wiki Add Task

> Capture ad-hoc ideas, bugs, tasks, or notes into the vault with ad-hoc capture frontmatter and descriptive filenames.

- Skill: `karlorz/wiki-add-task` (Agent Skill)
- Install (CLI): `npx skillmds@latest add karlorz/wiki-add-task`
- Raw SKILL.md: https://api.skillmd.com/api/skills/karlorz/wiki-add-task/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: karlorz (https://skillmd.com/u/karlorz)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/karlorz/wiki-add-task

---

# wiki-add-task
Capture ad-hoc ideas, bugs, tasks, and notes into the vault. Three entry points depending on where you are:
| Entry | When | What happens |
|-------|------|-------------|
| `/wiki-add-task <text>` | You're in a Claude Code session (NOT Hermes compact) | Creates `raw/transcripts/YYYY-MM-DD-{type}-{slug}.md` with ad-hoc capture frontmatter |
| Filesystem drop | Hermes Agent compact mode (no slash commands available) | Same as above — create `.md` in `raw/transcripts/`, dev-loop discovers it |
| Filesystem drop | You're NOT in a Claude session (Obsidian, editor, sync) | Create a new `.md` file in `raw/transcripts/` using the vault template — dev-loop discovers it on next cycle |
| Dev-loop discovery | Automatic, next cycle | Scans `raw/transcripts/` for new files since last cycle, surfaces as claimable work |
**Path Rule:** Captures ALWAYS go to `$(skillwiki path)/raw/transcripts/` (Layer 1). Never under `projects/{slug}/raw/` — that violates SCHEMA.md Layer 1 immutability. Text captures stay in `raw/transcripts/`. If the capture includes images or other binaries, store those files under `raw/assets/` with a sibling Markdown note that embeds them; never use a .txt sidecar (such as `README.txt`) as the only index; Obsidian opens Markdown notes.
### Exception: Explicit project task requests
When the user explicitly says "raise task to project X", "add a task for X", "create a feature request for X", or uses a directive structure like "raise task to {project} {description}", the intent is a **work item**, not a capture:
| User wording | Action | Target |
|---|---|---|
| "capture this", "note this", "remember this" | Use wiki-add-task (this skill) | `raw/transcripts/` |
| "raise task to project X", "add task to X project" | Escalate to `proj-work` | `projects/{slug}/work/YYYY-MM-DD-{slug}/task.md` |
| "save to wiki" + content | Use `wiki-ingest` | `concepts/`, `entities/`, etc. |
This is NOT a violation of the "ALWAYS" rule below — explicit project task requests are a distinct user intent that bypasses raw capture and goes directly to a Layer 3 work item.
## When This Skill Activates
- User invokes `/wiki-add-task` with a description.
- User says "add task", "capture this", "note this", "remember this", "log this idea", or similar.
- User provides a short text description and optionally a type tag.
- **Do NOT activate** when the user says "raise task to project X" or "add work item to project X" — escalate to `proj-work` instead.
## Output language
Run `skillwiki lang` at the start. Entry prose and `--human` summaries use the resolved language. Frontmatter keys, file names, and structural markers stay English.
## Steps
0. **Resolve vault and language.** Run `skillwiki path` (fail if NO_VAULT_CONFIGURED) and `skillwiki lang`.
1. **Parse arguments.** Extract from the user's message:
- `text` — the idea/bug/task/note content (required)
- `type` — one of: `idea`, `bug`, `task`, `note` (default: `idea`)
- `project` — optional project slug to cross-reference (e.g., `llm-wiki`)
2. **Sensitive content guard.** Before writing a capture, scan the text for live credentials, access keys, tokens, passwords, cookies, bearer headers, or private keys. Redact before writing. If the source text itself contains a live secret that must be preserved verbatim, STOP instead of filing it.
3. **Build filename.** Derive a slug from the first ~6 words of the text (lowercased, hyphens for spaces, non-alphanumeric stripped). The capture file is `raw/transcripts/YYYY-MM-DD-{type}-{slug}.md`. Each capture gets its own file — never append to an existing file.
4. **Write frontmatter.** Create the file with ad-hoc capture frontmatter:
```yaml
---
source_url:
ingested: YYYY-MM-DD
kind: {type}
project: "[[{slug}]]"
---
```
- Set `kind` to the parsed type (`idea`, `bug`, `task`, `note`).
- If a `project` slug was provided, set `project: "[[slug]]"`.
- If no project, omit the `project` field entirely.
- `source_url` is null (these are locally originated captures).
- `sha256` may be omitted for locally originated captures, but the completed capture is still immutable evidence. Corrections create a new capture or a maintained work-item note; never rewrite the existing transcript.
5. **Write body.** Below the frontmatter, write:
```markdown
# {type}: {text}
{text}
```
Use the resolved output language for any prose. The type label and frontmatter stay English.
6. **Cross-reference (optional).** If a `project` slug was provided:
- Check that `projects/{slug}/` exists in the vault.
- Append a one-line reference to the project's compound notes:
`- [YYYY-MM-DD] capture: [text (first 60 chars)] → raw/transcripts/YYYY-MM-DD-{type}-{slug}.md`
- Do NOT create a full work item (that's `proj-work`'s job).
7. **Update log.md.** Append: `## [YYYY-MM-DD] capture | [type]: [text (first 60 chars)]`
8. **Confirm to user.** Report what was captured and where. Suggest next steps:
- If `type: idea` → "Consider ingesting related sources to develop this idea."
- If `type: bug` → "Use proj-work to create a bug-fix work item."
- If `type: task` → "Use proj-work to track this task through the dev loop."
- If `type: note` → "Will be available for future wiki-query searches."
## Capture file format
Each capture is a standalone file with ad-hoc capture frontmatter:
```yaml
---
source_url:
ingested: 2026-05-08
kind: idea
project: "[[llm-wiki]]"
---
# idea: Fix the template mismatch
Fix the template mismatch between wiki-add-task and the vault template.
```
The `kind` field uses the capture type and must be one of: `idea`, `bug`, `task`, `note` (plus the existing `postmortem`, `session-log`, `meeting-notes`, `other` for non-capture raw sources).
The `project` and `kind` fields can be set independently — they do not require `work_item`. The `work_item` field is only used when the raw source is directly tied to a project work item (set by `proj-work`).
Ad-hoc captures may omit `sha256`; omission does not grant mutation authority. Once created, the transcript's content and frontmatter are immutable. The `sha256` field remains required for ingest pipelines that provide integrity verification.
## Stop conditions
- `skillwiki path` returns NO_VAULT_CONFIGURED.
- No `text` provided (prompt user once, then stop).
- Target file already exists (use a different slug or add a suffix).
- Capture text contains unredacted live credentials or other authenticating secrets.
## Forbidden
- Creating an `inbox/` directory. All captures go to `raw/transcripts/`.
- Appending to existing capture files — each capture gets its own file.
- Editing or correcting an existing raw transcript; create a new capture or maintained work-item note instead.
- Creating a work item — this is capture-only. Use `proj-work` for full work items.
- Writing to any Layer 2 or Layer 3 location. Captures are Layer 1 (raw).
- Writing live credentials, access keys, tokens, passwords, cookies, bearer headers, private keys, or other authenticating secrets to the vault.
- Indexing `raw/assets/` binaries with only a `.txt` sidecar.
## Filesystem drop (offline capture)
When you're not in a Claude session, drop files directly into `raw/transcripts/`:
1. Create a `.md` file in `raw/transcripts/` — name it descriptively (e.g., `2026-05-08-idea-fix-template.md`)
2. Use ad-hoc capture frontmatter: `source_url:`, `ingested:`, `kind:`, and optionally `project:`
3. Write your idea/bug/task/note below the frontmatter
No special format required — the dev-loop QUERY step will discover new files on the next cycle and surface them as claimable work. Mark the type with a heading like `## idea`, `## bug`, `## task`, or just write freeform.
## Dev-loop discovery
When the dev-loop QUERY step runs, it should scan `raw/transcripts/` for files with `ingested:` date newer than the last cycle. New files are surfaced as claimable work items. The agent then decides whether to:
- Create a work item via `proj-work` (for tasks and bugs)
- Ingest as a knowledge page via `wiki-ingest` (for ideas with sources)
- Leave in place (for notes that don't need action yet)