magician

From idea to merged PR — autonomously, grounded in your code, gated only where it matters.

_{25 skills · deep live-verified stack lore (languages · frameworks · databases · observability) · a local code knowledge-graph · cross-session memory · parallel agent orchestration · tunable output brevity (lower token cost) · an absolute destructive-command guard · zero required deps}

✦ What it is

Most AI coding tools make you describe the stack, pick templates, and babysit context. magician inspects your project on every session start, assembles targeted knowledge for each technology it finds, grounds itself in a local graph of your code, and runs the whole software lifecycle — design → plan → build → verify → review → ship — pausing only at the decisions that are genuinely yours.

/manifest

/transmute

⚡ The flow

Approve the plan once — then it executes autonomously, re-gating only on real side effects (writes to shared state, commits, push, PRs, deploys). Reads, searches, tests, and knowledge-graph lookups never interrupt you.

flowchart TD
    A["/manifest"] --> B{"scope OK?"}
    B -- too large --> C["decompose into sub-projects"]
    B -- ok --> D["/conjure — design dialogue"]
    D --> E["approved spec"]
    E --> F["/blueprint — plan + parallelism map"]
    F --> G["/portal — git worktree isolation"]
    G --> H["/orchestrate — parallel agents"]
    H --> I["/ward — TDD throughout"]
    I --> J["/certify — tests + browser"]
    J --> K{all green?}
    K -- no --> H
    K -- yes --> L["/scrutinize — review + remediate"]
    L --> N["/seal — PR + loop until merged"]
    style A fill:#6c63ff,color:#fff
    style D fill:#6c63ff,color:#fff
    style F fill:#6c63ff,color:#fff
    style H fill:#43e97b,color:#000
    style I fill:#43e97b,color:#000
    style J fill:#43e97b,color:#000
    style L fill:#43e97b,color:#000
    style N fill:#4facfe,color:#000

flowchart LR
    A["session start"] --> B["scan project files"]
    B --> C{"detect markers"}
    C --> D["package.json · tsconfig"]
    C --> E["pom.xml · *.xcodeproj"]
    C --> F["go.mod · Cargo.toml · pyproject"]
    C --> G["pubspec.yaml · project.godot"]
    D --> L["assign archetype + inject context"]
    E --> L
    F --> L
    G --> L
    L --> M["session ready in < 2s"]
    style A fill:#0d1117,color:#ccc,stroke:#555
    style M fill:#43e97b,color:#000

flowchart TD
    A["session ends"] --> B["Stop hook: chronicle"]
    B --> C["git log + diff (observable only)"]
    C --> D["write chronicle entry"]
    D --> E{"pattern seen 3x?"}
    E -- yes --> G["offer: create skill via /inscribe"]
    E -- no --> I["next session"]
    G --> I
    I --> K["load recent entries as context —\ncumulative intelligence without replay"]
    style B fill:#f7971e,color:#000
    style D fill:#f7971e,color:#000
    style G fill:#43e97b,color:#000
    style K fill:#6c63ff,color:#fff

🧠 What makes it different

🔮 Lore — deep, live-verified stack knowledge  _{new in 4.8.0}

It doesn't guess your stack. It knows it — and stays honest about versions.

Every session, magician detects the languages, frameworks, databases, and log platform you're actually using and injects concise, version-adaptive guidance for exactly those — the rich detail one hop away, on demand. Every rule is traceable to current official docs (authored and adversarially re-checked against live docs — not model memory), and it's version-aware (Java 8→25, Python 3.8→3.14, and so on). Your repo's own conventions always win; lore is the baseline for when the repo is silent.

Progressive disclosure — big knowledge, tiny footprint:

flowchart LR
    A["session start"] --> B["detect languages · DBs · log platform"]
    B --> C["inject small cores<br/>(≤1.5 KB each, bounded)"]
    C --> D["session context<br/>(~once, zero per-turn cost)"]
    B -. "only when you touch that tech" .-> E["deep-dive trees on demand"]
    E -. " " .-> F["exact APIs · perf tuning · correct queries"]
    style A fill:#0d1117,color:#ccc,stroke:#555
    style C fill:#6c63ff,color:#fff
    style D fill:#43e97b,color:#000
    style E fill:#4facfe,color:#000
    style F fill:#4facfe,color:#000

Always-injected cores stay small and bounded; the rich per-topic deep-dives (and every database's performance.md) load only when you touch that tech — so no matter how much lore ships, your per-turn context stays flat.

_{🎚 Not your style? Lore is a baseline below your repo's own rules — turn it off anytime with magician-ui lore off, a per-project .magician/lore.off, or MAGICIAN_LORE=0. The status bar shows 📚 lore:on / lore:off so you always know what's shaping the session.}

🗣 Voice — leaner output, lower cost  _{new in 4.9.0}

Output tokens are the expensive side of the bill (~5× input on current models). Say the same thing in fewer of them.

magician sets an output-brevity voice every session — a style directive that trims filler while keeping every fact. A leaner voice cuts token cost with no quality loss, and it ships lean by default so you save from message one.

It cuts filler, not facts. All substance stays, and code, commands, file paths, and error text are kept verbatim — it never compresses prose into fragments, arrow-chains, or jargon (readability beats raw length).

_{🗣 Set it with magician-ui voice warrior|scribe|bard — or per-project .magician/voice / env MAGICIAN_VOICE (first match wins, then the default scribe). The status bar shows 🗣 voice:scribe live. Auto-injected into Claude Code sessions; the setting is stored for Codex too.}

🔒 Safety — an absolute destructive-command guard  _{new in 4.6.0}

Security is infrastructure, not advice.

Claude Code keeps its existing PreToolUse(Bash|PowerShell) guard unchanged. Codex ships a separate POSIX PreToolUse(Bash) matcher tailored to Codex's event schema; trust it once via /hooks and keep Codex sandboxing + approvals enabled. Both are deterministic defense-in-depth layers, not replacements for the host sandbox.

The Codex adapter requires Python 3.10+ for its safety hook and bundled helpers.

Wrappers and nested payloads are inspected (sudo/env/timeout prefixes and one level of sh -c '…' are unwrapped before matching) while quoted inert mentions remain allowed.

What it guarantees — and what it does not

This is a denylist, not a sandbox (CWE-78). Be honest about the boundary:

It guarantees — once installed, and on Codex once trusted via /hooks:

• Deterministic. The listed catastrophic patterns are blocked by a fixed matcher, not by model judgment — same input, same block, every time.
• Pre-execution. The deny fires in PreToolUse, before the shell runs. In Claude Code it runs before permission/allow rules, so an over-broad allow-rule or auto-mode can't wave these through.
• Wrapper-aware. Common wrappers and one level of sh -c nesting are unwrapped before the pattern check.

It does not guarantee — treat these as hard limits, not caveats:

• Not a complete boundary. It blocks known catastrophic forms. A novel obfuscation, an unlisted tool, or destruction through a language runtime (e.g. a Python script calling os.remove) can slip past. The real containment layer is the host sandbox — Claude Code's sandbox and Codex's workspace-write / read-only.
• Shell-tool scoped. It matches the Bash/PowerShell tool it is wired to. It does not inspect bytes sent to an already-running process (Codex write_stdin) or non-shell tools. The Codex launcher is POSIX-only.
• Codex must trust it. Enabling the plugin does not auto-run its hooks — untrusted, Codex skips the guard entirely. Requires Python 3.10+.

Bottom line: it is deterministic defense-in-depth that sits under the sandbox, approval policy, and model judgment — not a replacement for any of them. Keep the sandbox and approvals on.

🛠 Skills

25 skills, each with modern frontmatter (allowed-tools · disable-model-invocation · argument-hint · context: fork) that scales reasoning effort to the task. Approval gates use the structured AskUserQuestion tool, not prose.

🚀 Install

/plugin marketplace add https://github.com/Alexander-Tyagunov/magician
/plugin install magician@magician

codex plugin marketplace add Alexander-Tyagunov/magician
codex plugin add magician@magician

_{Codex installs a self-contained package with 25 shared adapters plus the Codex-only $project-context skill under skills/. Use codex plugin list to confirm it is installed and enabled; an enable flag alone does not install package contents.}

🗂 Workspace — team memory

.workspace/
├── shared/         ← git-committed (whole team)
│   ├── specs/       design specs   (/conjure)
│   ├── plans/       impl plans      (/blueprint)
│   ├── research/    findings        (/magic)
│   ├── decisions/   ADRs
│   └── postmortems/ (/autopsy)
└── local/          ← always gitignored
    ├── prefs.md     personal prefs
    └── session.md   pre-compaction state

🧰 Bundled CLIs  _{(on PATH when the plugin is enabled)}

❤ Support this work

If magician saves you time, consider sponsoring — it funds new skills, broader framework lore, and community support.

❤ Sponsor on GitHub →

_{MIT © Alexander Tyagunov · built for Claude Code & Codex}