Claude Night Market

Claude Code plugins for software engineering workflows.

16 plugins providing 125 skills, 98 commands, and 41 agents for git operations, code review, spec-driven development, and issue management. Each plugin installs independently.

<p align="center"> <img src="assets/gifs/skills-showcase.gif" alt="Night Market skills in action" width="720"> </p>

Quick Start

# Add the marketplace
/plugin marketplace add athola/claude-night-market

# Install plugins you need
/plugin install sanctum@claude-night-market    # Git workflows
/plugin install pensive@claude-night-market    # Code review
/plugin install spec-kit@claude-night-market   # Spec-driven dev

# Use them
/prepare-pr                                    # Prepare a pull request
/full-review                                   # Run code review

Alternative: Install via npx with npx skills add athola/claude-night-market (installs all plugins at once).

After installation, run claude --init for one-time setup.

Note: If the Skill tool is unavailable, read skill files directly at plugins/{plugin}/skills/{skill-name}/SKILL.md.

opkg (OpenPackage)

# Install specific plugins
opkg i gh@athola/claude-night-market --plugins sanctum
opkg i gh@athola/claude-night-market --plugins pensive,conserve

# Plugins that depend on shared runtime skills (e.g. attune, conjure)
# automatically pull packages/core as a dependency

See the Installation Guide for detailed setup options.

Architecture

16 plugins organized in four layers. Domain specialists depend on utility plugins, which depend on foundation plugins, which depend on the meta layer.

flowchart TB
    classDef domainClass fill:#e8f4f8,stroke:#2980b9,stroke-width:2px,color:#2c3e50
    classDef utilityClass fill:#f8f4e8,stroke:#f39c12,stroke-width:2px,color:#2c3e50
    classDef foundationClass fill:#f4e8f8,stroke:#8e44ad,stroke-width:2px,color:#2c3e50
    classDef metaClass fill:#e8f4e8,stroke:#27ae60,stroke-width:2px,color:#2c3e50

    subgraph Domain["Domain Specialists"]
        direction LR
        D1[archetypes]:::domainClass
        D2[pensive]:::domainClass
        D3[parseltongue]:::domainClass
        D4[memory-palace]:::domainClass
        D5[spec-kit]:::domainClass
        D6[minister]:::domainClass
        D7[attune]:::domainClass
        D8[scry]:::domainClass
        D9[scribe]:::domainClass
    end

    subgraph Utility["Utility Layer"]
        direction LR
        U1[conserve]:::utilityClass
        U2[conjure]:::utilityClass
        U3[hookify]:::utilityClass
    end

    subgraph Foundation["Foundation Layer"]
        direction LR
        F1[imbue]:::foundationClass
        F2[sanctum]:::foundationClass
        F3[leyline]:::foundationClass
    end

    subgraph Meta["Meta Layer"]
        direction LR
        M1[abstract]:::metaClass
    end

    Domain ==> Utility ==> Foundation ==> Meta

Plugin Catalog

Plugin	Layer	Description	Skills	Cmds
abstract	Meta	Skill authoring, hook development, evaluation frameworks, stability monitoring	10	18
leyline	Foundation	Auth flows (GitHub/GitLab/AWS), quota management, error patterns, markdown formatting, Discussions retrieval, damage-control, stewardship	16	2
sanctum	Foundation	Git workflows, commit messages, PR prep, docs updates, version management, sessions	14	18
imbue	Foundation	TDD enforcement, proof-of-work validation, scope guarding, rigorous reasoning	9	3
conserve	Utility	Context optimization, bloat detection, CPU/GPU monitoring, token conservation	10	4
conjure	Utility	Delegation framework for routing tasks to external LLMs (Gemini, Qwen)	4	0
hookify	Utility	Behavioral rules engine with markdown configuration and hook-to-rule conversion	2	6
pensive	Domain	Code review, architecture review, bug hunting, Makefile audits, NASA Power of 10	11	12
attune	Domain	Project lifecycle: brainstorm, specify, plan, initialize, execute, war-room	12	10
spec-kit	Domain	Spec-driven development: specifications, task generation, implementation	3	9
parseltongue	Domain	Python: testing, performance, async patterns, packaging	4	3
minister	Domain	GitHub issue management, label taxonomy, initiative tracking	2	3
memory-palace	Domain	Spatial knowledge organization, digital garden curation, PR review capture	6	5
archetypes	Domain	Architecture paradigm selection (hexagonal, CQRS, microservices, etc.)	14	0
scribe	Domain	Documentation with AI slop detection, style learning, tech tutorials	4	3
scry	Domain	Terminal recordings (VHS), browser recordings (Playwright), GIF processing	4	2

Full inventory: Capabilities Reference.

How the Layers Work

Governance and quality. imbue enforces TDD via a PreToolUse hook that verifies test files before allowing implementation writes. Quality gates in /create-skill and /create-command halt execution when tests fail. imbue:rigorous-reasoning requires step-by-step logic checks before tool execution.

Security and sessions. leyline manages OAuth flows with local token caching. conserve auto-approves safe commands while blocking destructive operations. sanctum isolates named sessions. Agents can run in worktree isolation to prevent filesystem conflicts during parallel execution.

Maintenance. /update-ci reconciles pre-commit hooks and GitHub Actions with code changes. abstract's homeostatic monitor tracks skill stability and auto-triggers improvement agents when degradation is detected. It creates GitHub issues for human review. /fix-workflow repairs failed runs by analyzing previous errors.

Cross-session state. attune, spec-kit, and sanctum persist state across sessions via CLAUDE_CODE_TASK_LIST_ID. GitHub Discussions serve as a second persistence layer: leyline retrieves Decisions at session start, attune publishes war-room deliberations, memory-palace promotes evergreen knowledge, and imbue links scope-guard deferrals to companion discussions.

Risk classification. leyline:risk-classification provides 4-tier task gating. GREEN and YELLOW tasks use heuristic matching. RED and CRITICAL tasks escalate to war-room-checkpoint for expert deliberation.

Common Workflows

See the Common Workflows Guide for full details.

Workflow	Command	What it does
Project lifecycle	/attune:mission	Routes through brainstorm, specify, plan, execute phases
Initialize project	/attune:arch-init	Architecture-aware scaffolding with language detection
Review a PR	/full-review	Multi-discipline code review in a single pass
Fix PR feedback	/fix-pr	Address review comments progressively
Implement issues	/do-issue	Issue resolution with parallel agent execution
Prepare a PR	/prepare-pr	Quality gates, linting, clean git state
Write specs	/speckit-specify	Specification-first development
Catch up on changes	/catchup	Context recovery from recent git history
Codebase cleanup	/unbloat	Bloat removal with progressive depth levels
Update CI/CD	/update-ci	Reconcile hooks and workflows with code changes
Strategic decisions	/attune:war-room	Expert routing with reversibility scoring
Refine code	/refine-code	Duplication, algorithm, and clean code analysis

Requirements

• Claude Code 2.1.16+ (2.1.32+ for agent teams, 2.1.38+ for security features, 2.1.63 latest tested)
• Python 3.9+ for hooks (macOS ships 3.9.6). Plugin packages may target 3.10+ via virtual environments, but all hook code must be 3.9-compatible. See the Plugin Development Guide for compatibility rules.

Plugin Development

Create a new plugin:

make create-plugin NAME=my-plugin
make validate
make lint && make test

Plugin layout:

my-plugin/
├── .claude-plugin/
│   └── plugin.json        # Metadata: skills, commands, agents, hooks
├── commands/               # Slash commands (markdown)
├── skills/                 # Agent skills (SKILL.md + modules/)
├── hooks/                  # Event handlers (Python, 3.9-compatible)
├── agents/                 # Specialized agent definitions
├── tests/                  # pytest suite
├── Makefile                # Build, test, lint targets
└── pyproject.toml          # Package config

See the Plugin Development Guide for structure requirements and naming conventions. For LSP integration, see the LSP Guide.

Documentation

• Installation Guide - setup, marketplace, post-install hooks
• Quick Start - first commands after installation
• Common Workflows - task-oriented usage guide
• Plugin Development Guide - creating and testing plugins
• Capabilities Reference - full skill, command, and agent inventory
• Tutorials - PR workflows, debugging, feature lifecycles

Per-plugin documentation lives in book/src/plugins/ (one page per plugin).

Stewardship

Every plugin is entrusted to the community. Five principles guide how we maintain and improve the ecosystem: steward (not own), multiply (not merely preserve), be faithful in small things, serve those who come after, and think seven iterations ahead.

Each plugin README includes a Stewardship section with specific improvement opportunities. Run /stewardship-health to view per-plugin health dimensions.

See STEWARDSHIP.md for the full manifesto.

Contributing

Each plugin maintains its own tests and documentation. Run make test at the repo root to execute all plugin test suites. See the Plugin Development Guide for contribution guidelines.

License

MIT