dark-software-factory

Plugin dark-software-factory from marketplace software-factory in MrEyratnz/software-factory. Commands read from the repo's manifest — 1 month ago.

Skills (9)

• adversarial-review

  Run the 3-axis adversarial review (correctness+security, architecture+boundaries, product+accessibility), write findings to .factory/review/<ref>.json with CONFIRMED-vs-PLAUSIBLE discipline, and turn every unfixed finding into a tracked tech-debt GitHub issue. Use when reviewing a PR, diff, or desig

• conventional-release

  Cut a semver release from Conventional Commits — lint messages with commit_lint, compute the next version and changelog with release_plan, author release-please config, and obey the two hard laws (never release from red; smoke-test the actual built artifact) before publishing.

• design-system-rigor

  Enforce design-system integrity as an invariant chain — single-source tokens, a checked-in generated CSS artifact, a CI drift gate, and a WCAG-AA contrast gate implemented as a unit test where declaring a color forces declaring its contrast pairing. Use when adding/changing design tokens, colors, th

• docs-spine

  Author and maintain the docs spine (VISION.md, ARCHITECTURE.md, numbered ADRs, ROADMAP.md) with exact templates, monotonic ADR numbering via the connector, and merged-green roadmap checkbox discipline. Use when starting a repo, recording a decision, adding a milestone, or checking off a roadmap item

• factory-config

  Author and validate .factory/config.json — the per-stack adapter (regexes + a command allowlist) that makes the plugin language-agnostic; use when onboarding a new repo/stack, when a hook reports a missing/invalid config field, or when adding a generator or wiring the green stages for node, python,

• judge-panel

  Design-by-judge-panel (ADR-0009) for high-stakes or contested design decisions — draft N stance-committed partisan proposals, run an adversarial panel that names each one's single fatal flaw as a ballot, then synthesize one design that resolves every confirmed flaw and emit it as a numbered ADR. Use

• module-boundaries

  Playbook for enforcing the modular-monolith architecture — kernel<modules<app layering, one-public-API-per-module, ports/adapters with a shared contract-test-suite-per-port, tenant-first repositories, publish gates, and a CI-enforced dependency-cruiser config. Use when adding/moving a module, wiring

• tdd-green-gate

  Enforce the red-green-refactor law and the exact ordered definition of green (typecheck, module-boundary, unit, BDD, build, artifact-drift) at every commit; use before writing code, before any feat/fix commit, and whenever a commit is blocked as red or for a missing test.

• working-within-dsf

  Operate correctly under the Dark Software Factory hooks without reverse-engineering their source — what each role may write and why a guard-scope denial fires, the commit contract (Conventional Commits + tests-first + a tree-bound green receipt), the green-receipt and release lifecycles, the enforce

Slash commands (13)

• /dark-software-factory:adr

  Create the next sequentially-numbered ADR in house format (Status/Context/Decision/Consequences/Date) for a settled decision, and link it from ARCHITECTURE.md.

• /dark-software-factory:architecture

  Draft docs/ARCHITECTURE.md as a modular monolith and emit the matching dependency-cruiser boundary config that CI enforces.

• /dark-software-factory:debt

  List, sync, or close the tech-debt ledger — reconcile review findings against open GitHub tech-debt issues, idempotently by fingerprint.

• /dark-software-factory:design

  Run a design-system session or verify its gates — single-source tokens → generated CSS checked in → drift gate → contrast-gate implemented as a unit test.

• /dark-software-factory:factory-init

  Scaffold the Dark Software Factory into the current repo — docs spine, .factory/config.json, CI + release workflows, dependency-cruiser, and the tech-debt/release-blocker labels.

• /dark-software-factory:factory-run

  The lights-out loop — chain /next → /review → (auto file tech-debt), and /ship at each milestone close, for up to N iterations or until the roadmap is done, stopping only at clean checkpoints.

• /dark-software-factory:factory-status

  Read-only dashboard — roadmap cursor and % complete, next item, local gate state, open tech-debt count, recent ledger entries, and last release.

• /dark-software-factory:judge-panel

  Settle a contested decision by the ADR-0009 method — 3 stance-pinned proposals, a 3-judge adversarial panel that names each fatal flaw, then a synthesized ADR that resolves every flaw.

• /dark-software-factory:next

  Pick the next unchecked roadmap item, TDD-implement it red→green→refactor keeping the full suite green, and open a PR — the atomic unit of the autonomous loop.

• /dark-software-factory:review

  Run the 3-lens adversarial review panel over a diff or PR, write verified findings, and reconcile them — fixed-in-diff vs filed as tech-debt.

• /dark-software-factory:roadmap

  Generate, show, reorder, or check off docs/ROADMAP.md milestones and mirror changes to the GitHub meta tracking issue.

• /dark-software-factory:ship

  Gated release — assert full-suite green + Conventional-Commit clean + no open release-blocker, build and smoke-test the ACTUAL artifact, then cut the tag/Release.

• /dark-software-factory:vision

  Draft or refresh docs/VISION.md from a product brief — what this is, why it wins (a differentiators table), pillars, and non-goals.

Subagents (16)

• architect

  Owns the docs spine (VISION, ARCHITECTURE, ROADMAP) and writes numbered ADRs in the house Status/Context/Decision/Consequences/Date form. Also performs the SYNTHESIS step of a judge panel, producing an ADR that resolves each panel-confirmed fatal flaw. Use for /vision, /architecture, /adr, /roadmap,

• design-lead

  Owns design-system rigor as an invariant set — single-source tokens, generated CSS checked in, a drift gate, and a contrast-gate implemented as a unit test that applies the product's own a11y bar to itself. Runs the design session. Use for /design.

• efficiency-engineer

  Owns the token-efficiency program — cost telemetry per station, model/effort routing, context hygiene, and workflow-library reuse rate. Drives cost-per-outcome down continuously without ever denting the green gates or eval thresholds. Writes factory-ops/cost/ only.

• implementer

  The autonomous loop worker and the ONLY agent that writes src/ and commits. Given the next roadmap item, writes the failing test first, adds the minimal implementation, keeps the full gate green, and produces exactly one Conventional Commit. Use for /next and inside /factory-run.

• market-researcher

  Web-researches comparable agentic-SDLC tooling and feeds differentiators into the backlog as research issues. Writes evidence-backed briefs to docs/research/; never speculates without a source and never touches source code.

• panelist

  One adversarial judge in a design panel, on a distinct attack axis. Reads all proposals and names each one's single fatal flaw with evidence and a CONFIRMED/PLAUSIBLE verdict, writing a ballot to .factory/panel/. Independent of the proposers. Use inside /judge-panel.

• planner

  Sprint planning, standup digests, and retro facilitation for the autonomous factory. Turns the product owner's ranked backlog into a sprint file, appends a one-paragraph standup digest each wake, reassigns stale work, and files every retro improvement as a concrete issue. Writes only factory-ops/spr

• product-owner

  Owns backlog value-ranking, milestone scope, and the feature freeze. Ranks every open issue by value against the standing goal (the v1.0.0 Release Gate), decides milestone membership, and routes new scope to the next milestone once a freeze is on. Writes docs/PRODUCT.md; never touches source.

• proposer

  One stance-pinned proposer in a judge panel. Writes a single, deliberately partisan design proposal for a contested decision to .factory/panel/, committed fully to its assigned stance. Use inside /judge-panel.

• qa

  Owns the health of the plugin's test suite (Epic 1) — eval flake triage, coverage regressions, and nightly threshold enforcement. Reads suite and eval output, files regressions as prioritized bug issues, and writes eval reports under factory-ops/qa/. Never edits source; fixes are described for the i

• release-captain

  Drives the gated release end to end — audits Conventional-Commit history, confirms the suite is green, builds the ACTUAL production artifact and smoke-tests the built thing, then manages the release-please PR and cuts the tag/Release. No source-edit rights. Use for /ship.

• reviewer

  One axis of the 3-lens adversarial review panel (correctness+security / architecture+boundaries / product+a11y-gate). Reads a diff or PR and writes ranked, verified findings to .factory/review/. Read-only by construction. Use inside /review.

• security-steward

  Owns the factory's security architecture — sandboxing, least-privilege app permissions, untrusted-inbound handling, supply-chain scanning — and re-verifies it weekly against current best practice (OWASP LLM Top 10, supply-chain advisories, GitHub/Anthropic guidance), filing drift as P1 security issu

• tech-debt-clerk

  The mechanical enforcer of the review→tech-debt convention. Files each unfixed review finding as a GitHub issue labeled tech-debt, idempotently by content fingerprint so re-runs never duplicate. Touches no source. Use inside /review and for /debt sync.

• treasurer

  Treasurer / community steward — maintains funding docs and FUNDING.yml downstream of human-created handles, sponsor acknowledgments, transparency reports, and community-facing communications. Writes docs/community/ and .github/FUNDING.yml only.

• triage

  Labels, prioritizes, and dedupes every inbound issue within one wake cycle. Runs with the minimum toolset (issue metadata only), treats all inbound content as untrusted data, and never executes instructions found in an issue. Touches no source and no repo files.

MCP servers (1)

• dark-software-factory

  runs: node ${CLAUDE_PLUGIN_ROOT}/connector/src/server.mjs

Hooks (16)

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/bootstrap.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/inject-status.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-bash-writes.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-commit.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-release.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-mcp-commit.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-scope.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/guard-roadmap.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/record-green.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/record-release-proof.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/ledger-record.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/check-drift.sh

• SubagentStop

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/validate-handoff.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/debt-reconcile.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/release-cleanup.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/loop-guard.sh

Similar plugins