deepwork 0.1.0__tar.gz → 0.2.0__tar.gz

{deepwork-0.1.0 → deepwork-0.2.0}/.claude/commands/deepwork_jobs.define.md

@@ -11,13 +11,14 @@ hooks:
 
             Verify the job.yml output meets ALL quality criteria before completing:
 
-            1. **User Understanding**: Did you fully understand the user's workflow through interactive Q&A?
-            2. **Clear Inputs/Outputs**: Does every step have clearly defined inputs and outputs?
-            3. **Logical Dependencies**: Do step dependencies make sense and avoid circular references?
-            4. **Concise Summary**: Is the summary under 200 characters and descriptive?
-            5. **Rich Description**: Does the description provide enough context for future refinement?
-            6. **Valid Schema**: Does the job.yml follow the required schema (name, version, summary, steps)?
-            7. **File Created**: Has the job.yml file been created in `.deepwork/jobs/[job_name]/job.yml`?
+            1. **User Understanding**: Did you fully understand the user's workflow by asking structured questions?
+            2. **Structured Questions Used**: Did you ask structured questions (using the AskUserQuestion tool) to gather user input?
+            3. **Clear Inputs/Outputs**: Does every step have clearly defined inputs and outputs?
+            4. **Logical Dependencies**: Do step dependencies make sense and avoid circular references?
+            5. **Concise Summary**: Is the summary under 200 characters and descriptive?
+            6. **Rich Description**: Does the description provide enough context for future refinement?
+            7. **Valid Schema**: Does the job.yml follow the required schema (name, version, summary, steps)?
+            8. **File Created**: Has the job.yml file been created in `.deepwork/jobs/[job_name]/job.yml`?
 
             If ANY criterion is not met, continue working to address it.
             If ALL criteria are satisfied, include `<promise>✓ Quality Criteria Met</promise>` in your response.
@@ -44,14 +45,15 @@ hooks:
 ## Job Overview
 
 Core commands for managing DeepWork jobs. These commands help you define new multi-step
-workflows and refine existing ones.
+workflows and learn from running them.
 
 The `define` command guides you through an interactive process to create a new job by
-asking detailed questions about your workflow, understanding each step's inputs and outputs,
+asking structured questions about your workflow, understanding each step's inputs and outputs,
 and generating all necessary files.
 
-The `refine` command helps you modify existing jobs safely by understanding what you want
-to change, validating the impact, and ensuring consistency across your workflow.
+The `learn` command reflects on conversations where DeepWork jobs were run, identifies
+confusion or inefficiencies, and improves job instructions. It also captures bespoke
+learnings specific to the current run into AGENTS.md files in the working folder.
 
 
 
@@ -65,13 +67,15 @@ Create a `job.yml` specification file that defines the structure of a new DeepWo
 
 ## Task
 
-Guide the user through defining a job specification by asking clarifying questions. **Do not attempt to create the specification without first fully understanding the user's needs.**
+Guide the user through defining a job specification by asking structured questions. **Do not attempt to create the specification without first fully understanding the user's needs.**
+
+**Important**: Use the AskUserQuestion tool to ask structured questions when gathering information from the user. This provides a better user experience with clear options and guided choices.
 
 The output of this step is **only** the `job.yml` file - a complete specification of the workflow. The actual step instruction files will be created in the next step (`implement`).
 
 ### Step 1: Understand the Job Purpose
 
-Start by asking questions to understand what the user wants to accomplish:
+Start by asking structured questions to understand what the user wants to accomplish:
 
 1. **What is the overall goal of this workflow?**
    - What complex task are they trying to accomplish?
@@ -90,7 +94,7 @@ Start by asking questions to understand what the user wants to accomplish:
 
 ### Step 2: Define Each Step
 
-For each major phase they mentioned, ask detailed questions:
+For each major phase they mentioned, ask structured questions to gather details:
 
 1. **Step Purpose**
    - What exactly does this step accomplish?
@@ -121,6 +125,12 @@ For each major phase they mentioned, ask detailed questions:
 
 **Note**: You're gathering this information to understand what instructions will be needed, but you won't create the instruction files yet - that happens in the `implement` step.
 
+### Capability Considerations
+
+When defining steps, identify any that require specialized tools:
+
+**Browser Automation**: If any step involves web scraping, form filling, interactive browsing, UI testing, or research requiring website visits, ask the user what browser tools they have available. For Claude Code users, **Claude in Chrome** (Anthropic's browser extension) has been tested with DeepWork and is recommended for new users. Don't assume a default—confirm the tool before designing browser-dependent steps.
+
 ### Step 3: Validate the Workflow
 
 After gathering information about all steps:
@@ -145,7 +155,7 @@ After gathering information about all steps:
 
 For each step, consider whether it would benefit from **quality validation loops**. Stop hooks allow the AI agent to iteratively refine its work until quality criteria are met.
 
-**Ask the user about quality validation:**
+**Ask structured questions about quality validation:**
 - "Are there specific quality criteria that must be met for this step?"
 - "Would you like the agent to validate its work before completing?"
 - "What would make you send the work back for revision?"
@@ -188,68 +198,31 @@ stop_hooks:
 
 **Encourage prompt-based hooks** - They leverage the AI's ability to understand context and make nuanced quality judgments. Script hooks are best for objective checks (syntax, format, tests).
 
-### Step 5: Create the job.yml Specification
-
-Only after you have complete understanding, create the `job.yml` file:
+### Step 5: Create the Job Directory and Specification
 
-**File Location**: `.deepwork/jobs/[job_name]/job.yml`
+Only after you have complete understanding, create the job directory and `job.yml` file:
 
-(Where `[job_name]` is the name of the NEW job you're creating, e.g., `.deepwork/jobs/competitive_research/job.yml`)
+**First, create the directory structure** using the `make_new_job.sh` script:
 
-**Format**:
-```yaml
-name: [job_name]
-version: "1.0.0"
-summary: "[Brief one-line summary of what this job accomplishes]"
-description: |
-  [Detailed multi-line description of the job's purpose, process, and goals.
-
-  This should explain:
-  - What problem this workflow solves
-  - What the overall process looks like
-  - What the end result will be
-  - Who the intended users are
-  - Any important context about the workflow]
-
-changelog:
-  - version: "1.0.0"
-    changes: "Initial job creation"
-
-steps:
-  - id: [step_id]
-    name: "[Step Name]"
-    description: "[What this step does]"
-    instructions_file: steps/[step_id].md
-    inputs:
-      - name: [param_name]
-        description: "[What user needs to provide]"
-      # OR for file inputs from previous steps:
-      # - file: [filename_or_path]
-      #   from_step: [previous_step_id]
-    outputs:
-      - [output_filename_or_path]  # e.g., "report.md" or "reports/analysis.md"
-    dependencies: []  # List of step IDs that must complete first
-    # Optional: Quality validation hooks
-    stop_hooks:
-      - prompt: |
-          Verify this step's output meets quality criteria:
-          1. [Criterion 1]
-          2. [Criterion 2]
-          If ALL criteria are met, include `<promise>✓ Quality Criteria Met</promise>`.
-
-  - id: [another_step]
-    name: "[Another Step]"
-    description: "[What this step does]"
-    instructions_file: steps/[another_step].md
-    inputs:
-      - file: [output_filename_or_path]
-        from_step: [step_id]
-    outputs:
-      - [another_output_path]
-    dependencies:
-      - [step_id]  # This step requires the previous step
+```bash
+.deepwork/jobs/deepwork_jobs/make_new_job.sh [job_name]
 ```
 
+This creates:
+- `.deepwork/jobs/[job_name]/` - Main job directory
+- `.deepwork/jobs/[job_name]/steps/` - For step instruction files
+- `.deepwork/jobs/[job_name]/hooks/` - For custom validation scripts
+- `.deepwork/jobs/[job_name]/templates/` - For example file formats
+- `.deepwork/jobs/[job_name]/AGENTS.md` - Job management guidance
+
+**Then create the job.yml file** at `.deepwork/jobs/[job_name]/job.yml`
+
+(Where `[job_name]` is the name of the NEW job you're creating, e.g., `competitive_research`)
+
+**Template reference**: See `.deepwork/jobs/deepwork_jobs/templates/job.yml.template` for the standard structure.
+
+**Complete example**: See `.deepwork/jobs/deepwork_jobs/templates/job.yml.example` for a fully worked example.
+
 **Important**:
 - Use lowercase with underscores for job name and step IDs
 - Ensure file inputs reference steps in dependencies
@@ -371,11 +344,11 @@ Run `/deepwork_jobs.implement` to generate the instruction files for each step b
 ## Important Guidelines
 
 1. **Focus on specification only** - Don't create instruction files yet
-2. **Ask clarifying questions** - Never skip the discovery phase
+2. **Ask structured questions** - Never skip the discovery phase; use the AskUserQuestion tool
 3. **Rich context in description** - This helps with future refinement
 4. **Validate understanding** - Summarize and confirm before creating
 5. **Use examples** - Help users understand what good specifications look like
-6. **Understand file organization** - Always ask where outputs should be saved and if subdirectories are needed
+6. **Understand file organization** - Always ask structured questions about where outputs should be saved and if subdirectories are needed
 
 ## Validation Rules
 
@@ -409,6 +382,7 @@ After creating the file:
 
 ## Quality Criteria
 
+- Asked structured questions to fully understand user requirements
 - User fully understands what job they're creating
 - All steps have clear inputs and outputs
 - Dependencies make logical sense
@@ -455,13 +429,14 @@ This step uses an iterative quality validation loop. After completing your work,
 ### Quality Criteria
 Verify the job.yml output meets ALL quality criteria before completing:
 
-1. **User Understanding**: Did you fully understand the user's workflow through interactive Q&A?
-2. **Clear Inputs/Outputs**: Does every step have clearly defined inputs and outputs?
-3. **Logical Dependencies**: Do step dependencies make sense and avoid circular references?
-4. **Concise Summary**: Is the summary under 200 characters and descriptive?
-5. **Rich Description**: Does the description provide enough context for future refinement?
-6. **Valid Schema**: Does the job.yml follow the required schema (name, version, summary, steps)?
-7. **File Created**: Has the job.yml file been created in `.deepwork/jobs/[job_name]/job.yml`?
+1. **User Understanding**: Did you fully understand the user's workflow by asking structured questions?
+2. **Structured Questions Used**: Did you ask structured questions (using the AskUserQuestion tool) to gather user input?
+3. **Clear Inputs/Outputs**: Does every step have clearly defined inputs and outputs?
+4. **Logical Dependencies**: Do step dependencies make sense and avoid circular references?
+5. **Concise Summary**: Is the summary under 200 characters and descriptive?
+6. **Rich Description**: Does the description provide enough context for future refinement?
+7. **Valid Schema**: Does the job.yml follow the required schema (name, version, summary, steps)?
+8. **File Created**: Has the job.yml file been created in `.deepwork/jobs/[job_name]/job.yml`?
 
 If ANY criterion is not met, continue working to address it.
 If ALL criteria are satisfied, include `<promise>✓ Quality Criteria Met</promise>` in your response.

{deepwork-0.1.0 → deepwork-0.2.0}/.claude/commands/deepwork_jobs.implement.md

@@ -16,9 +16,9 @@ hooks:
             3. **Specific & Actionable**: Are instructions tailored to each step's purpose, not generic?
             4. **Output Examples**: Does each instruction file show what good output looks like?
             5. **Quality Criteria**: Does each instruction file define quality criteria for its outputs?
-            6. **Sync Complete**: Has `deepwork sync` been run successfully?
-            7. **Commands Available**: Are the slash-commands generated in `.claude/commands/`?
-            8. **Summary Created**: Has `implementation_summary.md` been created?
+            6. **Ask Structured Questions**: Do step instructions that gather user input explicitly use the phrase "ask structured questions"?
+            7. **Sync Complete**: Has `deepwork sync` been run successfully?
+            8. **Commands Available**: Are the slash-commands generated in `.claude/commands/`?
             9. **Policies Considered**: Have you thought about whether policies would benefit this job?
                - If relevant policies were identified, did you explain them and offer to run `/deepwork_policy.define`?
                - Not every job needs policies - only suggest when genuinely helpful.
@@ -48,14 +48,15 @@ hooks:
 ## Job Overview
 
 Core commands for managing DeepWork jobs. These commands help you define new multi-step
-workflows and refine existing ones.
+workflows and learn from running them.
 
 The `define` command guides you through an interactive process to create a new job by
-asking detailed questions about your workflow, understanding each step's inputs and outputs,
+asking structured questions about your workflow, understanding each step's inputs and outputs,
 and generating all necessary files.
 
-The `refine` command helps you modify existing jobs safely by understanding what you want
-to change, validating the impact, and ensuring consistency across your workflow.
+The `learn` command reflects on conversations where DeepWork jobs were run, identifies
+confusion or inefficiencies, and improves job instructions. It also captures bespoke
+learnings specific to the current run into AGENTS.md files in the working folder.
 
 
 ## Prerequisites
@@ -77,10 +78,31 @@ Generate the DeepWork job directory structure and instruction files for each ste
 
 Read the `job.yml` specification file and create all the necessary files to make the job functional, including directory structure and step instruction files. Then sync the commands to make them available.
 
-### Step 1: Read and Validate the Specification
+### Step 1: Create Directory Structure Using Script
+
+Run the `make_new_job.sh` script to create the standard directory structure:
+
+```bash
+.deepwork/jobs/deepwork_jobs/make_new_job.sh [job_name]
+```
+
+This creates:
+- `.deepwork/jobs/[job_name]/` - Main job directory
+- `.deepwork/jobs/[job_name]/steps/` - Step instruction files
+- `.deepwork/jobs/[job_name]/hooks/` - Custom validation scripts (with .gitkeep)
+- `.deepwork/jobs/[job_name]/templates/` - Example file formats (with .gitkeep)
+- `.deepwork/jobs/[job_name]/AGENTS.md` - Job management guidance
+
+**Note**: If the directory already exists (e.g., job.yml was created by define step), you can skip this step or manually create the additional directories:
+```bash
+mkdir -p .deepwork/jobs/[job_name]/hooks .deepwork/jobs/[job_name]/templates
+touch .deepwork/jobs/[job_name]/hooks/.gitkeep .deepwork/jobs/[job_name]/templates/.gitkeep
+```
+
+### Step 2: Read and Validate the Specification
 
 1. **Locate the job.yml file**
-   - Read `.deepwork/jobs/[job_name]/job.yml` from the define step (Where `[job_name]` is the name of the new job that was created in the define step)
+   - Read `.deepwork/jobs/[job_name]/job.yml` from the define step
    - Parse the YAML content
 
 2. **Validate the specification**
@@ -94,83 +116,20 @@ Read the `job.yml` specification file and create all the necessary files to make
    - List of all steps with their details
    - Understand the workflow structure
 
-### Step 2: Create Directory Structure
-
-Create the job directory in `.deepwork/jobs/[job_name]/`:
-
-```bash
-mkdir -p .deepwork/jobs/[job_name]/steps
-```
-
-Files to create:
-- `.deepwork/jobs/[job_name]/job.yml`
-- `.deepwork/jobs/[job_name]/steps/[step_id].md` - One for each step
-
 ### Step 3: Generate Step Instruction Files
 
 For each step in the job.yml, create a comprehensive instruction file at `.deepwork/jobs/[job_name]/steps/[step_id].md`.
 
-Each instruction file should follow this structure:
-
-```markdown
-# [Step Name]
-
-## Objective
-
-[Clear statement of what this step accomplishes, derived from the step's description]
-
-## Task
-
-[Detailed instructions for completing this step, based on:
-- The step's purpose
-- Expected inputs and outputs
-- The job's overall context
-]
-
-### Process
-
-[Break down the step into substeps. Use the information gathered during define about:
-- What needs to be done
-- What makes a good output
-- Any quality criteria
-]
+**Template reference**: See `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.template` for the standard structure.
 
-1. [Substep 1]
-2. [Substep 2]
-3. [Substep 3]
+**Complete example**: See `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.example` for a fully worked example.
 
-[If this step has user inputs, explain how to gather them]
-[If this step has file inputs, explain how to use them]
-
-## Output Format
-
-### [output_filename_1]
-
-[Description of what should be in this output file]
-
-**Structure**:
-```[file format]
-[Example or template of what the output should look like]
-```
-
-[Repeat for each output file]
-
-## Quality Criteria
-
-[List what makes this step's output high quality:
-- Completeness checks
-- Format requirements
-- Content requirements
-]
-
-- [Quality criterion 1]
-- [Quality criterion 2]
-- [Quality criterion 3]
-
-## Context
-
-[Provide context from the job's overall description to help understand why this step matters and how it fits into the bigger picture]
-```
+**Available templates in `.deepwork/jobs/deepwork_jobs/templates/`:**
+- `job.yml.template` - Job specification structure
+- `step_instruction.md.template` - Step instruction file structure
+- `agents.md.template` - AGENTS.md file structure
+- `job.yml.example` - Complete job specification example
+- `step_instruction.md.example` - Complete step instruction example
 
 **Guidelines for generating instructions:**
 
@@ -180,6 +139,7 @@ Each instruction file should follow this structure:
 4. **Explain the "why"** - Help the user understand the step's role in the workflow
 5. **Quality over quantity** - Detailed, actionable instructions are better than vague ones
 6. **Align with stop hooks** - If the step has `stop_hooks` defined, ensure the quality criteria in the instruction file match the validation criteria in the hooks
+7. **Ask structured questions** - When a step has user inputs, the instructions MUST explicitly tell the agent to "ask structured questions" using the AskUserQuestion tool to gather that information. Never use generic phrasing like "ask the user" - always use "ask structured questions"
 
 ### Handling Stop Hooks
 
@@ -213,6 +173,12 @@ If a step in the job.yml has `stop_hooks` defined, the generated instruction fil
 
 This alignment ensures the AI agent knows exactly what will be validated and can self-check before completing.
 
+### Using Supplementary Reference Files
+
+Step instructions can include additional `.md` files in the `steps/` directory for detailed examples, templates, or reference material. Reference them using the full path from the project root.
+
+See `.deepwork/jobs/deepwork_jobs/steps/supplemental_file_references.md` for detailed documentation and examples.
+
 ### Step 4: Verify job.yml Location
 
 Verify that `job.yml` is in the correct location at `.deepwork/jobs/[job_name]/job.yml`. The define step should have created it there. If for some reason it's not there, you may need to create or move it.
@@ -230,11 +196,9 @@ This will:
 - Generate slash-commands for each step
 - Make the commands available in `.claude/commands/` (or appropriate platform directory)
 
-### Step 6: Reload Commands
+### Step 6: Relay Reload Instructions
 
-Instruct the user to reload commands in their current session:
-- Run `/reload` command (if available)
-- Or restart the Claude session
+After running `deepwork sync`, look at the "To use the new commands" section in the output. **Relay these exact reload instructions to the user** so they know how to pick up the new commands. Don't just reference the sync output - tell them directly what they need to do (e.g., "Type 'exit' then run 'claude --resume'" for Claude Code, or "Run '/memory refresh'" for Gemini CLI).
 
 ### Step 7: Consider Policies for the New Job
 
@@ -298,112 +262,9 @@ Would you like me to create this policy? I can run `/deepwork_policy.define` to
 
 ## Example Implementation
 
-**Given this job.yml:**
-```yaml
-name: competitive_research
-version: "1.0.0"
-summary: "Systematic competitive analysis workflow"
-description: |
-  A comprehensive workflow for analyzing competitors in your market segment.
-  Helps product teams understand the competitive landscape through systematic
-  identification, research, comparison, and positioning recommendations.
-
-steps:
-  - id: identify_competitors
-    name: "Identify Competitors"
-    description: "Identify 5-7 key competitors in the target market"
-    instructions_file: steps/identify_competitors.md
-    inputs:
-      - name: market_segment
-        description: "The market segment to analyze"
-      - name: product_category
-        description: "The product category"
-    outputs:
-      - competitors_list.md
-    dependencies: []
-```
-
-**Generate this instruction file** (`.deepwork/jobs/competitive_research/steps/identify_competitors.md`):
-
-```markdown
-# Identify Competitors
-
-## Objective
-
-Identify 5-7 key competitors in the target market segment to analyze for competitive positioning.
-
-## Task
-
-Research and identify the most relevant competitors in the specified market segment and product category. Focus on companies that directly compete for the same customer base and solve similar problems.
-
-### Process
-
-1. **Understand the market context**
-   - Review the market segment provided by the user
-   - Understand the product category boundaries
-   - Consider direct and indirect competitors
-
-2. **Research competitors**
-   - Search for companies in this space
-   - Look for market leaders and emerging players
-   - Consider different competitive dimensions (features, price, target market)
-
-3. **Select 5-7 key competitors**
-   - Prioritize direct competitors
-   - Include at least one market leader
-   - Include 1-2 emerging/innovative players
-   - Ensure diversity in the competitive set
-
-4. **Document each competitor**
-   - Company name
-   - Brief description (2-3 sentences)
-   - Why they're a relevant competitor
-   - Primary competitive dimension
-
-## Output Format
-
-### competitors_list.md
-
-A markdown document listing each competitor with context.
-
-**Structure**:
-```markdown
-# Competitor Analysis: [Market Segment]
-
-## Market Context
-- **Segment**: [market segment]
-- **Category**: [product category]
-- **Analysis Date**: [current date]
-
-## Identified Competitors
-
-### 1. [Competitor Name]
-**Description**: [2-3 sentence description of what they do]
-
-**Why Relevant**: [Why they're a key competitor in this space]
-
-**Competitive Dimension**: [What they compete on - e.g., price, features, market segment]
-
-[Repeat for each competitor, 5-7 total]
-
-## Selection Rationale
-
-[Brief paragraph explaining why these specific competitors were chosen and what dimensions of competition they represent]
-```
-
-## Quality Criteria
-
-- 5-7 competitors identified (not too few, not too many)
-- Mix of established and emerging players
-- All competitors are genuinely relevant to the market segment
-- Each competitor has clear, specific description
-- Selection rationale explains the competitive landscape
-- Output is well-formatted and ready for use by next step
-
-## Context
-
-This is the foundation step for competitive analysis. The competitors identified here will be deeply researched in subsequent steps, so it's important to choose the right set. Focus on competitors that will provide strategic insights for positioning decisions.
-```
+For a complete worked example showing a job.yml and corresponding step instruction file, see:
+- **Job specification**: `.deepwork/jobs/deepwork_jobs/templates/job.yml.example`
+- **Step instruction**: `.deepwork/jobs/deepwork_jobs/templates/step_instruction.md.example`
 
 ## Important Guidelines
 
@@ -422,63 +283,6 @@ Before running `deepwork sync`, verify:
 - All step instruction files exist (one per step)
 - No file system errors
 
-## Output Format
-
-### implementation_summary.md
-
-After successful implementation, create a summary:
-
-```markdown
-# Job Implementation Complete: [job_name]
-
-## Overview
-
-Successfully implemented the **[job_name]** workflow with [N] steps.
-
-**Summary**: [job summary]
-
-**Version**: [version]
-
-## Files Created
-
-### Job Definition
-- `.deepwork/jobs/[job_name]/job.yml`
-
-### Step Instructions
-- `.deepwork/jobs/[job_name]/steps/[step1_id].md`
-- `.deepwork/jobs/[job_name]/steps/[step2_id].md`
-[... list all step files ...]
-
-
-## Generated Commands
-
-After running `deepwork sync`, the following slash-commands are now available:
-
-- `/[job_name].[step1_id]` - [step description]
-- `/[job_name].[step2_id]` - [step description]
-[... list all commands ...]
-
-## Next Steps
-
-1. **Reload commands**: Run `/reload` or restart your Claude session
-2. **Start the workflow**: Run `/[job_name].[first_step_id]` to begin
-3. **Test the job**: Try executing the first step to ensure everything works
-
-## Job Structure
-
-[Show the workflow diagram with step names and dependencies]
-
-Step 1: [step_name]
-  ↓
-Step 2: [step_name]
-  ↓
-Step 3: [step_name]
-  ↓
-[Final output]
-
-The job is now ready for use!
-```
-
 ## Completion Checklist
 
 Before marking this step complete, ensure:
@@ -487,8 +291,7 @@ Before marking this step complete, ensure:
 - [ ] Each instruction file is complete and actionable
 - [ ] `deepwork sync` executed successfully
 - [ ] Commands generated in platform directory
-- [ ] User informed of next steps (reload commands)
-- [ ] implementation_summary.md created
+- [ ] User informed to follow reload instructions from `deepwork sync`
 - [ ] Considered whether policies would benefit this job (Step 7)
 - [ ] If policies suggested, offered to run `/deepwork_policy.define`
 
@@ -499,6 +302,7 @@ Before marking this step complete, ensure:
 - Instructions are specific and actionable
 - Output examples are provided in each instruction file
 - Quality criteria defined for each step
+- Steps with user inputs explicitly use "ask structured questions" phrasing
 - Sync completed successfully
 - Commands available for use
 - Thoughtfully considered relevant policies for the job domain
@@ -531,7 +335,7 @@ All work for this job should be done on a dedicated work branch:
 ## Output Requirements
 
 Create the following output(s):
-- `implementation_summary.md`
+- `steps/` (directory)
 Ensure all outputs are:
 - Well-formatted and complete
 - Ready for review or use by subsequent steps
@@ -548,9 +352,9 @@ Verify the implementation meets ALL quality criteria before completing:
 3. **Specific & Actionable**: Are instructions tailored to each step's purpose, not generic?
 4. **Output Examples**: Does each instruction file show what good output looks like?
 5. **Quality Criteria**: Does each instruction file define quality criteria for its outputs?
-6. **Sync Complete**: Has `deepwork sync` been run successfully?
-7. **Commands Available**: Are the slash-commands generated in `.claude/commands/`?
-8. **Summary Created**: Has `implementation_summary.md` been created?
+6. **Ask Structured Questions**: Do step instructions that gather user input explicitly use the phrase "ask structured questions"?
+7. **Sync Complete**: Has `deepwork sync` been run successfully?
+8. **Commands Available**: Are the slash-commands generated in `.claude/commands/`?
 9. **Policies Considered**: Have you thought about whether policies would benefit this job?
    - If relevant policies were identified, did you explain them and offer to run `/deepwork_policy.define`?
    - Not every job needs policies - only suggest when genuinely helpful.
@@ -577,14 +381,14 @@ After completing this step:
 
 2. **Inform the user**:
    - Step 2 of 3 is complete
-   - Outputs created: implementation_summary.md
-   - Ready to proceed to next step: `/deepwork_jobs.refine`
+   - Outputs created: steps/
+   - Ready to proceed to next step: `/deepwork_jobs.learn`
 
 ## Next Step
 
 To continue the workflow, run:
 ```
-/deepwork_jobs.refine
+/deepwork_jobs.learn
 ```
 
 ---