@aslomon/effectum 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aslomon/effectum",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Autonomous development system for Claude Code — describe what you want, get production-ready code",
   "bin": {
     "effectum": "bin/install.js"

package/system/commands/prd/decompose.md

@@ -0,0 +1,88 @@
+# /prd:decompose — Split Large Scope into Multiple PRDs (Phase 3)
+
+You break down a large project scope into manageable, individually implementable PRDs.
+
+## Step 1: Load Project
+
+Interpret `$ARGUMENTS` as project-slug.
+
+- If empty: List available projects, ask the user.
+- Validate that `workshop/projects/{slug}/` exists.
+
+Read the current project state:
+
+- `workshop/projects/{slug}/PROJECT.md`
+- `workshop/projects/{slug}/vision.md` (if present)
+- `workshop/projects/{slug}/requirements-map.md` (if present)
+- Existing PRDs under `workshop/projects/{slug}/prds/`
+
+## Step 2: Load Decomposition Guide
+
+Read `workshop/knowledge/03-decomposition-guide.md` for strategies and signals.
+
+## Step 3: Check Decomposition Signals
+
+Analyze the scope for decomposition signals:
+
+- More than 8 acceptance criteria total
+- Independent user journeys identifiable
+- Different bounded contexts / domains
+- Different technical layers (frontend, backend, data)
+- Features with different priorities / timelines
+- Different risk levels
+
+If no clear signals: Inform the user that a single PRD might suffice. Ask whether to decompose anyway.
+
+## Step 4: Propose Decomposition Strategy
+
+Propose one or more strategies:
+
+| Strategy               | When                       | Example                                          |
+| ---------------------- | -------------------------- | ------------------------------------------------ |
+| **Domain-based**       | Different bounded contexts | Auth PRD, Billing PRD, Dashboard PRD             |
+| **User-Journey-based** | Independent user flows     | Onboarding PRD, Core Workflow PRD, Reporting PRD |
+| **Phase-based**        | Natural sequence           | MVP PRD, Enhancement PRD, Scale PRD              |
+| **Layer-based**        | Clear tech separation      | Data Model PRD, API PRD, Frontend PRD            |
+
+Explain to the user why you recommend this strategy.
+
+## Step 5: Discussion and Adjustment
+
+Discuss the proposed decomposition with the user:
+
+- Show the proposed PRDs with title and brief description.
+- Show which requirements / features belong to which PRD.
+- Show dependencies between the PRDs.
+- Let the user adjust the split (merge, split further, regroup).
+
+## Step 6: Create/Update Files
+
+After agreement:
+
+1. **Vision Document** (`vision.md`): Update or create the project vision document with the overall picture.
+
+2. **Requirements Map** (`requirements-map.md`): Create the assignment table — which requirements/features belong to which PRD.
+
+3. **Network Map** (`network-map.mmd`): Create an initial Network Map (Stage 2) with PRD boundaries, per `workshop/knowledge/06-network-map-guide.md`.
+
+4. **PRD Stubs** (`prds/{number}-{name}.md`): Create a stub file for each identified PRD with:
+   - Title and brief description
+   - Assigned requirements from the Requirements Map
+   - Known dependencies on other PRDs
+   - Status: `stub`
+
+5. **PROJECT.md**: Update with the complete PRD list and status `decomposing` → `drafting`.
+
+## Step 7: Next Steps
+
+Show the user:
+
+1. The final decomposition as an overview.
+2. A recommended processing order (dependency-based).
+3. Suggest starting with `/prd:discuss {slug}/001` for the first PRD.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/discuss.md

@@ -0,0 +1,65 @@
+# /prd:discuss — Deep-Dive Discussion for a Specific PRD (Phase 4)
+
+You conduct an in-depth discussion about a specific PRD. Goal: maximum understanding, clarify all details.
+
+## Step 1: Load PRD
+
+Interpret `$ARGUMENTS`:
+
+- Format `project-slug/001` → Read `workshop/projects/{project-slug}/prds/001-*.md`
+- Format as file path → Read the file directly
+- If empty or unclear: List available projects and PRDs, ask the user.
+
+Read the PRD completely.
+
+## Step 2: Load Questioning Framework
+
+Read `workshop/knowledge/02-questioning-framework.md`, specifically the Phase 4 section (Feature Deep-Dive).
+
+## Step 3: Identify Feature Type
+
+Determine the primary feature type of the PRD:
+
+- **UI/Frontend**: Screens, components, interactions, responsive behavior
+- **API/Backend**: Endpoints, business logic, data processing
+- **Data/Storage**: Data models, migrations, queries, caching
+- **Integration**: Third-party services, webhooks, OAuth, external APIs
+- **AI/ML**: Prompts, models, pipelines, feedback loops
+
+## Step 4: Ask Type-Specific Questions
+
+Ask questions appropriate to the feature type. There is no fixed limit — ask as many questions as needed until the feature is fully understood.
+
+Rules for the discussion:
+
+- Ask 2-3 questions per round, no more.
+- Accept all response formats:
+  - Detailed answers → process fully.
+  - Short answers ("yes", "standard", "as usual") → derive sensible defaults.
+  - "Skip that" → mark as `[NEEDS CLARIFICATION]` in the PRD and move on.
+- Summarize your current understanding after each round.
+- Let the user correct before proceeding.
+- Go deep where needed — superficiality is worse than too many questions.
+
+## Step 5: Update PRD
+
+After the discussion (or after significant insights in between):
+
+1. Update the PRD with the new details.
+2. Replace existing `[ASSUMPTION]` markers with clarified information.
+3. Add new `[ASSUMPTION]` or `[NEEDS CLARIFICATION]` markers where needed.
+4. Update Acceptance Criteria, Scope, Data Model, etc.
+
+## Step 6: Check Network Map
+
+Read `workshop/projects/{slug}/network-map.mmd` if it exists.
+If the discussion uncovered new connections, dependencies, or components:
+
+- Update `network-map.mmd` accordingly.
+- Inform the user about the changes.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/express.md

@@ -0,0 +1,81 @@
+# /prd:express — Quick PRD from Structured/Semi-Structured Input
+
+You create a complete PRD from an already relatively clear feature input. Minimal follow-up questions, maximum inference.
+
+## Step 1: Analyze Input
+
+Read `$ARGUMENTS` as a feature description.
+
+If empty: Ask the user for a feature description. Briefly explain that Express is intended for features that are already relatively clear.
+
+Parse the input for existing structure:
+
+- User Stories / Job Stories
+- Acceptance Criteria
+- Scope / Boundaries
+- Technical details
+- Data model hints
+- Integrations
+
+## Step 2: Determine Project
+
+Check if a matching project exists under `workshop/projects/`:
+
+- If yes: Assign the PRD there.
+- If no: Create a new project (like `/workshop:init`). Derive the slug from the feature description.
+
+## Step 3: Generate PRD
+
+Read `workshop/knowledge/01-prd-template.md` for the template.
+
+Fill out the template intelligently:
+
+1. **Title and Problem Statement**: Derive from the description.
+2. **User Stories**: Adopt existing ones or generate from the description.
+3. **Acceptance Criteria**: Adopt existing ones or derive from described behavior.
+4. **Scope**: Clearly define what is in-scope.
+5. **Non-Goals**: Proactively suggest — what is explicitly NOT part of this feature?
+6. **Data Model**: If data persistence is involved, suggest tables/fields.
+7. **API Contracts**: If API endpoints are needed, suggest them.
+8. **Quality Gates**: Set sensible defaults (tests, performance, accessibility).
+9. **Autonomy Rules**: Define what the implementing agent may decide on its own.
+10. **Completion Promise**: Clear definition of "done".
+
+## Step 4: Mark Assumptions
+
+Mark ALL assumptions with `[ASSUMPTION]` at the end of the PRD in a dedicated section.
+Group them by category:
+
+- Business/Product Assumptions
+- Technical Assumptions
+- Scope Assumptions
+
+## Step 5: Determine Workflow Mode
+
+Read `workshop/knowledge/08-workflow-modes.md`.
+Determine the appropriate workflow mode for the implementation.
+
+## Step 6: Save Files
+
+1. Save the PRD under `workshop/projects/{slug}/prds/{number}-{name}.md`.
+2. Update `PROJECT.md` with the new PRD.
+
+## Step 7: Generate Handoff Prompt
+
+Read `workshop/knowledge/07-prompt-templates.md`.
+Immediately generate a handoff prompt and save it under `workshop/projects/{slug}/prompts/{number}-{name}-handoff.md`.
+
+## Step 8: Present Result
+
+Show the user:
+
+1. The generated PRD (complete or summary).
+2. List of all assumptions — the user should confirm or correct these.
+3. The chosen workflow mode with justification.
+4. Next steps: recommend review (`/prd:review`) or direct handoff.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/handoff.md

@@ -0,0 +1,82 @@
+# /prd:handoff — Hand Off PRD to the Target Project
+
+You export a completed PRD as a handoff package for implementation in the target project.
+
+## Step 1: Load PRD and Check Readiness
+
+Interpret `$ARGUMENTS` as `project-slug/001`.
+
+- If empty or unclear: List available projects and PRDs, ask the user.
+
+Read the PRD: `workshop/projects/{project-slug}/prds/001-*.md`
+
+Check the readiness score:
+
+- If no review has been performed yet: Automatically perform a review (like `/prd:review`). Read `workshop/knowledge/05-quality-checklist.md` for this.
+- If score < 2.0: Warn the user and ask whether to proceed anyway. List the weaknesses.
+- If score >= 2.0: Proceed.
+
+## Step 2: Load Project Information
+
+Read `workshop/projects/{slug}/PROJECT.md` for:
+
+- `target_repo`: Path to the target repository
+- Project context and tech stack information
+
+## Step 3: Determine Workflow Mode
+
+Read `workshop/knowledge/08-workflow-modes.md` for the decision matrix.
+
+Determine the appropriate mode based on:
+
+- PRD complexity
+- Number of affected files
+- Risk level
+- User preference (if known)
+
+Possible modes:
+
+- **Standard Session**: Normal Claude Code session with the PRD as context
+- **Full-Auto**: Autonomous implementation with defined checkpoints
+- **Ralph Loop**: Iterative Review-Adjust-Learn-Polish-Harden cycle
+
+## Step 4: Generate Handoff Prompt
+
+Read `workshop/knowledge/07-prompt-templates.md` for the appropriate template.
+
+Generate the complete handoff prompt:
+
+1. Embed or reference the PRD content.
+2. Workflow instructions according to the chosen mode.
+3. Adopt Quality Gates and Completion Criteria from the PRD.
+4. Include tech stack context from PROJECT.md.
+
+## Step 5: Save Files
+
+Save the prompt under: `workshop/projects/{slug}/prompts/{number}-{name}-handoff.md`
+
+## Step 6: Serve Target Repository (optional)
+
+If `target_repo` is defined in PROJECT.md and the path exists:
+
+- Ask the user whether PRD and prompt should be copied there.
+- If yes: Copy both files to the target repository (e.g., under `docs/prds/`).
+
+## Step 7: Update Status
+
+Update the PRD status in `PROJECT.md` to `handed-off`.
+
+## Step 8: Show Next Steps
+
+Show the user:
+
+1. Where the handoff prompt was saved.
+2. How the prompt is used in the target project (brief instructions).
+3. The chosen workflow mode and why.
+4. If additional PRDs are open in the project: what comes next.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/network-map.md

@@ -0,0 +1,70 @@
+# /prd:network-map — Create or Update the Project Network Map
+
+You create or update the visual network map of a project as a Mermaid diagram.
+
+## Step 1: Identify Project
+
+Interpret `$ARGUMENTS` as project-slug.
+
+- If empty: List available projects, ask the user.
+- Validate that `workshop/projects/{slug}/` exists.
+
+## Step 2: Load Project Data
+
+Read all relevant files:
+
+- All PRDs under `workshop/projects/{slug}/prds/*.md`
+- `workshop/projects/{slug}/vision.md` if present
+- `workshop/projects/{slug}/requirements-map.md` if present
+- `workshop/projects/{slug}/network-map.mmd` if present (existing map)
+
+## Step 3: Load Conventions
+
+Read `workshop/knowledge/06-network-map-guide.md` for the Mermaid conventions and styling rules.
+
+## Step 4: Determine Stage
+
+Determine the appropriate level of detail based on the project status:
+
+| Stage              | When                | Content                                          |
+| ------------------ | ------------------- | ------------------------------------------------ |
+| 1 — Feature Map    | Early discovery     | Only features and their relationships            |
+| 2 — PRD Boundaries | After decomposition | Features grouped into PRD boundaries             |
+| 3 — Full Technical | PRDs in detail      | Data models, APIs, external services, tech stack |
+
+## Step 5: Analyze Network
+
+Identify and catalog:
+
+- **Features/Modules**: All described functionalities
+- **Data Entities**: Tables, models, schemas
+- **External Services**: Third-party APIs, auth providers, payment, etc.
+- **Connections**: Dependencies, data flows, event chains
+- **PRD Assignment**: Which feature belongs to which PRD
+
+## Step 6: Generate Mermaid Diagram
+
+Create the diagram according to the conventions from the guide:
+
+- Use status colors: `planned` (gray), `inProgress` (blue), `done` (green)
+- Group with `subgraph` for PRD boundaries
+- Label edges with relationship types
+- Keep the diagram readable — split or simplify if >20 nodes
+
+## Step 7: Write File
+
+Write the updated Network Map to `workshop/projects/{slug}/network-map.mmd`.
+
+## Step 8: Display Result
+
+Show the user:
+
+1. The complete Mermaid source in a code block.
+2. A brief summary: number of features, PRDs, connections, identified dependencies.
+3. Notes on potential issues (circular dependencies, isolated nodes, too many connections).
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/new.md

@@ -0,0 +1,71 @@
+# /prd:new — Start a New Project or PRD
+
+You start a new PRD workshop session. Work interactively and adaptively with the user.
+
+## Step 1: Check Input
+
+If `$ARGUMENTS` is empty, ask: **[in configured language] "What do you want to build?"** — wait for a response before proceeding.
+
+If `$ARGUMENTS` is provided, analyze the input:
+
+- **Workshop Mode** (vague description, idea, problem): Start the full workshop process with Phase 1.
+- **Express Mode** (specific feature with clear scope): Redirect to `/prd:express`.
+
+## Step 2: Create New Project or Use Existing One
+
+Check if a matching project already exists under `workshop/projects/`.
+
+- **New project**: Create the project structure following the `/workshop:init` pattern:
+  1. Derive a slug from the project name (lowercase, hyphens, no spaces).
+  2. Create `workshop/projects/{slug}/` with subdirectories `prds/`, `prompts/`, `notes/`.
+  3. Create `PROJECT.md` from `workshop/templates/PROJECT.md` with slug and today's date.
+  4. Create `notes/discovery-log.md` and `notes/decisions.md` as empty files.
+  5. Set status to `discovery`.
+
+- **Existing project**: Read `PROJECT.md` and determine the current state.
+
+## Step 3: Start Discovery Phase (Phase 1 — Vision & Problem Discovery)
+
+Read `workshop/knowledge/02-questioning-framework.md` for the question progression.
+
+Begin Phase 1 with adaptive questions:
+
+- Ask 2-3 questions at a time, no more.
+- Adapt follow-up questions to the responses.
+- Accept short answers ("yes", "standard", "skip that").
+- Summarize your understanding after each round and let the user correct.
+- Record key insights in `notes/discovery-log.md`.
+
+## Step 4: Progress Through Phases
+
+Work through the phases:
+
+1. **Vision & Problem Discovery** → Save result in `vision.md`
+2. **Scope & Requirements** → Save in `requirements-map.md`
+3. **Decomposition Check**: If the scope is large (>8 ACs, multiple independent journeys, different bounded contexts), suggest decomposition and reference `workshop/knowledge/03-decomposition-guide.md`.
+4. **Create Network Map** → `network-map.mmd` per `workshop/knowledge/06-network-map-guide.md`
+
+After each phase:
+
+- Save results to the corresponding files.
+- Update `PROJECT.md` with the new status.
+
+## Step 5: Write PRD
+
+When the scope is clear:
+
+1. Read `workshop/knowledge/01-prd-template.md` for the template.
+2. Guide the user through PRD creation:
+   - Title, Problem Statement, User Stories
+   - Acceptance Criteria, Scope/Non-Goals
+   - Data Model (if data persistence is involved), API Contracts
+   - Quality Gates, Autonomy Rules, Completion Promise
+3. Mark open items with `[ASSUMPTION]` or `[NEEDS CLARIFICATION]`.
+4. Save PRD under `workshop/projects/{slug}/prds/{number}-{name}.md`.
+5. Update `PROJECT.md`.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/prompt.md

@@ -0,0 +1,62 @@
+# /prd:prompt — Generate Handoff Prompt for a PRD
+
+You generate a handoff prompt for a PRD without performing the full export process.
+
+## Step 1: Load PRD
+
+Interpret `$ARGUMENTS` as `project-slug/001`.
+
+- If empty or unclear: List available projects and PRDs, ask the user.
+
+Read the PRD: `workshop/projects/{project-slug}/prds/001-*.md`
+
+## Step 2: Determine Workflow Mode
+
+Read `workshop/knowledge/08-workflow-modes.md` for the decision matrix.
+
+Evaluate the PRD against the matrix criteria:
+
+- **Complexity**: Number of ACs, data model scope, integrations
+- **Risk**: New technologies, security-relevant, critical path
+- **File Impact**: How many files are expected to be affected
+- **Autonomy Level**: How much can be implemented without follow-up questions
+
+Determine the mode:
+
+- **Standard Session**: Moderate complexity, user wants to collaborate
+- **Full-Auto**: Clearly defined, low risk, high autonomy
+- **Ralph Loop**: Complex, high risk, iterative approach needed
+
+## Step 3: Generate Prompt
+
+Read `workshop/knowledge/07-prompt-templates.md` for the appropriate template.
+
+Build the complete prompt:
+
+1. **Context Section**: Project name, tech stack, relevant context from PROJECT.md.
+2. **PRD Content**: Embed the complete PRD.
+3. **Workflow Instructions**: According to the chosen mode.
+4. **Quality Gates**: Quality criteria adopted from the PRD.
+5. **Completion Criteria**: When is the implementation done.
+6. **Autonomy Rules**: What the implementing agent may decide on its own.
+
+## Step 4: Save Prompt
+
+Save the prompt under: `workshop/projects/{slug}/prompts/{number}-{name}-handoff.md`
+
+## Step 5: Display Prompt
+
+Show the complete prompt in a code block so the user can easily copy it.
+
+## Step 6: Explain Mode
+
+Briefly explain (2-3 sentences) why this workflow mode was chosen. For example:
+
+- "Full-Auto, because the PRD is clearly defined, affects few files, and has no external dependencies."
+- "Ralph Loop, because the feature is security-critical and needs iterative review."
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/resume.md

@@ -0,0 +1,62 @@
+# /prd:resume — Resume Work on an Existing Project/PRD
+
+You resume work on an existing project or PRD. Read the current state, summarize, and continue where things left off.
+
+## Step 1: Identify Project
+
+Interpret `$ARGUMENTS`:
+
+- Format `project-slug` → Resume work on the entire project.
+- Format `project-slug/001` → Focus on this specific PRD.
+- If empty: Scan `workshop/projects/` and show available projects with status. Ask the user which one to continue.
+
+## Step 2: Load Full Context
+
+Read ALL existing files of the project:
+
+- `workshop/projects/{slug}/PROJECT.md` — Status, metadata, PRD list
+- `workshop/projects/{slug}/vision.md` — Project vision (if present)
+- `workshop/projects/{slug}/requirements-map.md` — Requirements map (if present)
+- `workshop/projects/{slug}/prds/*.md` — All PRDs
+- `workshop/projects/{slug}/network-map.mmd` — Network map (if present)
+- `workshop/projects/{slug}/notes/discovery-log.md` — Discovery notes
+- `workshop/projects/{slug}/notes/decisions.md` — Decision log
+- `workshop/projects/{slug}/prompts/*.md` — Existing handoff prompts
+
+## Step 3: Determine Current State
+
+Analyze the project status and determine the current phase:
+
+| Status in PROJECT.md | Current Phase            | Next Step                                    |
+| -------------------- | ------------------------ | -------------------------------------------- |
+| `discovery`          | Vision/Problem Discovery | Continue or conclude questioning             |
+| `scoping`            | Scope & Requirements     | Refine requirements, check for decomposition |
+| `decomposing`        | Decomposition            | Finalize PRD splitting                       |
+| `drafting`           | PRD Creation             | Continue writing open PRDs                   |
+| `discussing`         | Feature Deep-Dive        | Continue deep-dive                           |
+| `review`             | Quality Review           | Conclude review or apply improvements        |
+| `ready`              | Ready for Handoff        | Perform handoff                              |
+| `handed-off`         | Completed                | Archiving or additional PRDs                 |
+
+## Step 4: Present Summary
+
+Give the user a compact overview:
+
+1. **Project name and vision** (1-2 sentences)
+2. **Current status** and phase
+3. **What has been accomplished so far** (PRDs, decisions, open questions)
+4. **What comes next** (concrete suggestion)
+
+## Step 5: Continue Working
+
+Offer the user to continue with the next logical step:
+
+- If a specific PRD is referenced: Focus on that.
+- If the overall project: Suggest the most important next step.
+- Wait for the user's confirmation before starting.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/review.md

@@ -0,0 +1,59 @@
+# /prd:review — Quality Review and Readiness Scoring (Phase 7)
+
+You perform a systematic quality review of one or more PRDs.
+
+## Step 1: Load PRDs
+
+Interpret `$ARGUMENTS`:
+
+- Format `project-slug/001` → Review only this single PRD: `workshop/projects/{project-slug}/prds/001-*.md`
+- Format `project-slug` (without number) → Review ALL PRDs in the project: `workshop/projects/{project-slug}/prds/*.md`
+- If empty: List available projects, ask the user.
+
+Read all PRDs to be reviewed completely.
+
+## Step 2: Load Quality Checklist
+
+Read `workshop/knowledge/05-quality-checklist.md` for the evaluation criteria.
+
+## Step 3: Systematic Review
+
+Review each PRD against all categories of the Quality Checklist. Rate each category on a scale of 0-3:
+
+| Score | Meaning                           |
+| ----- | --------------------------------- |
+| 0     | Missing completely or unusable    |
+| 1     | Present but incomplete or unclear |
+| 2     | Solid, minor gaps acceptable      |
+| 3     | Excellent, no improvements needed |
+
+## Step 4: Present Results
+
+Show for each PRD:
+
+1. **Scoring table**: Each category with score and concrete justification.
+2. **Weighted average**: Calculate overall score.
+3. **Improvement suggestions**: Specific, actionable recommendations per category with score < 3.
+4. **Open items**: List of all `[ASSUMPTION]` and `[NEEDS CLARIFICATION]` markers.
+5. **Red Flags Check**: Review the red flag criteria from the Quality Checklist.
+
+## Step 5: Update Status
+
+Based on the overall score:
+
+- **Score >= 2.0**: Update the PRD status in `PROJECT.md` to `ready`. Inform the user that the PRD is ready for handoff.
+- **Score < 2.0**: Keep the status at `review`. Clearly list what needs improvement. Suggest using `/prd:discuss` for the weak areas.
+
+## Step 6: Summary
+
+Give the user a clear recommendation:
+
+- Ready for handoff? → Suggest `/prd:handoff`.
+- Rework needed? → Suggest concrete next steps.
+- For multiple PRDs: Sort by readiness, show which should be addressed first.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/prd/status.md

@@ -0,0 +1,63 @@
+# /prd:status — Dashboard of All Projects and PRDs
+
+You display an overview of all projects and their PRD statuses.
+
+## Step 1: Determine Scope
+
+Interpret `$ARGUMENTS`:
+
+- If empty: Show overview of ALL projects.
+- If project-slug is provided: Show detailed view for that project.
+
+## Step 2: Collect Project Data
+
+Scan all directories under `workshop/projects/`.
+
+For each project:
+
+1. Read `PROJECT.md` for status, metadata, PRD list.
+2. Count PRDs under `prds/`.
+3. Determine the status of each PRD (discovery, draft, review, ready, handed-off).
+4. Determine the last modification date.
+
+## Step 3: Display Overview (all projects)
+
+Present a formatted table:
+
+```
+| Project         | Status     | PRDs                          | Last Update    |
+|-----------------|------------|-------------------------------|----------------|
+| my-saas-app     | drafting   | 001 (ready), 002 (draft)      | 2026-03-18     |
+| portfolio-site  | discovery  | —                             | 2026-03-20     |
+```
+
+## Step 4: Detailed View (single project)
+
+If a specific project is requested, additionally show:
+
+- Vision summary (from vision.md)
+- Each PRD with: number, name, status, readiness score (if reviewed)
+- Network map status (present yes/no, stage)
+- Open `[ASSUMPTION]` and `[NEEDS CLARIFICATION]` counts per PRD
+- Existing handoff prompts
+
+## Step 5: Update STATUS.md
+
+Write the current overview to `STATUS.md` in the workshop root directory.
+Format: Markdown table with timestamp.
+
+## Step 6: Suggest Next Actions
+
+For each project, provide a concrete recommendation:
+
+- `discovery` → "Start `/prd:new {slug}` to continue"
+- `drafting` → "Use `/prd:discuss {slug}/001` for the next deep-dive"
+- `review` → "Run `/prd:review {slug}`"
+- `ready` → "Ready for `/prd:handoff {slug}/001`"
+- `handed-off` → "All PRDs handed off. `/workshop:archive {slug}` is available."
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/setup.md

@@ -0,0 +1,158 @@
+# /setup — Install Autonomous Development Workflow
+
+Install the complete autonomous development workflow into a target project.
+
+## Step 1: Determine Target
+
+If `$ARGUMENTS` contains a path, use it as the target project path.
+If `$ARGUMENTS` is empty, ask: **[in configured language] "What is the path to your project?"** — wait for a response.
+
+Validate:
+
+- The path exists. If not, ask: "This directory does not exist. Should I create it?"
+- Check for an existing `.claude/` directory at the target path.
+  - If found, ask: **"A .claude/ directory already exists. Overwrite, merge, or abort?"**
+    - **Overwrite**: Delete existing `.claude/` and replace with fresh installation.
+    - **Merge**: Keep existing files, only add missing ones. Warn about conflicts.
+    - **Abort**: Stop the installation.
+
+## Step 2: Gather Configuration
+
+Ask these questions one at a time. Skip any that you can auto-detect from the project.
+
+### 2.1 Project Name
+
+Derive from the directory name. Confirm with the user:
+**"Project name: {derived-name} — correct?"**
+
+### 2.2 Tech Stack
+
+Auto-detect first:
+
+- If `package.json` exists with `"next"` dependency → suggest **Next.js + Supabase**
+- If `pyproject.toml` or `requirements.txt` exists → suggest **Python + FastAPI**
+- If `Package.swift` exists → suggest **Swift/SwiftUI**
+- If none match → suggest **Generic**
+
+Offer presets:
+
+1. **Next.js + Supabase** — Full-stack web (TypeScript, App Router, Tailwind, Shadcn, Supabase)
+2. **Python + FastAPI** — Backend/API (Python 3.12+, FastAPI, SQLAlchemy, pytest)
+3. **Swift/SwiftUI** — iOS/macOS (Swift 6, SwiftUI, SwiftData, XCTest)
+4. **Generic** — Stack-agnostic (universal quality rules, no framework-specific config)
+5. **Custom** — Ask detailed questions about the stack
+
+### 2.3 Communication Language
+
+**"Communication language? (default: English)"**
+Options: English, German (du/informal), or specify another.
+
+### 2.4 Autonomy Level
+
+**"Autonomy level?"**
+
+1. **Conservative** — Claude asks before most actions. Best for learning the workflow or sensitive projects.
+2. **Standard** (recommended) — Autonomous within guardrails. Stops for plan approval, ambiguous scope, and breaking changes.
+3. **Full autonomy** — Decides everything. Only stops on errors or genuinely ambiguous scope.
+
+## Step 3: Read Templates and Stack Preset
+
+Read these files from the repo root:
+
+1. `system/templates/CLAUDE.md.tmpl` — Main configuration template
+2. `system/templates/settings.json.tmpl` — Settings template
+3. `system/templates/guardrails.md.tmpl` — Guardrails template
+4. `system/stacks/{selected-stack}.md` — Stack-specific content (nextjs-supabase.md, python-fastapi.md, swift-ios.md, or generic.md)
+
+The stack preset file contains values for these placeholders:
+
+- `{{TECH_STACK}}` — Technology list
+- `{{ARCHITECTURE_PRINCIPLES}}` — Architecture rules
+- `{{PROJECT_STRUCTURE}}` — Directory layout
+- `{{QUALITY_GATES}}` — Build/test/lint commands
+- `{{STACK_SPECIFIC_GUARDRAILS}}` — Framework-specific guardrails
+- `{{FORMATTER}}` — Code formatter name
+- `{{PACKAGE_MANAGER}}` — Package manager command
+
+## Step 4: Generate and Install Files
+
+Substitute all `{{PLACEHOLDER}}` values with the gathered configuration and stack preset values:
+
+| Placeholder                     | Source                                                                                |
+| ------------------------------- | ------------------------------------------------------------------------------------- |
+| `{{PROJECT_NAME}}`              | Step 2.1                                                                              |
+| `{{LANGUAGE}}`                  | Step 2.3 (formatted as instruction, e.g., "Speak German (du/informal) with the user") |
+| `{{TECH_STACK}}`                | Stack preset                                                                          |
+| `{{ARCHITECTURE_PRINCIPLES}}`   | Stack preset                                                                          |
+| `{{PROJECT_STRUCTURE}}`         | Stack preset                                                                          |
+| `{{QUALITY_GATES}}`             | Stack preset                                                                          |
+| `{{STACK_SPECIFIC_GUARDRAILS}}` | Stack preset                                                                          |
+| `{{FORMATTER}}`                 | Stack preset                                                                          |
+| `{{PACKAGE_MANAGER}}`           | Stack preset                                                                          |
+
+Create these files in the target project:
+
+### Configuration Files (3)
+
+1. **`{target}/CLAUDE.md`** — From `CLAUDE.md.tmpl` with all placeholders substituted
+2. **`{target}/.claude/settings.json`** — From `settings.json.tmpl` with placeholders substituted
+3. **`{target}/.claude/guardrails.md`** — From `guardrails.md.tmpl` with placeholders substituted
+
+### Reference Guide (1)
+
+4. **`{target}/AUTONOMOUS-WORKFLOW.md`** — Copy `system/templates/AUTONOMOUS-WORKFLOW.md` as-is
+
+### Workflow Commands (10)
+
+Copy ALL files from `system/commands/` to `{target}/.claude/commands/`:
+
+5. `plan.md` — Analysis + implementation plan + wait for approval
+6. `tdd.md` — Test-first development (RED → GREEN → REFACTOR)
+7. `verify.md` — Build + types + lint + tests verification
+8. `e2e.md` — End-to-end test creation and execution
+9. `code-review.md` — Security + quality audit
+10. `build-fix.md` — Incremental build error resolution
+11. `refactor-clean.md` — Dead code removal and cleanup
+12. `ralph-loop.md` — Iterative autonomous implementation loop
+13. `cancel-ralph.md` — Stop a running Ralph Loop
+14. `checkpoint.md` — Create a git restore point
+
+## Step 5: Verify Installation
+
+List all created files with their absolute paths in a table:
+
+```
+| # | File | Status |
+|---|------|--------|
+| 1 | {target}/CLAUDE.md | Created |
+| 2 | {target}/.claude/settings.json | Created |
+| ... | ... | ... |
+```
+
+Show a configuration summary:
+
+```
+| Setting | Value |
+|---------|-------|
+| Project | {name} |
+| Stack | {stack} |
+| Language | {language} |
+| Autonomy | {level} |
+| Commands installed | 10 |
+| Files created | {total count} |
+```
+
+## Step 6: Next Steps
+
+Tell the user:
+
+1. **"Open Claude Code in `{target}` to use the workflow"**
+2. **Available commands:** `/plan`, `/tdd`, `/verify`, `/e2e`, `/code-review`, `/build-fix`, `/refactor-clean`, `/ralph-loop`, `/cancel-ralph`, `/checkpoint`
+3. **"To create a PRD: come back to this repo and run `/prd:new`"**
+4. **"Read `AUTONOMOUS-WORKFLOW.md` for the complete reference guide"**
+5. **"Customize `CLAUDE.md` to match your specific project conventions"**
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md for user-facing communication.
+All installed file content must be in English.

package/system/commands/workshop/archive.md

@@ -0,0 +1,58 @@
+# /workshop:archive — Archive a Completed Project
+
+You archive a completed project by moving it from `workshop/projects/` to `workshop/archive/`.
+
+## Step 1: Identify Project
+
+Interpret `$ARGUMENTS` as project-slug.
+
+- If empty: List available projects under `workshop/projects/`, ask the user.
+
+Check if `workshop/projects/{slug}/` exists. If not: Inform the user, check whether it already exists under `workshop/archive/`.
+
+## Step 2: Check Readiness
+
+Read `workshop/projects/{slug}/PROJECT.md`.
+
+Check the status of all PRDs:
+
+- **All PRDs `handed-off`**: All good, proceed.
+- **Not all PRDs `handed-off`**: Warn the user with a list of incomplete PRDs and their current status. Explicitly ask: [in configured language] "Archive anyway?"
+- Wait for confirmation before proceeding.
+
+## Step 3: Ensure Archive Directory
+
+Check if `workshop/archive/` exists. If not, create it.
+
+## Step 4: Move Project
+
+Move the project directory:
+
+- From: `workshop/projects/{slug}/`
+- To: `archive/{YYYY-MM-DD}_{slug}/`
+
+Use today's date as the prefix.
+
+## Step 5: Update STATUS.md
+
+Read `STATUS.md` in the root directory (if present).
+Update the project list:
+
+- Remove the project from the active list.
+- Add it to the archive section (with archiving date).
+
+If `STATUS.md` does not exist, create it with the archive entry.
+
+## Step 6: Confirmation
+
+Confirm to the user:
+
+- Which project was archived.
+- Where it was moved to.
+- Whether all PRDs were in `handed-off` status.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.

package/system/commands/workshop/init.md

@@ -0,0 +1,78 @@
+# /workshop:init — Initialize a New Project Workspace
+
+You create the complete directory structure and template files for a new project.
+
+## Step 1: Validate Slug
+
+Interpret `$ARGUMENTS` as project-slug.
+
+If empty: Ask the user for a project name and derive the slug from it.
+
+Validate the slug format:
+
+- Only lowercase letters, digits, and hyphens allowed.
+- No spaces, no special characters, no umlauts.
+- Must start with a letter.
+- Examples: `my-saas-app`, `portfolio-2026`, `ai-agent-framework`
+
+If invalid: Suggest a corrected slug and ask the user.
+
+Check if `workshop/projects/{slug}/` already exists. If yes: Inform the user and ask whether `/prd:resume` was intended.
+
+## Step 2: Create Directory Structure
+
+Create the following structure:
+
+```
+workshop/projects/{slug}/
+  prds/
+  prompts/
+  notes/
+```
+
+## Step 3: Create PROJECT.md
+
+Read `workshop/templates/PROJECT.md` as a template.
+
+Create `workshop/projects/{slug}/PROJECT.md` with:
+
+- Project name (from slug, Title Case)
+- Today's date as creation date
+- Status: `discovery`
+- Empty PRD list
+- Empty fields for target_repo, tech_stack, etc.
+
+## Step 4: Create Notes Files
+
+Create `workshop/projects/{slug}/notes/discovery-log.md`:
+
+```markdown
+# Discovery Log
+
+## Session 1 — {today's date}
+
+(Notes will be added during discovery phase)
+```
+
+Create `workshop/projects/{slug}/notes/decisions.md`:
+
+```markdown
+# Decision Log
+
+| #   | Date | Decision | Rationale | Status |
+| --- | ---- | -------- | --------- | ------ |
+```
+
+## Step 5: Confirmation
+
+Confirm to the user:
+
+- Which directory was created.
+- Which files were set up.
+- Suggest continuing with `/prd:new {slug}`.
+
+## Communication
+
+Follow the language settings defined in CLAUDE.md.
+All file content must be written in English.
+User-facing communication uses the language configured in CLAUDE.md.