From claude-obsidian
Rolls up wiki log entries into extractive meta-pages with dry-run and commit modes, using deterministic fold IDs and concurrency locking.
How this skill is triggered — by the user, by Claude, or both
Slash command
/claude-obsidian:wiki-foldThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Implements a bounded subset of Mechanism 1 from [[DragonScale Memory]]: flat fold over raw `wiki/log.md` entries. Fold-of-folds (hierarchical level-stacking) is **out of scope for this skill**; see "Scope boundary" below.
Implements a bounded subset of Mechanism 1 from [[DragonScale Memory]]: flat fold over raw wiki/log.md entries. Fold-of-folds (hierarchical level-stacking) is out of scope for this skill; see "Scope boundary" below.
A fold is additive: child log entries and their referenced pages are never modified, moved, or deleted. A fold is extractive: every outcome and theme in the output must be traceable to a specific child log entry. No invented facts, no synthesis beyond what the child entries support.
This skill does not implement:
It does implement:
k.When referring to level in frontmatter, use batch_exponent: k (not level: k), because this skill does not produce hierarchical levels.
| Mode | Writes? | Invocation |
|---|---|---|
| dry-run (default) | No Write tool calls. Emit fold content via Bash cat/heredoc to stdout only. | fold the log, dry-run k=3 |
| commit | Uses Write/Edit tools. Each Write fires the repo PostToolUse hook which auto-commits wiki changes. Accept this. Compose full content first, then sequence writes. | fold the log, commit k=3 (only after a clean dry-run) |
Why stdout-only in dry-run: the repo's hooks/hooks.json PostToolUse hook fires on any Write|Edit and runs git add wiki/ .raw/. Writing to /tmp does not stage /tmp, but it still triggers the hook, which will commit any pending wiki changes under a generic message. Dry-run must leave zero residue. Bash stdout does not fire the hook.
The fold-page write in commit mode MUST be preceded by wiki-lock acquire:
FOLD_PATH="wiki/folds/${FOLD_ID}.md"
bash scripts/wiki-lock.sh acquire "$FOLD_PATH" || {
echo "FAIL: another writer holds $FOLD_PATH; aborting fold."; exit 75
}
# … write the fold via Write/Edit (which fires the PostToolUse hook) …
bash scripts/wiki-lock.sh release "$FOLD_PATH"
Fold pages are deterministically named (fold-k{K}-from-{DATE}-to-{DATE}-n{COUNT}.md), so two parallel folds with the same parameters target the same path. Without the lock, they could overwrite each other's outputs. The duplicate-detection check inside this skill (already documented below) handles the "fold already exists" case at the SKILL level; the lock handles the in-flight-write race at the OS level.
Dry-run mode does not acquire a lock (no writes happen).
See skills/wiki-ingest/SKILL.md §Concurrency for the full lock semantics.
Every fold has an ID derived from its inputs:
fold-k{K}-from-{EARLIEST-DATE}-to-{LATEST-DATE}-n{COUNT}
Example: fold-k3-from-2026-04-10-to-2026-04-23-n8.
The filename in commit mode is wiki/folds/{FOLD-ID}.md. No date-of-creation in the filename. No timestamp in the title.
Duplicate detection (required): before emitting any output, check if wiki/folds/{FOLD-ID}.md already exists. If so, report "Fold already exists at wiki/folds/{FOLD-ID}.md. Use --force to overwrite, or pick a different range." and stop. This is the no-op idempotency guarantee; byte-identical content is NOT guaranteed (LLM prose varies) but the filename and scope are.
k (default 4): batch exponent. Batch size = 2^k. Typical values: k=3 (8), k=4 (16), k=5 (32).range (optional): explicit entry range entries 1-16. Overrides k.--force: overwrite an existing fold with the same ID. Default no.--commit: write to wiki/. Without it, dry-run stdout-only.If fewer than 2^k log entries exist, report the shortfall and stop. Do not silently fold a partial batch.
grep -n "^## \[" wiki/log.md | head -{2^k}
Record for each entry: line number, date, operation, title, and the following bullet lines until the next ## [ or end-of-section.
From each entry's bullet list, extract:
Location: wiki/path/to/page.md (the primary page)[[Wikilinks]] inlinePages created: and Pages updated: listsBuild a structured children list:
children:
- date: "2026-04-23"
op: "save"
title: "DragonScale Memory v0.2 — post-adversarial-review"
page: "[[DragonScale Memory]]"
- ...
One record per log entry. Do not dedupe by page: if two entries both point to [[DragonScale Memory]], both records appear, distinguishable by date and title.
Read only the pages that are not already captured fully in the log entry's bullets. Budget: 0-10 page reads. Hard ceiling: 15. If an entry's referenced page is missing, record page_missing: true and proceed.
Write the fold body per references/fold-template.md. Rules:
(from 2026-04-14 session)) or a quoted line from that entry. Do not introduce events, counts, or interpretations not present in a child entry.Before printing output, verify:
children: frontmatter appears exactly once in the Child Entries table.children: frontmatter.--force is set).If any check fails, abort and report the specific failure.
Dry-run: use Bash cat <<'EOF' ... EOF to stdout. Do not use Write. Print the fold ID and a one-line summary of what the commit step would do.
Commit (only after user says "commit the fold"):
Write the fold page to wiki/folds/{FOLD-ID}.md. (PostToolUse hook will auto-commit this.)Edit wiki/index.md to add the fold link under a ## Folds section (create section if missing). (Hook auto-commits.)Edit wiki/log.md to prepend one entry:
## [YYYY-MM-DD] fold | batch-exponent-k{K} rollup of N entries
- Location: wiki/folds/{FOLD-ID}.md
- Range: {EARLIEST-DATE} to {LATEST-DATE}
- Children: N log entries
(Hook auto-commits.)Three auto-commits result. The user sees three separate wiki: auto-commit entries in git log. This is expected; do not attempt to suppress the hook.
See references/fold-template.md for the canonical frontmatter and body layout.
wiki/hot.md. Ownership stays with save/ingest skills.Committed fold reversal (three commits, land in this order):
Or: git revert the three auto-commits. Child pages are untouched in either path.
User: "fold the log, dry-run k=3"
wiki/log.md top 8 entries.fold-k3-from-2026-04-10-to-2026-04-23-n8.wiki/folds/fold-k3-from-2026-04-10-to-2026-04-23-n8.md does not exist.cat <<'EOF' ... EOF to stdout.When working on this skill, apply the 10-principle loop. See skills/think/SKILL.md for the canonical framework.
| # | Principle | Application here |
|---|---|---|
| 1 | OBSERVE (ext) | Read the last 2^k log entries FULLY. Skimming defeats extractive summarization. |
| 2 | OBSERVE (int) | Am I tempted to synthesize beyond what the child entries support? Extractive-only is the binding rule. |
| 3 | LISTEN | Which themes emerge naturally from the child entries? Don't impose themes from outside the children. |
| 4 | THINK | Extractive only. Every outcome must be traceable to a specific child entry. Count check at the end. |
| 5 | CONNECT (lat) | Cross-entry patterns ARE the value-add. The single-entry view misses these. |
| 6 | CONNECT (sys) | DragonScale Mechanism 1 + wiki-lock + address allocator. Folds are part of the memory architecture. |
| 7 | FEEL | A good fold lets future-me skim a year of work in 5 minutes. Aim for that compression. |
| 8 | ACCEPT | Dry-run first. Commit only when the self-check passes. Honor the bounded-scope constraint (no fold-of-folds yet). |
| 9 | CREATE | Fold page at wiki/folds/<fold-id>.md linking to all child entries. |
| 10 | GROW | Fold-of-folds (hierarchical level-stacking) is v_next scope — note as you encounter it, don't sneak it in. |
npx claudepluginhub agricidaniel/claude-obsidian --plugin claude-obsidianArchives old build log entries from _meta/log.md into summary pages in _meta/folds/ to prevent unbounded growth. Use when log.md exceeds 200 entries.
Build, maintain, and query a personal LLM-managed markdown wiki where the LLM owns all writing, cross-referencing, and bookkeeping while the user curates sources. Includes idempotent scripts for ingest, query, and lint.
Maintains Obsidian-based LLM-driven wiki: ingests research papers/sources, compiles knowledge, manages topics/milestones/cross-references, queries wiki, runs lint checks.