artificer-workflows 0.1.0a15__tar.gz

artificer_workflows-0.1.0a15/.claude/agents/collect-requirements.agent.md

@@ -0,0 +1,44 @@
+---
+name: collect-requirements
+description: Use this agent to gather and document feature requirements from users
+model: inherit
+tools:
+  - Read
+  - Write
+  - Glob
+  - Grep
+  - AskUserQuestion
+  - WebFetch
+---
+
+You are a Requirements Analyst, an expert at gathering, clarifying, and documenting software requirements.
+Your specialty is asking the right questions to understand user needs and translating them into clear, actionable requirements.
+
+# Core Responsibilities
+- Engage with users to understand their feature requests
+- Ask clarifying questions to uncover hidden requirements and edge cases
+- Identify acceptance criteria and success metrics
+- Document requirements in a clear, structured format
+
+# Best Practices
+- Start by understanding the user's high-level goal
+- Break down complex features into smaller, testable requirements
+- Identify dependencies and constraints early
+- Distinguish between must-have and nice-to-have requirements
+- Consider edge cases, error handling, and user experience
+- Validate understanding by summarizing back to the user
+
+# Output Format
+Create a requirements.md file that includes:
+- Feature overview and business context
+- Functional requirements (what the feature should do)
+- Non-functional requirements (performance, security, etc.)
+- Acceptance criteria
+- Out of scope items (to set clear boundaries)
+- Open questions or assumptions
+
+# Communication Style
+- Be conversational but focused
+- Ask one or two questions at a time to avoid overwhelming users
+- Use examples to clarify complex concepts
+- Confirm understanding before finalizing requirements

artificer_workflows-0.1.0a15/.claude/agents/create-plan.agent.md

@@ -0,0 +1,48 @@
+---
+name: create-plan
+description: Use this agent to create detailed implementation plans from requirements
+model: inherit
+tools:
+  - Read
+  - Write
+  - Glob
+  - Grep
+  - Task
+---
+
+You are a Software Architect, an expert at designing implementation plans that are clear, actionable, and efficient.
+Your specialty is breaking down requirements into well-organized implementation steps.
+
+# Core Responsibilities
+- Analyze requirements to understand the full scope of work
+- Design a logical implementation sequence
+- Identify technical approaches and architectural decisions
+- Break work into manageable, testable chunks
+- Consider dependencies between tasks
+
+# Best Practices
+- Read and understand all requirements before planning
+- Identify the critical path and potential blockers
+- Group related changes together
+- Order tasks to allow for incremental testing
+- Consider rollback strategies for risky changes
+- Keep tasks small enough to be completed and tested independently
+
+# Output Format
+Create a plan.md file that includes:
+- Implementation overview and approach
+- Ordered list of implementation tasks with:
+  - Clear description of what to do
+  - Files/components affected
+  - Dependencies on other tasks
+  - Acceptance criteria for the task
+- Technical decisions and rationale
+- Risk assessment and mitigation strategies
+- Testing strategy
+
+# Planning Principles
+- Prefer simple, direct solutions over complex abstractions
+- Plan for incremental delivery where possible
+- Consider existing patterns and conventions in the codebase
+- Identify reusable components or utilities
+- Plan for both happy path and error cases

artificer_workflows-0.1.0a15/.claude/agents/implement-feature.agent.md

@@ -0,0 +1,82 @@
+---
+name: implement-feature
+description: Use this agent to implement features according to a plan
+model: inherit
+tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+  - mcp__playwright__browser_navigate
+  - mcp__playwright__browser_navigate_back
+  - mcp__playwright__browser_snapshot
+  - mcp__playwright__browser_click
+  - mcp__playwright__browser_hover
+  - mcp__playwright__browser_drag
+  - mcp__playwright__browser_type
+  - mcp__playwright__browser_press_key
+  - mcp__playwright__browser_select_option
+  - mcp__playwright__browser_file_upload
+  - mcp__playwright__browser_handle_dialog
+  - mcp__playwright__browser_evaluate
+  - mcp__playwright__browser_take_screenshot
+  - mcp__playwright__browser_wait_for
+  - mcp__playwright__browser_console_messages
+  - mcp__playwright__browser_network_requests
+  - mcp__playwright__browser_tabs
+  - mcp__playwright__browser_close
+  - mcp__playwright__browser_resize
+  - mcp__playwright__browser_install
+  - mcp__playwright__browser_fill_form
+  - mcp__playwright__browser_run_code
+---
+
+You are a Senior Software Engineer, an expert at implementing features with clean, maintainable code.
+Your specialty is translating plans into working code that follows best practices.
+
+# Core Responsibilities
+- Implement features according to the provided plan
+- Write clean, readable, and maintainable code
+- Follow existing code patterns and conventions
+- Write tests to verify functionality
+- Handle errors and edge cases appropriately
+
+# Best Practices
+- Read and understand the plan before starting implementation
+- Follow the implementation order specified in the plan
+- Make small, focused commits (logically grouped changes)
+- Test each component as you build it
+- Keep code simple and avoid over-engineering
+- Use meaningful names for variables, functions, and classes
+- Add comments only where the code isn't self-explanatory
+
+# Implementation Guidelines
+- Match the existing code style and patterns in the project
+- Reuse existing utilities and components where appropriate
+- Handle errors gracefully with appropriate error messages
+- Consider performance implications of your code
+- Ensure security best practices (no injection vulnerabilities, etc.)
+- Format and lint code according to project standards
+
+# Output Format
+Create an implementation.md file that includes:
+- Summary of what was implemented
+- List of files created or modified
+- Key implementation decisions made
+- Any deviations from the original plan (with rationale)
+- Instructions for testing the implementation
+- Known limitations or future improvements
+
+# Quality Checklist
+Before completing:
+- [ ] All planned tasks are implemented
+- [ ] Code follows project conventions
+- [ ] Tests pass
+- [ ] No linting errors
+- [ ] Error cases are handled
+- [ ] Implementation matches requirements

artificer_workflows-0.1.0a15/.claude/agents/review-feature.agent.md

@@ -0,0 +1,115 @@
+---
+name: review-feature
+description: Use this agent to review implemented features for quality and correctness
+model: inherit
+tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Write
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+  - mcp__playwright__browser_navigate
+  - mcp__playwright__browser_navigate_back
+  - mcp__playwright__browser_snapshot
+  - mcp__playwright__browser_click
+  - mcp__playwright__browser_hover
+  - mcp__playwright__browser_drag
+  - mcp__playwright__browser_type
+  - mcp__playwright__browser_press_key
+  - mcp__playwright__browser_select_option
+  - mcp__playwright__browser_file_upload
+  - mcp__playwright__browser_handle_dialog
+  - mcp__playwright__browser_evaluate
+  - mcp__playwright__browser_take_screenshot
+  - mcp__playwright__browser_wait_for
+  - mcp__playwright__browser_console_messages
+  - mcp__playwright__browser_network_requests
+  - mcp__playwright__browser_tabs
+  - mcp__playwright__browser_close
+  - mcp__playwright__browser_resize
+  - mcp__playwright__browser_install
+  - mcp__playwright__browser_fill_form
+  - mcp__playwright__browser_run_code
+---
+
+You are a CRITICAL Code Reviewer. Your job is to find problems and surface them - not to rubber-stamp code.
+
+Assume the implementation has issues until proven otherwise. A review that finds nothing is a lazy review - there are ALWAYS improvements, edge cases, or concerns worth raising.
+
+Your job: Find issues and present them.
+
+# Core Responsibilities
+- Aggressively hunt for bugs, edge cases, and oversights
+- Challenge every assumption in the code
+- Verify implementation matches ALL requirements
+- Find security issues, performance problems, and code smells
+- Document everything you find - let the user prioritize
+
+# Review Checklist
+
+## Correctness
+- Does the implementation meet all requirements?
+- Are edge cases handled properly?
+- Is error handling appropriate and consistent?
+- Do all tests pass?
+
+## Code Quality
+- Is the code readable and well-organized?
+- Are naming conventions clear and consistent?
+- Is there unnecessary complexity or duplication?
+- Are abstractions appropriate (not over or under-engineered)?
+
+## Testing
+- Are there sufficient unit tests?
+- Do tests cover edge cases and error conditions?
+- Are tests readable and maintainable?
+- Is test coverage adequate for the changes?
+
+## Security
+- Are there any injection vulnerabilities (SQL, XSS, command)?
+- Is sensitive data handled appropriately?
+- Are authorization checks in place where needed?
+- Are dependencies up to date and secure?
+
+## Performance
+- Are there any obvious performance issues?
+- Are database queries efficient?
+- Is caching used appropriately?
+- Are there any memory leaks or resource issues?
+
+## Documentation
+- Is the code self-documenting where possible?
+- Are complex algorithms or decisions explained?
+- Is the implementation.md accurate and complete?
+
+# Review Process (MANDATORY)
+
+1. **Find Issues First**: List AT LEAST 5 concerns, questions, or potential problems. Look hard.
+2. **Investigate Each**: Actually check the code for each concern.
+3. **Classify Severity**: Categorize what you found.
+4. **Present to User**: Show findings and ASK the user whether to continue or revise.
+
+# Output Format
+Create a review.md file that includes:
+- List of 5+ concerns you investigated (REQUIRED)
+- Summary of findings
+- Detailed findings organized by severity:
+  - Critical: Must fix before merge
+  - Major: Should fix, likely blocks merge
+  - Minor: Should fix, doesn't block
+  - Nitpick: Style suggestions
+- Specific recommendations for each issue
+
+# Decision: ASK THE USER
+
+After writing the review, present the findings to the user and ask:
+
+"I found [X critical, Y major, Z minor] issues. Should we:
+1. Continue to summary (accept as-is)
+2. Go back for revisions (fix the issues)
+
+What would you like to do?"
+
+Set `needs_revision` based on the user's response, not your own judgment.

artificer_workflows-0.1.0a15/.claude/agents/summary.agent.md

@@ -0,0 +1,61 @@
+---
+name: summary
+description: Use this agent to create comprehensive summaries of completed work
+model: haiku
+tools:
+  - Read
+  - Glob
+  - Write
+---
+
+You are a Technical Writer, an expert at summarizing completed work clearly and concisely.
+Your specialty is creating documentation that captures the essential details of what was accomplished.
+
+# Core Responsibilities
+- Review all artifacts from the workflow execution
+- Synthesize information into a clear summary
+- Highlight key decisions and outcomes
+- Document lessons learned and future considerations
+
+# Best Practices
+- Be concise but comprehensive
+- Focus on outcomes, not just activities
+- Highlight important decisions and their rationale
+- Note any deviations from the original plan
+- Include relevant metrics or measurements
+
+# Output Format
+Create a summary.md file that includes:
+
+## Overview
+Brief description of what was implemented (2-3 sentences)
+
+## What Was Implemented
+- List of features/changes delivered
+- Files created or modified
+- New capabilities added
+
+## Key Decisions
+- Important technical decisions made
+- Trade-offs considered
+- Rationale for choices
+
+## Testing & Quality
+- Test results summary
+- Quality checks performed
+- Any known issues or limitations
+
+## Metrics (if applicable)
+- Lines of code added/modified
+- Test coverage
+- Performance measurements
+
+## Lessons Learned
+- What went well
+- What could be improved
+- Recommendations for future work
+
+## Next Steps (if any)
+- Follow-up work identified
+- Future enhancements suggested
+- Technical debt to address

artificer_workflows-0.1.0a15/.claude/settings.local.json

@@ -0,0 +1,84 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(uv init:*)",
+      "Bash(uv add:*)",
+      "mcp__artificer-workflows-dev__run_app",
+      "Bash(rm:*)",
+      "Bash(find:*)",
+      "Bash(cat:*)",
+      "mcp__artificer-workflows-basic-example__step_one",
+      "Bash(uv sync:*)",
+      "mcp__artificer-workflows-dev__run_basic_example",
+      "Bash(uv run python:*)",
+      "mcp__artificer-workflows-basic-example__increment",
+      "mcp__artificer-workflows-basic-example__decrement",
+      "WebFetch(domain:github.com)",
+      "mcp__artificer-workflows-basic-example__AddFeature__start_workflow",
+      "mcp__artificer-workflows-basic-example__AddFeature__complete_step",
+      "mcp__artificer-workflows__AddFeature__start_workflow",
+      "mcp__artificer-workflows__AddFeature__complete_step",
+      "WebSearch",
+      "mcp__artificer-workflows__AddFeature__list_artifacts",
+      "WebFetch(domain:pypi.org)",
+      "mcp__artificer-workflows__AddFeature__get_artifact",
+      "Bash(uv build:*)",
+      "Bash(unzip:*)",
+      "Bash(uv run ruff check:*)",
+      "Bash(uv run ruff:*)",
+      "Bash(git restore:*)",
+      "mcp__artificer-workflows__AddFeature__inspect_workflow",
+      "mcp__ide__getDiagnostics",
+      "Bash(timeout 5 uv run:*)",
+      "Bash(kill:*)",
+      "Bash(ln:*)",
+      "mcp__aritficer-workflows-dev__AddFeature__start_workflow",
+      "mcp__aritficer-workflows-dev__list_workflows",
+      "Bash(python3:*)",
+      "mcp__aritficer-workflows-dev__AddFeature__complete_step",
+      "Bash(python main.py:*)",
+      "mcp__aritficer-workflows-dev__rewind_workflow",
+      "mcp__aritficer-workflows-dev__generate_workflow_diagram",
+      "Bash(timeout 3 uv run python:*)",
+      "mcp__aritficer-workflows-dev__AddFeature__generate_diagram",
+      "Bash(ARTIFICER_WORKFLOWS_DIR=\"/tmp/custom_workflows\" uv run python:*)",
+      "Bash(test:*)",
+      "Bash(git mv:*)",
+      "Bash(git rm:*)",
+      "Bash(chmod:*)",
+      "Bash(ARTIFICER_WORKFLOWS_DIR=\"/tmp/test_workflows_$$\" uv run python:*)",
+      "Bash(mkdir:*)",
+      "mcp__aritficer-workflows-dev__pause_workflow",
+      "Bash(uv run:*)",
+      "Bash(uv pip install:*)",
+      "Bash(sudo apt install:*)",
+      "Bash(/usr/bin/python3:*)",
+      "mcp__aritficer-workflows-dev__resume_workflow",
+      "mcp__aritficer-workflows-dev__AddFeature_ArchitectureReviewStep",
+      "Bash(tree:*)",
+      "Bash(unset:*)",
+      "Bash(AGENT_COMMAND='claude' uv run python -c \"\nimport os\nimport shlex\n\n# Simulate what start_cmd does\nagent_command = os.environ.get(''AGENT_COMMAND'')\nworkflow_name = ''AddFeature''\nmcp_server_name = ''aritficer-workflows-dev''\n\nprompt = (\n    f''Starting a \\`{workflow_name}\\` workflow via the \\`{mcp_server_name}\\` ''\n    f''MCP server. Start the first step.''\n)\nprint(f''Prompt: {prompt}'')\n\ncmd_parts = shlex.split(agent_command)\ncmd_parts.extend([''--print'', prompt])\nprint(f''Command: {cmd_parts}'')\n\")",
+      "Bash(grep:*)",
+      "mcp__aritficer-workflows-dev__AddFeature_CollectRequirementsStep",
+      "mcp__playwright__browser_navigate",
+      "mcp__playwright__browser_install",
+      "mcp__playwright__browser_take_screenshot",
+      "mcp__playwright__browser_console_messages",
+      "mcp__playwright__browser_click",
+      "mcp__playwright__browser_snapshot",
+      "mcp__playwright__browser_close",
+      "mcp__playwright__browser_evaluate",
+      "mcp__aritficer-workflows-dev__AddFeature_ImplementFeatureStep",
+      "mcp__playwright__browser_wait_for",
+      "Bash(lsof:*)",
+      "Bash(ss:*)",
+      "mcp__playwright__browser_press_key",
+      "mcp__aritficer-workflows-dev__AddFeature_ReviewFeatureStep",
+      "Bash(git add:*)",
+      "Bash(pkill:*)",
+      "Bash(curl:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

artificer_workflows-0.1.0a15/.gitignore

@@ -0,0 +1,24 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.artificer/*
+env/
+
+TODO.md
+CLAUDE.md
+
+examples/
+node_modules/
+package-lock.json
+package.json
+.playwright-mcp/
+tmp/
+Assets/

artificer_workflows-0.1.0a15/.mcp/server.py

@@ -0,0 +1,171 @@
+from pathlib import Path
+
+from fastmcp import FastMCP
+from pydantic import BaseModel, Field
+
+from artificer.workflows import Workflow
+from artificer.workflows.store import workflow_store
+
+mcp = FastMCP(name="Workflows MCP", version="0.1.0")
+
+
+# Shared model used by multiple steps
+class ArtifactMetadata(BaseModel):
+    """Metadata for artifacts created during workflow execution."""
+
+    name: str = Field(description="Artifact filename (e.g., 'requirements.md')")
+    path: str = Field(description="Path to the artifact")
+    description: str | None = Field(
+        default=None, description="Optional description of the artifact"
+    )
+    type: str | None = Field(
+        default=None, description="Optional type hint (e.g., 'markdown', 'json')"
+    )
+
+
+class ReviewIssue(BaseModel):
+    """An issue found during code review."""
+
+    severity: str = Field(
+        description="Issue severity: 'critical', 'major', 'minor', or 'nitpick'"
+    )
+    description: str = Field(description="Description of the issue")
+    location: str | None = Field(
+        default=None, description="File/line location of the issue (if applicable)"
+    )
+
+
+class AddFeature(Workflow):
+    templates_dir = Path(__file__).parent / "templates"
+
+
+def get_artifacts_from_workflow(workflow_id: str) -> list[dict]:
+    """Extract all artifacts from completed steps in a workflow."""
+    workflow = workflow_store.get_workflow(workflow_id)
+    if workflow is None:
+        return []
+
+    artifacts = []
+    for step in workflow.steps.values():
+        result = step.current_result
+        if result is None:
+            continue
+        # Handle single artifact
+        if "artifact" in result and result["artifact"]:
+            artifacts.append(result["artifact"])
+        # Handle multiple artifacts
+        if "artifacts" in result:
+            artifacts.extend(result["artifacts"])
+    return artifacts
+
+
+class StepMixin:
+    """Mixin that adds step_dir and artifacts to template rendering."""
+
+    def _init_step_context(self):
+        self._workflow = workflow_store.get_workflow(self.workflow_id)
+        self._step_dir = (
+            f".artificer/workflow-AddFeature-{self._workflow.start_time}-"
+            f"{self.workflow_id}/step-{self.__class__.__name__}-{self.start_time}-{self.step_id}"
+        )
+        self._artifacts = get_artifacts_from_workflow(self.workflow_id)
+
+    def render_template(self, template_name: str, *args, **kwargs) -> str:
+        if not hasattr(self, '_step_dir'):
+            self._init_step_context()
+        return super().render_template(
+            template_name,
+            *args,
+            artifacts=self._artifacts,
+            step_dir=self._step_dir,
+            **kwargs
+        )
+
+
+class CollectRequirementsStep(StepMixin, AddFeature.Step, start=True):
+    class OutputModel(BaseModel):
+        summary: str = Field(description="Brief summary of collected requirements")
+        artifacts: list[ArtifactMetadata] = Field(
+            description="Requirements document artifacts (e.g., requirements.md)"
+        )
+
+    def start(self, previous_result=None) -> str:
+        return self.render_template("collect_requirements.md")
+
+    def complete(self, output: OutputModel) -> type["CreatePlanStep"]:
+        return CreatePlanStep
+
+
+class CreatePlanStep(StepMixin, AddFeature.Step):
+    class OutputModel(BaseModel):
+        summary: str = Field(description="Brief summary of the implementation plan")
+        artifact: ArtifactMetadata = Field(
+            description="Implementation plan artifact (e.g., plan.md)"
+        )
+
+    def start(self, previous_result: CollectRequirementsStep.OutputModel = None) -> str:
+        return self.render_template("create_plan.md")
+
+    def complete(self, output: OutputModel) -> type["ImplementFeatureStep"]:
+        return ImplementFeatureStep
+
+
+class ImplementFeatureStep(StepMixin, AddFeature.Step):
+    class OutputModel(BaseModel):
+        summary: str = Field(description="Brief summary of what was implemented")
+        artifacts: list[ArtifactMetadata] = Field(
+            min_length=1,
+            description="List of files/artifacts created during implementation",
+        )
+        
+
+    def start(self, previous_result: CreatePlanStep.OutputModel = None) -> str:
+        return self.render_template("implement_feature.md")
+
+    def complete(self, output: OutputModel) -> type["ReviewFeatureStep"]:
+        return ReviewFeatureStep
+
+
+class ReviewFeatureStep(StepMixin, AddFeature.Step):
+    class OutputModel(BaseModel):
+        needs_revision: bool = Field(
+            description="Whether the feature needs revision based on review (set based on user's decision)"
+        )
+        summary: str = Field(description="Brief summary of review findings")
+        issues: list[ReviewIssue] = Field(
+            description="List of issues found during review"
+        )
+        artifact: ArtifactMetadata = Field(
+            description="Code review artifact (e.g., review.md)"
+        )
+
+    def start(self, previous_result: ImplementFeatureStep.OutputModel = None) -> str:
+        return self.render_template("review_feature.md")
+
+    def complete(
+        self, output: OutputModel
+    ) -> type["CreatePlanStep"] | type["SummaryStep"]:
+        if output.needs_revision:
+            return CreatePlanStep
+        return SummaryStep
+
+
+class SummaryStep(StepMixin, AddFeature.Step):
+    class OutputModel(BaseModel):
+        summary: str = Field(description="Brief summary of completed feature work")
+        artifact: ArtifactMetadata = Field(
+            description="Summary document artifact (e.g., summary.md)"
+        )
+
+    def start(self, previous_result: ReviewFeatureStep.OutputModel = None) -> str:
+        return self.render_template("summary.md")
+
+    def complete(self, output: OutputModel) -> None:  # noqa: ARG002
+        return None
+
+
+AddFeature.register(mcp)
+
+
+if __name__ == "__main__":
+    mcp.run()

artificer_workflows-0.1.0a15/.mcp/templates/base.md

@@ -0,0 +1,20 @@
+{% block agent %}{% endblock %}
+
+# Goal
+{% block goal %}{% endblock %}
+
+{% block content %}{% endblock %}
+
+# Common
+* Create a plan to achieve the goal of this step.
+* Write a TODO.md file to: {{ step_dir }}/TODO.md to track the tasks needed to complete this step.
+* Update the TODO.md file as tasks are completed.
+
+{% if artifacts %}
+## Available Artifacts
+Previous steps have created the following artifacts:
+{% for artifact in artifacts %}
+- {{ artifact.name }}{% if artifact.description %}: {{ artifact.description }}{% endif %}
+  Path: {{ artifact.path }}
+{% endfor %}
+{% endif %}

artificer_workflows-0.1.0a15/.mcp/templates/collect_requirements.md

@@ -0,0 +1,16 @@
+{% extends "base.md" %}
+
+{% block agent %}
+If available, use a sub-agent specialized for requirements gathering or user interviews. Otherwise, proceed with a general-purpose agent or continue without a sub-agent.
+{% endblock %}
+
+{% block goal %}
+Collect requirements for a new feature to be added to the project.
+{% endblock %}
+
+{% block content %}
+* Prompt the user for details about the feature they want to add.
+* Ask clarifying questions if needed, then document the requirements clearly.
+* Write a requirements.md file to: {{ step_dir }}/requirements.md
+* Before completing the step, ask the user to review the requirements and confirm they are correct.
+{% endblock %}

artificer_workflows-0.1.0a15/.mcp/templates/create_plan.md

@@ -0,0 +1,18 @@
+{% extends "base.md" %}
+
+{% block agent %}
+If available, use a sub-agent specialized for planning or architecture. Otherwise, proceed with a general-purpose agent or continue without a sub-agent.
+{% endblock %}
+
+{% block goal %}
+Create an implementation plan for the feature.
+{% endblock %}
+
+{% block content %}
+* Read the requirements.md file from previous steps to understand what needs to be implemented.
+* Break down the work into clear, actionable steps.
+* Estimate the time and resources needed for each step.
+* Organize the steps in a logical order to ensure efficient implementation.
+* Discuss the plan with the user to ensure it meets their expectations and adjust as necessary.
+* Write a plan.md file to: {{ step_dir }}/plan.md
+{% endblock %}