mycelium

Generate the validated "read" (prose) that accompanies extracted code facts — language-book chapters, reference-manual entries, and learning-corpus lessons — from the committed index JSON, with a mandatory faithfulness gate so nothing is hallucinated. Wraps tools/llm-harness/narrate/ (Generator -> FaithfulnessChecker -> Loop): only validated, cited prose is committed; the rest is dropped and reported (never silently). Deterministic Mock backends by default (offline/CI).

Classify a Rust construct's Mycelium native-translation strategy using the ratified DN-111 native-equivalence taxonomy — Native Equivalent · Idiomatic Remapping · Approximation · Interop Bridge (DN-110's Adaptation/Solution/Approximation/Bridge handles are permanent aliases). Runs DN-110 §9's six-step decision procedure: verify-first against the corpus, identify the underlying PROBLEM (not Rust's mechanism), classify by the {exact?}×{native?} generator, apply the DN-109 §3.2 auto-fire ratchet, and emit a register-style record with an honest, never-upgraded guarantee tag (VR-5).

Reconcile the repo's GitHub issues to the committed source of truth (tools/github/issues.yaml + idmap.tsv) the rate-limit-frugal, diff-based way: one bulk snapshot, only-the-deltas writes, dry-run by default. Hits the API only for issues that are missing (create) or drifted (update), skipping everything already in sync. A periodic DESKTOP operation (real API) — not for the cloud/web session.

Maintain Mycelium's changelogs. Keeps the top-level CHANGELOG.md (Keep a Changelog 1.1.0, ISO dates, design-phase framing) and each doc's changelog footer in sync with a change, and enforces the append-only status discipline (Draft→Accepted→Superseded, Resolved for notes). Use when finishing a change, moving a doc's status, or cutting a release.

Develop a change forward (up the tiers) the spec-first, staged, context-windowed way: spec/DN (requirements, DoD, user stories) -> public API -> private API -> component seam-map -> code, each stage a bounded working set that persists a compact artifact and drops from context once consumed (DN-96). Owns the staged design pipeline, the change-sizing check (soft ~1-2k / hard 4,000 LOC), and the precursor doc/index-branch mechanic; delegates isolation, review+merge-up, index regen, and the main landing to /worktree-guard, /pr-land, /doc-index + /tero-refresh, and /land, following DN-97's ratified Rank-1 batch-engine command sequences for the actual landing.

Propagate a squashed landing on `main` back down to the persistent lower trunks -- main -> integration -> dev -- via a plain, no-force merge per tier (DN-97 Rank 1, maintainer-ratified: same-content trunks make this trivially conflict-free -- no merge-driver, no veto, no keep-list). Landed through the same PR-merge mechanism /pr-land and /land already use for these protected branches, never a raw git push. Run once per batch after 1-6 disjoint work-set squashes land on main. Also covers the in-flight-adapt one-liner for a still-open work-set branch.

Get the resolvable citations for a mycelium-tero query — provenance only (anchor + file:line + the cited claim's guarantee tag), without the full item bodies. The provenance-first view of the transparent memory API (DN-87 / E39-1).

Get the EXPLAIN trace for a mycelium-tero query — why these sources, in what order: the candidate count, the ordering rule(s) applied, a per-hit reason, and any cross-reference edges that could not be resolved. The auditability view of the transparent memory API (DN-87 / E39-1).

Query the mycelium-tero transparent memory API (DN-87 / E39-1) for cited answers about this project's decisions, issues, docs, changelog, and skills — over MCP or HTTP, from any agent platform. Every answer carries resolvable citations; a query that finds nothing citable is a typed refusal, not an empty answer.

Reload the mycelium-tero memory API's served index from disk after the committed docs/tero-index/index.json has been regenerated — the freshness operation of the transparent memory API (DN-87 / E39-1). Requires the broader `refresh` token scope (not read-only).

Work the committed `.myc` draft corpus (`gen/myc-drafts/`, M-1002/M-1003): regenerate it deterministically, triage targets from the manifest, graduate a draft into `lib/` the hand-vetted way (M-993), and run an M-1006 ladder phase (bounded target set → rip → patch → record → feed lessons back into the transpiler). The corpus honesty contract binds throughout: everything under `gen/myc-drafts/` is `Declared` draft material — never imported by `lib/`, never dogfood-gated; drafts graduate only via hand-vetted port work with a differential witness.

Run the Rust→Mycelium transpiler WITH its real-toolchain vet loop (M-1000/M-1001, kickoff trx2): transpile targets, `myc check` every emitted `.myc`, and read the two honesty-split metrics — `expressible_fraction` (text emitted) vs **`checked_fraction`** (myc-check-clean, the number that matters). Per the M-991 verdict (DN-34 §8.7–§8.8, `Empirical`): the transpiler is a **gap-profiling instrument, not a bulk porter** — emitted `.myc` is a `Declared` starting point until a differential upgrades it; a mostly-gapped result is a successful, honest output (G2/VR-5).

Run the real native Mycelium toolchain over the self-hosted `lib/compiler/*.myc` frontend as a second, independent witness alongside the Rust `cargo test` differential — dual old-Rust + new-`myc` parity as the L1 frontend is ported to Mycelium (M-989 / boot10 / DN-26). Light checks only: `myc check` is the core parity check; `mycfmt`/`myc-lint` run advisory; heavy VSA/GPU-bound work is held out of the gate and belongs on a local/teleport machine. Non-gating by default (the port is in-progress until M-741) — a failure prints, never silently, but does not turn `just check` red.

Mycelium's implementation discipline. Apply when writing or changing code/docs in this repo: small auditable steps, tests-first, a property test for every bound, honest per-op guarantee tags, no black boxes (EXPLAIN), append-only decisions, grounded claims, and local↔CI check parity (`just check`) before committing.

Review a PR with a dedicated agent and land it UP the tree (leaf→dev, dev→integration). Spawns an isolated Sonnet /pr-review agent that posts findings as PR comments, patches what it finds, replies with the resolution, and updates the PR description; then — once review-clean and green — merges the PR into its base tier. The terminal merge to `main` is held for the maintainer (use /land for that squash). The agent-driven per-PR review loop, parameterized by PR number + base tier.

Run a concurrent wave of tightly-scoped work the safe, fast way: partition into disjoint items, spawn ONE isolated git worktree per agent, each leaf runs only change-scoped checks and updates only its own issue, each result is reviewed and merged up the tree via /pr-land, and the integration tier does the whole-batch polish/close-out. The umbrella for the concurrent-PR development pattern — maximum velocity with maximum accuracy, parameterized by the work-items list.

Assert the worktree-isolation discipline before any concurrent git work: one isolated git worktree per concurrent agent, and the orchestrator's main worktree a clean pointer. The idempotent, parameterized guard that keeps parallel agents from racing one checkout and cross-contaminating branches (CLAUDE.md mitigation #11) — the worktree analogue of /branch-guard.

Land a reviewed PR or branch onto main: self-review with the /pr-review lens, handle every CI / bot comment, run just check green, curated squash-merge to main (squash-only; internal swarm merges stay octopus/--no-ff), then branch + worktree cleanup.

Assert you are on the designated working branch and NOT on a protected branch (main/integration/dev/claude/head/*) before committing, merging, or pushing. The idempotent, parameterized guard that keeps work on its actual working branch and off the protected tiers — so the wrong-branch / commit-to-main failure mode cannot recur. Backs the harness-level PreToolUse hook + the git pre-commit/pre-push hooks.

Land work the Wave-N way, respecting protected bases. A child/working branch lands onto its head via a --no-ff PR (lineage preserved, NO squash); a completed head lands onto main via a curated SQUASH PR; then the squashed main is propagated back down (scripts/sync-heads.sh). Use when merging a completed unit into a head, or a head into main, in the multi-session head-branch workflow. Not for plain child-to-child merges below a head (those stay octopus/--no-ff with no PR) — use /land only for a single-branch squash onto main outside a wave.

Load and execute a stowed wave kickoff by its short UID (e.g. e7l, dfr, dfb). Reads .claude/kickoffs/<UID>.md + the standing context, then drives that task set on its protected head branch per the Wave-N workflow. Use at the START of a parent session when the user types "/kickoff <uid>" / "run kickoff <uid>" / "begin <uid>" — it is the context-optimized instigator that fires a stowed kickoff in its own session.

Regenerate and query the Mycelium agent code index (docs/api-index/), and validate doc_refs entries in issues.yaml. Use when you need to regenerate the committed agent index, query it for symbol locations, or check doc_refs validity.

Documentation review for the Mycelium corpus. Checks that cross-references resolve, notation is normalized, grounding labels are valid, ADR/RFC/DN status transitions are legal and append-only, and the changelog reflects the change. Most of this repo is normative docs, so this is the primary review for a docs-only diff.

Opinionated pull-request / diff review for the Mycelium repo. Enforces CONTRIBUTING.md — the honesty rule (per-op guarantee tags), append-only ADR/RFC discipline, grounding citations, and the "which FR/NFR/VR/SC + how verified" expectation — and does a hallucination/consistency pass. Auto-scales depth to the change (editorial → standard → deep) and can run an exhaustive all-severities pass.

Security review for the Mycelium repo, scaled to the change. Covers secrets, supply-chain (pinned deps, no curl|bash, lockfile integrity), shell/CI safety, input handling, and — for code — the usual vulnerability classes. Auto-detects docs-only diffs and runs a light pass; can run an exhaustive all-severities pass.