distill

The #60 wiki-distiller (spec 2026-08-18 §3): batch-mine L1 narratives newer than the stored watermark for durable learnings the live wrap gate missed, and land them through the single write door, producer="distiller", capped at WRITE_CAP writes per run.

When to use

• /ren:distill — on-demand run (the first backlog-rescue run is this).
• The weekly routine (routines/distiller-weekly.md) runs the same flow.
• /ren:distill --seed-tree <project> — MANUAL TRIGGER ONLY (spec 2026-08-31 §3 behavior 1). Backfills the concept tree from a project's EXISTING knowledge/lessons/ pages — durable concepts written before concept-tree routing existed, or missed by a session's own wrap gate. This mode is NEVER part of the scheduled weekly routine; it runs only when a friend (or the live session, deliberately) asks for it by name.

Flow

1. Batch. uv run python -c "from skills.distill.lib import l1_batch, read_watermark; import json; print(json.dumps(l1_batch(read_watermark())))" from the framework repo (or the versioned plugin cache with UV_PROJECT_ENVIRONMENT redirected, same as /ren:update's convention). Empty batch → report "watermark caught up", stop.
2. Dedup context. For each distinct session in the batch, collect landed_pages(session).
3. Mine. Spawn ONE ren-distiller agent (worker-class) with the batch's escaped_body texts and the per-session landed sets. Parse its reply as the candidate JSON array. A malformed reply → stop, report, watermark UNTOUCHED.
4. Classify. Build one classifier prompt per candidate via build_classifier_prompt(item, eligible_targets=eligible_update_targets(source_session), project=...) and spawn ONE classifier-class subagent (batched, same pattern as /ren:wrap step 3) returning an index-keyed JSON verdict array.
5. Apply. Assemble candidates (lib shape: item/verdict/source_session/project/content=proposed_content/page=None) and call apply_candidates(candidates, run_session="distill-<date>", batch=batch, watermark_before=read_watermark()). Print the returned counts; a non-zero capped_remainder is reported as "N candidates carried to the next run"; duplicates (noop-duplicate replays) is reported separately and never counts against the cap.
6. Advance the watermark to result["watermark_after"] — ONLY if steps 3-5 completed without an exception AND watermark_after is not None. The lib computes it: a fully-processed batch (no remainder) advances to the batch's max ren_ts; a capped run advances only up to (not past) the earliest L1 belonging to a session with unprocessed candidates, so that session's L1s stay behind the watermark and get re-mined next run (spec §3.4, §3.5). A None watermark_after with a non-empty remainder means no advance this run — say so on the report screen. Any exception in steps 3-5 leaves the watermark untouched (re-run safe; the journal dedup makes replays idempotent).
7. Report. One screen: batch size, candidates, applied/held/suggested/gated_out/refused/duplicates, capped remainder, new watermark (or "no advance this run" when watermark_after is None).

--seed-tree <project> flow (Task 7, spec 2026-08-31 §3)

Manual trigger only — see "When to use" above. A single call does the whole run; there is no separate mine/classify subagent hand-off like the L1 flow above, because the candidates are already-written lessons, not narrative to mine, and this mode always has a live llm_call to gate them with.

1. Run. seed_tree(project, llm_call, cap=None) (from skills.distill.lib).
2. Internally: loads projects/<project>/schema.md's taxonomy — a missing or unparseable schema.md refuses the WHOLE run (result["blind"] is set, "no taxonomy — run ingest's taxonomy draft first"; run /ren:ingest-project or hand-seed a taxonomy first). Otherwise it enumerates projects/<project>/knowledge/lessons/*.md newer than the project's own seed_tree_watermark (kept separate from the scheduled distiller's watermark), gates each lesson body through the LIVE classifier, and for every kind == "concept" verdict that resolves to a brand-new taxonomy leaf: places it via the SAME concept-create machinery /ren:wrap uses (mints the page, maintains its leaf/parent hubs, additively splices schema.md), then appends a See: [[<node>]] pointer to the source lesson. Everything else (already-a-lesson verdicts, non-durable verdicts, an invalid concept placement) is skipped — advancing the watermark past it, since there is nothing to write for a lesson that's already sitting on disk as a lesson. Known limitation: a concept placement that resolves to an ALREADY- EXISTING taxonomy node is also skipped, and the source lesson is left un-annotated (result["existing_node_skipped"], distinct from result["gated_out"]'s classifier-noise cases) — --seed-tree does not accrete onto existing nodes; that machinery is /ren:wrap's own _concept_node_page + merge path. Backfilling accretion for this mode is future work, not this task's scope.
3. Report. Same counter shape as the L1 flow (applied/held/ suggested/gated_out/refused/duplicates/capped_remainder), plus annotated (the See: pointer UPDATEs — these count toward the cap exactly like any other write), existing_node_skipped, and blind.

What this skill does NOT do

• Write any wiki file directly — apply_candidates (and, for --seed-tree, the same concept-create machinery /ren:wrap uses) are the only write paths.
• Advance the watermark on a failed run, or past an unprocessed session's earliest L1 on a capped run.
• Touch quarantine banners, trust stamps, or the backup remote.
• Run --seed-tree on a schedule — it is manual-trigger only, never folded into the weekly routine.