with one click
distill
// Synthesize wiki pages from related memories. One endpoint, one flow: daemon clusters and synthesizes what it can; agent finishes whatever the daemon couldn't (no LLM or cluster too big). Invoked as `/distill [target]`.
// Synthesize wiki pages from related memories. One endpoint, one flow: daemon clusters and synthesizes what it can; agent finishes whatever the daemon couldn't (no LLM or cluster too big). Invoked as `/distill [target]`.
Social media scheduling and publishing for AI agents. Use when the user wants to schedule posts, connect social accounts, upload media, or publish campaigns to X, LinkedIn, Instagram, Facebook Pages, TikTok, Discord, Telegram, YouTube, Reddit, WordPress, or Pinterest through SocialClaw.
127 production skills across 10 categories (Security, Deployment, Dev, Business, Content, SEO, Marketing, Product, Automation, Core). Skills auto-load based on your task. Includes localhost dashboard with Agent Runner, Burn Report, and session diary.
Session-start briefing from Origin. Reads the project status file (the /handoff-maintained ledger of Active/Backlog work), then loads identity, preferences, and topic-relevant memories so the agent walks in with context. Surfaces any memories the daemon has flagged for human revision before the session uses them. Invoked as `/brief [topic]`. Call FIRST at session start, before any other Origin verb.
Save a memory to Origin in flow. Active capture verb — use proactively when the user states a preference, makes a decision, corrects you, or shares a durable fact. Invoked as `/capture <content>`.
Alias for `/origin:handoff` — symmetric brief/debrief naming. Same behavior: end-of-session ritual that writes session log + project status + granular MCP captures. Invoked as `/debrief`. Use when the user prefers the brief/debrief pair over brief/handoff.
End-of-session ritual. Captures decisions, lessons, gotchas, and open threads. Writes a narrative session log to ~/.origin/sessions/ and stores granular memories via Origin MCP. Previews any unconfirmed captures from the current session before closing. Invoked as `/handoff`.
| name | distill |
| description | Synthesize wiki pages from related memories. One endpoint, one flow: daemon clusters and synthesizes what it can; agent finishes whatever the daemon couldn't (no LLM or cluster too big). Invoked as `/distill [target]`. |
| argument-hint | [target | rebuild <page-id> | deep] |
| allowed-tools | ["mcp__plugin_origin_origin__recall","mcp__plugin_origin_origin__distill","mcp__plugin_origin_origin__create_page","mcp__plugin_origin_origin__update_page","mcp__plugin_origin_origin__delete_page","mcp__plugin_origin_origin__get_page_sources","Bash"] |
Force a distillation pass now. The daemon's background distill cycles run
on its own clock; /distill is the explicit user-triggered pass.
Distillation is four operations bundled into one flow:
The default flow runs all four. The rebuild verb is a destructive opt-in
that overrides the lock on a single page.
One POST to the daemon. Response splits into:
pages_created / created_ids: pages the daemon synthesized itself
(only when daemon has an LLM).pending: clusters the daemon couldn't finish. The agent
synthesizes each in this session and POSTs them back to /api/pages.Trigger timing is the only thing that differs between background distill cycles and this skill. Code path is the same; daemon hands back clusters when it can't synthesize; whoever called fills in the rest.
For bare /distill, infer a target from cwd:
Bash: top=$(git -C "$PWD" rev-parse --show-toplevel 2>/dev/null); \
common=$(git -C "$PWD" rev-parse --git-common-dir 2>/dev/null); \
if [ -n "$common" ]; then \
case "$common" in /*) root=$(dirname "$common");; *) root=$(cd "$top" && cd "$(dirname "$common")" && pwd);; esac; \
basename "$root"; \
fi
origin).basename "$PWD".deep → no scope (global pass).rebuild <page-id> → call
distill(target=<page-id>, force=true). Confirms "Rebuild page ?
Your edits will be wiped, page regenerates from sources." before
proceeding. Skip the rest of this skill — single-page rebuild does
not produce pending clusters; the daemon's response shape is
{"status": "ok", "force": true, "page_id": ..., "updated": true}.
Report verbatim.For /distill <arg> → forward <arg> to target.
distill(target="<scope>")
The tool returns the daemon's full JSON payload as text. Parse it as JSON. Possible shapes:
{
"pages_created": 0,
"scoped": true,
"created_ids": [],
"pending": [
{ "source_ids": [...], "contents": [...], "entity_id": ...,
"entity_name": ..., "space": ..., "estimated_tokens": ... },
...
],
"stale_pages": [
{ "page_id": ..., "title": ..., "summary": ...,
"source_memory_ids": [...], "stale_reason": "source_updated",
"user_edited": false, "sources_updated_count": 3 },
...
],
"stale_truncated": false,
"orphan_topics": [
{ "label": "Topic Z", "count": 3 },
...
]
}
The route never invokes the daemon LLM. created_ids is always empty
when called from this skill; pending carries every cluster the
daemon found. The agent synthesizes them in this session — that's why
the LLM choice is consistent with how the user invoked the skill.
unresolved + hint: relay to user verbatim and stop.
pending clusterThe daemon route filters out clusters fully covered by an existing page (subset or Jaccard ≥ 0.8). What remains is either:
existing_page_id is set) → the cluster
has new memories beyond what's in the matched page. The agent has
LLM access, so the right move is to refresh the existing page in
the same pass.Cluster shape:
pending: [
{
source_ids, contents, entity_id, entity_name, space,
estimated_tokens,
existing_page_id?, existing_page_title?, new_memory_count?
},
...
]
For each cluster, first run a coherence check before synthesizing:
cluster.contents.Origin but spanning RwLock bugs, schema choices, onboarding UI,
migrations, and CSS), the cluster is incoherent. Skip
synthesizing it. Record it for the report under "Skipped (low
coherence)" with the existing page title (if refresh) or a short
topic hint (if new).The coherence judgement is something only the agent can do — it needs to read the prose. Daemon clustering is heuristic; agent is the final filter against producing a grab-bag page.
For each coherent cluster:
existing_page_title when refreshing
unless the new memories materially change the topic. For new
clusters: cluster.entity_name if specific, otherwise derive from
the first memory's content.[[wikilinks]]. Cite source
ids inline with (source: mem_XXX).New cluster (no existing_page_id) — call the MCP tool:
create_page(title="...", summary="...", content="...",
entity_id="<cluster.entity_id or omit>",
space="<cluster.space>",
source_memory_ids=[...])
Refresh candidate (existing_page_id is set) — replace the body
in place via the update_page MCP tool. This is a single atomic
call: replaces content + source list + optional summary, clears the
daemon's stale_reason, bumps version, preserves page_id +
created_at so external [[wikilinks]] keep working.
update_page(page_id=cluster.existing_page_id,
content="...",
source_memory_ids=cluster.source_ids,
summary="...")
The stale_pages block in the response lists pages whose sources
changed since last compile. Shape:
stale_pages: [
{ page_id, title, summary, source_memory_ids,
sources_updated_count, stale_reason, user_edited },
...
]
stale_truncated: <bool> # true when 10+ stale pages exist
For each stale page:
user_edited == true → never auto-rewrite. The user touched
the page; the upstream memories also changed. Surface in the
"Conflict" report block and stop. The user resolves by hand, OR
runs /distill rebuild <page-id> to wipe their edits and
regenerate from sources.user_edited == false → fetch source memories via
get_page_sources(page_id="<id>"), run the same coherence check
used for clusters, then call update_page with the existing
source_memory_ids and freshly synthesized prose.update_page(page_id=stale.page_id,
content="<refreshed prose>",
source_memory_ids=stale.source_memory_ids,
summary="<optional refreshed claim>")
When stale_truncated == true, tell the user "more stale pages
remain — re-run /distill after this pass to continue."
orphan_topics lists wikilink labels that 2+ existing pages reach
for but no page is named for. Each entry is a topic-discovery
signal — other pages are asking for this page.
Do not auto-create pages from this list — the agent doesn't have
the source memories at hand, and an empty-stub page is worse than no
page. Surface them in the report so the user can choose to run
/distill <label> intentionally:
Topic suggestions (other pages link here, no page yet):
- "Topic Z" (3 pages reference it)
- "Other" (2 pages reference it)
Skip the section when orphan_topics is empty.
Three output shapes. Pick the one that matches what happened.
If pending is empty (every cluster already fully covered):
Scope `<scope>` is up to date — no new memories to distill.
If at least one cluster was synthesized:
Distilled N page(s) from <total> memories in scope `<scope>`:
- <Title> v1, synthesized from <K> sources
- <Title> v3 → v4: +mem_xyz, +250 chars
...
For each page, create_page and update_page return a WriteResult
whose warnings array carries a pre-formatted delta line from the
daemon (e.g. "v3 → v4: +mem_xyz, +250 chars"). Render it verbatim
after the title. When warnings is empty or the call returned no
WriteResult, fall back to:
v1, synthesized from <K> sources (K = source_ids length)refreshed (bare, as before)This lets the user see exactly what changed per page without opening each file.
If at least one cluster was skipped on the coherence check:
Skipped M cluster(s) — low coherence (memories share entity but
topics scatter; would produce a grab-bag page):
- "<existing_page_title or topic hint>" (<N> memories)
...
If at least one stale page was refreshed:
Refreshed K stale page(s):
- <Title> v2 → v3: +mem_abc, +180 chars
- <Title> refreshed
...
Same delta-line rule as new/refresh clusters: render warnings[0]
from the update_page WriteResult verbatim; fall back to refreshed
when absent.
If at least one stale page was skipped because user_edited:
Conflict on L stale page(s) — page has user edits, sources also
changed. Open and reconcile manually:
- <Title> (~/.origin/pages/<slug>.md)
Distinct wording from the coherence-skip block so the user can tell the two reasons apart at a glance.
Emit the blocks back-to-back when more than one outcome happened in the same pass.
When the only outcome is skipped clusters (and pending was
non-empty), still emit the Skipped block. Do not report "up to
date" in that case — the scope isn't up to date, the candidates were
just too low quality.
Rules:
/read "<title>"
for that.<total> = sum of source_ids.len() across the clusters that were
actually synthesized.After writing the pages above, snapshot the change so the user can git log their memory's life timeline. Defensive — silent skip if git is
missing or ~/.origin/ is not a repo yet.
Bash: git -C ~/.origin add -A && \
git -C ~/.origin -c user.name=Origin -c user.email=daemon@origin.local \
commit --quiet -m "distill: <N> pages" 2>/dev/null || \
(sleep 1 && git -C ~/.origin add -A && \
git -C ~/.origin -c user.name=Origin -c user.email=daemon@origin.local \
commit --quiet -m "distill: <N> pages" 2>/dev/null) || true
The retry handles index.lock races — the daemon may be writing to
~/.origin/ at the same moment (auto-commit from captures). One-second
wait is enough for the daemon to release the lock.
/distill rebuild <page-id> when you want to wipe a page you
previously edited and have the daemon regenerate from current
sources. Destructive: your prose goes away. Use after you are
done curating a page and want it back on the auto-refresh path.Each cluster the agent synthesizes counts against this session's tokens. Daemon-side clusters (when an LLM is present) cost daemon LLM tokens instead (cents on API, seconds on-device). Either way, keep cluster sizes reasonable — the daemon already enforces a per-cluster token budget via its tuning config.