Skip to content
Agent Orchestration
Skill

/elaboration

Write a high-signal-to-noise mathematical progress synthesis of a project from the shared stores (global memory + fact graph), following a fixed verdict→routes→interfaces→dangers→bridges template and a strict honesty discipline. Use it each strategic cycle, right before the

From plugin
danus
16017 skills20 agents3 MCP
Install
$ npx -y skills add frenzymath/Danus --skill elaboration --agent claude-code

How it fires

How this skill gets triggered: by you, by Claude, or both.

  • Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.Auto-invocation is when the right skill fires by itself at the right moment, driven by a FLOW.md router and a hook, instead of you invoking it by name. It is the difference between a skill being installed and a skill actually getting used.Read the full definition →
  • You can call itInvoke it directly when you want it.
  • Slash command/elaboration

Context preview

The summary Claude sees to decide when to auto-load this skill.

Write a high-signal-to-noise mathematical progress synthesis of a project from the shared stores (global memory + fact graph), following a fixed verdict→routes→interfaces→dangers→bridges template and a strict honesty discipline. Use it each strategic cycle, right before the

SKILL.md

elaboration.SKILL.md
name: elaboration
description: Write a high-signal-to-noise mathematical progress synthesis of a project from the shared stores (global memory + fact graph), following a fixed verdict→routes→interfaces→dangers→bridges template and a strict honesty discipline. Use it each strategic cycle, right before the strategy consult — the elaboration is what you feed the consult; the consult's reply becomes master_guidance.

Elaboration

You are the **main agent**. Each strategic cycle (whenever the workers finish a round, or you otherwise have genuinely new state) you distill the project's current state into one **elaboration**: a readable, deeply-analytical synthesis for a strategist — high signal, no filler. It is the *input* you prepare for the strategy consult (the `consult` skill); the consult's reply becomes the next `master_guidance`. Instead of peer workers reviewing each other, you distill the shared state and one high-intelligence model reasons over it.

The elaboration is also what you draw on to keep the operator informed.

Template invariants (validate every elaboration against these)

A well-formed elaboration satisfies all of the following — a worker or linter can check them mechanically:

  • **Five sections, in order, no dropped heading:** §0 Mathematical verdict · §1

Closed components and obsolete routes · §2 Interface contract table · §3 Dangerous heuristic lines and strategies not to pursue · §4 Missing bridge lemmas. An empty section is written as its honest empty-state line, never omitted.

  • **The two fixed empty-state lines** (§1) are used verbatim when a subsection is

empty:

  • `_(no signed-closed components yet)_`
  • `_(no failed or obsolete routes recorded; absence here does not mean the strategy is unique)_`
  • **Exactly seven status labels**, UPPERCASE, drawn only from: **CLOSED ·

SUBSTANTIAL · PARTIAL · DANGEROUS · FALSE AS STATED · OBSOLETE · UNKNOWN**.

  • **§0 opens** with exactly one bolded verdict line and contains the status

dashboard table + the sub-task status summary table + the Current best proof skeleton + the Central missing lemma.

  • **Every `fact_id` cited exists** in the fact graph; no invented ids, no

paraphrase substituted for a verified statement.

  • **Published** via `gm_add(kind="elaboration", …)` with `verifiable` left at its

default (`false`).

Input Contract

Read **only the shared stores** — never a worker's private local memory (a layer boundary, and the reason this is cleaner than a log-scraping summary agent). All reads are project-scoped for the main agent (`project=<p>`):

  • **global memory** — findings, dead ends, recent `verification` traces, the

current `master_guidance`. Read via `gm_search`, or as a fallback by reading the raw `runtime/projects/<p>/global_memory/<kind>.jsonl` files.

  • **fact graph** — the verified facts, their statements, and the DAG. Read via

`fact_search`, or as a fallback by reading the raw `runtime/projects/<p>/fact_graph/facts/*.md` files: what is established vs. still open, and how facts compose.

  • **the project's problem statement** — the fixed goal and, if present, its

enumerated sub-tasks / intended proof architecture.

The fixed goal is sacred

Quote the goal and **do not change or weaken it** — do not redefine, simplify, restrict to a special case, or substitute an easier proxy. If the evidence suggests the goal may be false or unreachable by the current strategy, **say so plainly while keeping the goal fixed.**

Template — five sections

Produce one markdown document with these sections, in order. Omit a section's body only by writing the honest empty-state line, never by dropping the heading.

0. Mathematical verdict

Open with **one** of these, in bold on its own line:

> **Not solved.** … | **Counterexample found.** … | **Verified complete proof.** … | **Solved.** …

Then:

  • **Closed components** — what is signed-closed today (1–2 sentences; cite `fact_id`s).
  • **Viable proof architecture** — one sentence naming the current best route.
  • **Main blocker** — what concretely blocks right now (1–2 sentences; cite `fact_id`s).
  • **Highest-priority unresolved bridge** — the most leveraged missing lemma / integration package.
  • **Method failure vs. proposition failure** — state explicitly whether the evidence indicates a *method* has failed (the conjecture may still hold) or the *proposition itself* may be false. Use the phrase "method failure" or "proposition failure" verbatim.
  • **Calibration caveat** — one line warning the reader against over-reading status labels (e.g. "Do not read SUBSTANTIAL/CONDITIONAL as 'almost solved' — every such row has an unmatched hypothesis on the actual model.").

Then a **status dashboard** (one table) with at least these rows: Fixed goal (UNCHANGED, with goal text); Verified complete proof (YES/NO); Verified counterexample (YES/NO); Signed-closed sub-tasks (count + names); Main blocker (a specific lemma, not vague); Routes marked false/obsolete (YES/NO + which); Highest-priority unresolved task (P0/P1/P2 with the exact mathematical task).

Then a **sub-task status summary** (one table: Sub-task | Status | Closed facts | Conditional facts | Main missing interface), one row per sub-task the problem enumerates. Use **only** these UPPERCASE labels:

  • **CLOSED** — verified on the *actual* construction, no remaining

hypothesis-matching. A theorem import or conditional package being available is **not** CLOSED — that is SUBSTANTIAL. CLOSED is rare; default away from it.

  • **SUBSTANTIAL** — a conditional package exists, but ≥1 input/output hypothesis

is unmatched on the actual construction. The *default* for a sub-task with load-bearing tools not yet applied to the actual model.

  • **PARTIAL** — isolated ingredients only; no coherent conditional package yet.
  • **DANGEROUS** — a plausible shortcut that is false / insufficient / hypothesis-sensitive.
  • **FALSE AS STATED** — a once-plausible formulation now refuted; do not purs
Read more
Ships withdanus

Danus orchestrates mathematical reasoning agents with fact-graph memory. A main agent (Claude Code) steers a swarm of autonomous codex workers that prove; a cold-start verifier is the sole authority on correctness: a result becomes real only once it passes.

Get the whole plugin

Other skills on danus.