oliverweissl/context-garden / skills/mycelium
mycelium
VerifiedDecide whether to spawn subagents (one, or several in parallel) to search, investigate or edit, and brief them well; passes finding notes between agents so they don't redo the same exploration. Use before delegating to an agent and after an agent reports findings.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 3.2 KB |
| agents/botanist.md | markdown | 927 B |
| agents/landscaper.md | markdown | 1.3 KB |
| agents/scout.md | markdown | 1.3 KB |
| bin/myceliumexecutable | script | 1.2 KB |
| references/protocol.md | markdown | 5.1 KB |
| scripts/cg_mode.py | script | 5.4 KB |
| scripts/my_budget.py | script | 4.7 KB |
| scripts/my_gate.py | script | 7.7 KB |
| scripts/my_store.py | script | 14.0 KB |
| scripts/mycelium.py | script | 10.9 KB |
| tests/fixtures/mini_repo/README.md | markdown | 39 B |
| tests/fixtures/mini_repo/src/middleware.py | script | 167 B |
| tests/fixtures/mini_repo/src/refresh.py | script | 210 B |
| tests/smoke_test.sh | script | 13.6 KB |
scripts/cg_mode.py
View on GitHub#!/usr/bin/env python3
"""Per-skill mode: on (Claude uses it automatically), manual (only when the
user calls it, e.g. `/compost <instruction>`), off (not used; the default).
Identical copy in every context-garden skill (skills never import each other).
The mode is stored where Claude Code's own `skillOverrides` setting lives, so
the `/skills` menu and this tool agree:
on -> "on", manual -> "user-invocable-only", off -> "off" ("name-only" reads as on).
Resolution: $CONTEXT_GARDEN_MODE_<NAME> > <git root>/.claude/settings.local.json
> <git root>/.claude/settings.json > ~/.claude/settings.json > off.
Claude Code applies skillOverrides natively only to standalone skills (not
plugin skills), so SKILL.md also injects `mode --banner` and hooks check
`--is-on`; that makes the mode hold for plugin installs too.
Usage: cg_mode.py <skill> [on|manual|off] [--scope local|project|user]
cg_mode.py <skill> --banner | --is-on (exit 0 on, 3 manual/off)
"""
from __future__ import annotations
import json
import os
import shlex
import subprocess
import sys
import tempfile
from pathlib import Path
MODES = ("on", "manual", "off")
DEFAULT_MODE = "off"
NOT_ON = 3 # --is-on exit status when manual/off
BIN_DIR = Path(__file__).resolve().parent.parent / "bin"
TO_OVERRIDE = {"on": "on", "manual": "user-invocable-only", "off": "off"}
FROM_OVERRIDE = {"on": "on", "name-only": "on", "user-invocable-only": "manual", "off": "off"}
def repo_root() -> Path:
try:
out = subprocess.run(
["git", "rev-parse", "--show-toplevel"], stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True,
)
if out.returncode == 0 and out.stdout.strip():
return Path(out.stdout.strip())
except OSError:
pass
return Path.cwd()
def settings_files() -> dict:
root = repo_root()
return {
"local": root / ".claude" / "settings.local.json",
"project": root / ".claude" / "settings.json",
"user": Path.home() / ".claude" / "settings.json",
}
def _read(path: Path) -> dict:
try:
data = json.loads(path.read_text())
except FileNotFoundError:
return {}
return data if isinstance(data, dict) else {}
def resolve(skill: str) -> tuple:
"""(mode, source)."""
env = os.environ.get(f"CONTEXT_GARDEN_MODE_{skill.upper()}")
if env in MODES:
return env, f"$CONTEXT_GARDEN_MODE_{skill.upper()}"
for scope, path in settings_files().items():
try:
value = (_read(path).get("skillOverrides") or {}).get(skill)
except ValueError:
continue # unparseable settings file: Claude Code will complain itself
if value in FROM_OVERRIDE:
return FROM_OVERRIDE[value], str(path)
return DEFAULT_MODE, "default"
def set_mode(skill: str, mode: str, scope: str = "local") -> Path:
"""Write skillOverrides[skill]; every other key of the file is kept as is."""
path = settings_files()[scope]
try:
data = _read(path)
except ValueError:
raise SystemExit(f"{path} is not valid JSON; not touching it")
overrides = data.setdefault("skillOverrides", {})
overrides[skill] = TO_OVERRIDE[mode]
path.parent.mkdir(parents=True, exist_ok=True)
fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp")
try:
with os.fdopen(fd, "w") as f:
f.write(json.dumps(data, indent=2) + "\n")
os.replace(tmp, path)
except BaseException:
try:
os.unlink(tmp)
except OSError:
pass
raise
return path
def banner(skill: str) -> str:
mode, _ = resolve(skill)
if mode == "manual":
return (
f"**{skill} is in MANUAL mode here.** Use it only if the user explicitly asked "
f"for it in this conversation (e.g. typed `/{skill} ...`). Otherwise stop reading "
"this skill and continue the task without it."
)
if mode == "off":
return (
f"**{skill} is turned OFF here** (off is the default). Do not use it; continue the "
f"task without it. Only if the user asks to turn it on: `{shlex.quote(str(BIN_DIR / skill))} mode on` "
"(automatic) or `mode manual` (only when called)."
)
return ""
def main(argv: list) -> int:
if not argv:
print(__doc__.strip())
return 2
skill, rest = argv[0], argv[1:]
if rest == ["--banner"]:
text = banner(skill)
if text:
print(text)
return 0
if rest == ["--is-on"]:
return 0 if resolve(skill)[0] == "on" else NOT_ON # a crash exits 1: told apart
if not rest:
mode, source = resolve(skill)
print(f"{skill}: {mode} (from {source})")
return 0
mode, scope = rest[0], "local"
if len(rest) == 3 and rest[1] == "--scope" and rest[2] in ("local", "project", "user"):
scope = rest[2]
elif len(rest) != 1:
print(__doc__.strip(), file=sys.stderr)
return 2
if mode not in MODES:
print(f"mode must be one of {', '.join(MODES)}", file=sys.stderr)
return 2
path = set_mode(skill, mode, scope)
print(f"{skill}: {mode} (written to {path})")
now, source = resolve(skill)
if now != mode:
print(f"note: still {now} because {source} takes precedence", file=sys.stderr)
return 0
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |