rafcode 1.0.1 → 1.1.0

package/RAF/016-planning-scalpel/decisions.md

@@ -0,0 +1,7 @@
+# Project Decisions
+
+## What files should be included in the task commit?
+Code + outcome + this task's plan - Commit the code changes made during the task, the outcome file, and the plan file for this specific task (e.g., 001-task-name.md). Not all plan files, just the one related to the current task.
+
+## How should Claude determine which code files to commit?
+Trust Claude's judgment - Instruct Claude to only add files it explicitly modified during the task, relying on its awareness of changes. No need to verify with git diff.

package/RAF/016-planning-scalpel/input.md

@@ -0,0 +1 @@
+commit only plan that is related to the task (change instruction in task execution prompt)

package/RAF/016-planning-scalpel/outcomes/001-update-git-commit-instructions.md

@@ -0,0 +1,38 @@
+# Outcome: Update Git Commit Instructions
+
+## Summary
+
+Updated the task execution prompt to commit only files related to the current task instead of using `git add -A` which staged all changes including unrelated files.
+
+## Key Changes
+
+**File modified**: `src/prompts/execution.ts` (lines 89-104)
+
+**Before**:
+```
+1. Stage all changes with `git add -A`
+   - This includes any new plan files in the `plans/` folder
+```
+
+**After**:
+```
+1. Stage only the files you modified during this task:
+   - Add each code file you changed: `git add <file1> <file2> ...`
+   - Add the outcome file: `git add ${outcomeFilePath}`
+   - Add this task's plan file: `git add ${planPath}`
+```
+
+## Acceptance Criteria Verification
+
+- [x] `git add -A` is no longer used in the execution prompt
+- [x] Instructions clearly tell Claude to add only modified files
+- [x] Outcome file path is explicitly included in staging instructions
+- [x] Plan file path for the current task is explicitly included
+- [x] All existing tests pass (733 tests passed)
+
+## Notes
+
+- The `planPath` and `outcomeFilePath` variables were already available in the function scope, so no additional code changes were needed
+- This is a prompt text change only - no structural code changes
+
+<promise>COMPLETE</promise>

package/RAF/016-planning-scalpel/plans/001-update-git-commit-instructions.md

@@ -0,0 +1,43 @@
+# Task: Update Git Commit Instructions
+
+## Objective
+Modify the task execution prompt to commit only files related to the current task instead of all changes.
+
+## Context
+Currently, the execution prompt instructs Claude to use `git add -A`, which stages all changes including unrelated files. This can result in commits containing changes that don't belong to the current task. The fix ensures each task commit is scoped to only its relevant changes.
+
+## Requirements
+- Replace `git add -A` with explicit file staging
+- Commit must include: code files modified during the task, the outcome file, and the plan file for the current task
+- Claude should use its own judgment about which files it modified (no git diff verification needed)
+- Remove the misleading comment about "any new plan files in the plans/ folder"
+
+## Implementation Steps
+1. Read `src/prompts/execution.ts`
+2. Locate the `commitInstructions` section (around lines 89-101)
+3. Replace the current git add instruction:
+   ```typescript
+   // Current (lines 93-95):
+   1. Stage all changes with \`git add -A\`
+      - This includes any new plan files in the \`plans/\` folder
+
+   // Replace with:
+   1. Stage only the files you modified during this task:
+      - Add each code file you changed: \`git add <file1> <file2> ...\`
+      - Add the outcome file: \`git add ${outcomeFilePath}\`
+      - Add this task's plan file: \`git add ${planPath}\`
+   ```
+4. Ensure the string template variables (`${outcomeFilePath}`, `${planPath}`) are properly interpolated
+5. Run tests to verify no regressions
+
+## Acceptance Criteria
+- [ ] `git add -A` is no longer used in the execution prompt
+- [ ] Instructions clearly tell Claude to add only modified files
+- [ ] Outcome file path is explicitly included in staging instructions
+- [ ] Plan file path for the current task is explicitly included
+- [ ] All existing tests pass
+
+## Notes
+- The `planPath` variable is already available in the `getExecutionPrompt` function params
+- The `outcomeFilePath` variable is also already available
+- This is a prompt text change only - no structural code changes needed

package/RAF/017-decision-vault/decisions.md

@@ -0,0 +1,13 @@
+# Project Decisions
+
+## What commit message format should be used for planning artifacts?
+RAF[NNN] Plan: project-name - Follow existing RAF commit convention with 'Plan:' prefix
+
+## Should this commit happen automatically or be opt-in via a flag?
+Always commit automatically after every successful planning session
+
+## What should happen if the git commit fails (e.g., not in a git repo)?
+Warn and continue - Show a warning message but don't fail the planning session
+
+## Which files should be committed after planning?
+Only input.md and decisions.md - Just the input and decisions, not the generated plans

package/RAF/017-decision-vault/input.md

@@ -0,0 +1,2 @@
+make raf commit decisions and input after planning complete (go to current project folder and commit
+only these files)

package/RAF/017-decision-vault/outcomes/001-create-git-commit-utility.md

@@ -0,0 +1,53 @@
+# Outcome: Create Git Commit Utility for Planning Artifacts
+
+## Summary
+
+Created the `commitPlanningArtifacts` function in `src/core/git.ts` that commits planning artifacts (input.md and decisions.md) with a consistent commit message format.
+
+## Changes Made
+
+### Files Modified
+- **src/core/git.ts**: Added `commitPlanningArtifacts` function and required imports
+
+### Files Created
+- **tests/unit/commit-planning-artifacts.test.ts**: Comprehensive unit tests (8 test cases)
+
+## Implementation Details
+
+The `commitPlanningArtifacts(projectPath: string): Promise<void>` function:
+
+1. **Extracts project info** from the path using existing `extractProjectNumber` and `extractProjectName` utilities
+2. **Stages only specific files**: Uses explicit paths for `input.md` and `decisions.md` (no wildcards)
+3. **Commit message format**: `RAF[NNN] Plan: project-name` (e.g., `RAF[017] Plan: decision-vault`)
+4. **Graceful error handling**:
+   - Logs warning if not in git repo
+   - Logs warning if project number/name can't be extracted
+   - Handles "nothing to commit" silently (debug log)
+   - Other errors logged as warnings, never thrown
+
+## Test Coverage
+
+8 unit tests covering:
+- Correct commit message format (numeric and base36 project numbers)
+- Staging only input.md and decisions.md (no wildcards)
+- Not in git repository handling
+- Invalid project path handling
+- "Nothing to commit" handling (both early check and commit error)
+- Other git error handling (warning log, no throw)
+
+## Acceptance Criteria Verification
+
+- [x] Function `commitPlanningArtifacts` exists in `src/core/git.ts`
+- [x] Function stages only input.md and decisions.md
+- [x] Commit message follows format `RAF[NNN] Plan: project-name`
+- [x] Git failures result in warning log, not thrown error
+- [x] Function handles "nothing to commit" gracefully
+- [x] TypeScript compiles without errors (verified with `npm run build`)
+
+## Notes
+
+- The plan suggested `src/utils/git.ts` but `src/core/git.ts` already existed with git utilities, so the function was added there for consistency
+- The function is exported and ready to be integrated into the plan command (Task 002)
+- All 741 existing tests continue to pass
+
+<promise>COMPLETE</promise>

package/RAF/017-decision-vault/outcomes/002-integrate-commit-into-plan.md

@@ -0,0 +1,44 @@
+# Outcome: Integrate Commit into Plan Command
+
+## Summary
+
+Integrated the `commitPlanningArtifacts` function (from Task 001) into the plan command to automatically commit planning artifacts (input.md and decisions.md) after successful planning in both regular and amend modes.
+
+## Changes Made
+
+### Files Modified
+- **src/commands/plan.ts**: Added import and commit calls in both `runPlanCommand()` and `runAmendCommand()`
+
+## Implementation Details
+
+1. **Import added** at the top of plan.ts:
+   ```typescript
+   import { commitPlanningArtifacts } from '../core/git.js';
+   ```
+
+2. **Integration in `runPlanCommand()`** (line 207-208):
+   - Placed after the "Planning complete!" success message
+   - Placed before the "Run 'raf do'" info message
+   - Inside the `if (planFiles.length > 0)` block (no commit if no plans created)
+
+3. **Integration in `runAmendCommand()`** (line 388-389):
+   - Placed after the "Amendment complete!" success message
+   - Placed before the "Total tasks" / "Run 'raf do'" info messages
+   - Inside the `if (newPlanFiles.length > 0)` block (no commit if no new plans created)
+
+## Acceptance Criteria Verification
+
+- [x] Regular `raf plan` commits input.md and decisions.md after planning
+- [x] `raf plan --amend` commits input.md and decisions.md after amendment
+- [x] No commit attempted if no plan files were created
+- [x] Git warnings displayed but don't interrupt success flow
+- [x] TypeScript compiles without errors (verified with `npm run build`)
+- [x] All 741 existing tests continue to pass
+
+## Notes
+
+- The `commitPlanningArtifacts` function handles all error cases gracefully (logs warnings, never throws)
+- Commit happens automatically without any user flag
+- The flow maintains clean logging - git warnings appear but don't overshadow the success message
+
+<promise>COMPLETE</promise>

package/RAF/017-decision-vault/outcomes/003-add-tests-for-planning-commit.md

@@ -0,0 +1,51 @@
+# Outcome: Add Tests for Planning Commit Functionality
+
+## Summary
+
+Verified that comprehensive unit tests for `commitPlanningArtifacts` already exist from Task 001. The tests cover all required scenarios and all acceptance criteria are satisfied.
+
+## Analysis
+
+### Plan vs Reality
+
+The plan requested tests at `tests/utils/git.test.ts`, but Task 001 already created tests at `tests/unit/commit-planning-artifacts.test.ts`. This location is actually preferable because:
+
+1. It follows the existing project convention (all unit tests are in `tests/unit/`)
+2. There's already a `tests/unit/git.test.ts` that tests other git utilities (`parseGitStatus`)
+3. Having a dedicated file for `commitPlanningArtifacts` improves test organization
+
+### Existing Test Coverage (8 tests)
+
+| Test | Acceptance Criteria |
+|------|---------------------|
+| should commit input.md and decisions.md with correct message format | Successful commit scenario |
+| should handle base36 project numbers | Commit message format (base36) |
+| should warn and return when not in git repository | Not a git repo scenario |
+| should warn when project number cannot be extracted | Error handling |
+| should handle "nothing to commit" gracefully | Nothing to commit (early check) |
+| should handle commit error with "nothing to commit" message | Nothing to commit (commit error) |
+| should warn on other git errors without throwing | Error handling |
+| should only stage input.md and decisions.md | Verifies no wildcards |
+
+### Test Results
+
+- All 8 `commitPlanningArtifacts` tests pass
+- All 741 tests in the project pass
+- No new code changes were needed
+
+## Acceptance Criteria Verification
+
+- [x] Test file exists (at `tests/unit/commit-planning-artifacts.test.ts`)
+- [x] Tests cover successful commit scenario
+- [x] Tests verify commit message format
+- [x] Tests cover "not a git repo" scenario
+- [x] Tests cover "nothing to commit" scenario
+- [x] All tests pass with `npm test`
+
+## Notes
+
+- The "files don't exist" scenario mentioned in the plan is implicitly covered by the "nothing to commit" tests, since git add on non-existent files results in nothing staged
+- Task 001 followed TDD practices and created tests alongside the implementation
+- No additional tests or changes were required for this task
+
+<promise>COMPLETE</promise>

package/RAF/017-decision-vault/plans/001-create-git-commit-utility.md

@@ -0,0 +1,38 @@
+# Task: Create Git Commit Utility for Planning Artifacts
+
+## Objective
+Create a utility function that commits input.md and decisions.md files after planning completes.
+
+## Context
+RAF currently commits code changes during task execution, but planning artifacts (input.md and decisions.md) are not committed. This task creates a reusable utility to commit these files with a consistent commit message format.
+
+## Requirements
+- Commit only `input.md` and `decisions.md` from the project folder (not plans/)
+- Use commit message format: `RAF[NNN] Plan: project-name`
+  - NNN is the 3-digit project number (e.g., 017)
+  - project-name is the kebab-case project name (e.g., decision-vault)
+- If git commit fails (not in repo, nothing to commit, etc.), log a warning and continue
+- Never fail the planning session due to git issues
+
+## Implementation Steps
+1. Create a new file `src/utils/git.ts` (or add to existing git utilities if present)
+2. Implement `commitPlanningArtifacts(projectPath: string): Promise<void>` function:
+   - Extract project number and name from projectPath
+   - Build the commit message: `RAF[NNN] Plan: project-name`
+   - Run `git add` for only `input.md` and `decisions.md` (use explicit paths)
+   - Run `git commit -m "message"`
+   - Catch any errors and log warning (don't throw)
+3. Export the function for use in plan command
+
+## Acceptance Criteria
+- [ ] Function `commitPlanningArtifacts` exists in `src/utils/git.ts`
+- [ ] Function stages only input.md and decisions.md
+- [ ] Commit message follows format `RAF[NNN] Plan: project-name`
+- [ ] Git failures result in warning log, not thrown error
+- [ ] Function handles "nothing to commit" gracefully
+- [ ] TypeScript compiles without errors
+
+## Notes
+- Look at existing git usage in the codebase for patterns (execution prompt uses git for task commits)
+- Use `child_process.exec` or similar for git commands
+- The function should be idempotent - calling it when files are already committed should just warn

package/RAF/017-decision-vault/plans/002-integrate-commit-into-plan.md

@@ -0,0 +1,39 @@
+# Task: Integrate Commit into Plan Command
+
+## Objective
+Call the git commit utility after planning completes successfully in both regular and amend modes.
+
+## Context
+The commit utility from task 001 needs to be integrated into the plan command. The commit should happen automatically after Claude finishes planning and plan files have been created.
+
+## Dependencies
+001
+
+## Requirements
+- Commit happens automatically (no flag needed)
+- Commit after both regular `raf plan` and `raf plan --amend`
+- Only attempt commit if at least one plan file was created
+- Warning on failure should not affect the success message shown to user
+
+## Implementation Steps
+1. Import `commitPlanningArtifacts` in `src/commands/plan.ts`
+2. In `runPlanCommand()`:
+   - After the "Planning complete!" success message (around line 199-207)
+   - Before the final `logger.info` about running `raf do`
+   - Call `await commitPlanningArtifacts(projectPath)`
+3. In `runAmendCommand()`:
+   - After the "Amendment complete!" success message (around line 376-386)
+   - Before the final `logger.info` about running `raf do`
+   - Call `await commitPlanningArtifacts(projectPath)`
+4. Ensure the commit call is inside the `if (planFiles.length > 0)` block so we only commit when plans exist
+
+## Acceptance Criteria
+- [ ] Regular `raf plan` commits input.md and decisions.md after planning
+- [ ] `raf plan --amend` commits input.md and decisions.md after amendment
+- [ ] No commit attempted if no plan files were created
+- [ ] Git warnings displayed but don't interrupt success flow
+- [ ] TypeScript compiles without errors
+
+## Notes
+- The projectPath variable is already available in both functions
+- Keep the logging flow clean - git warning should appear but not overshadow success message

package/RAF/017-decision-vault/plans/003-add-tests-for-planning-commit.md

@@ -0,0 +1,40 @@
+# Task: Add Tests for Planning Commit Functionality
+
+## Objective
+Write unit tests for the git commit utility to ensure correct behavior in various scenarios.
+
+## Context
+The new git commit functionality needs test coverage to verify it works correctly and handles edge cases properly.
+
+## Dependencies
+001
+
+## Requirements
+- Test the `commitPlanningArtifacts` function
+- Cover success and failure scenarios
+- Mock git commands to avoid actual git operations in tests
+
+## Implementation Steps
+1. Create test file `tests/utils/git.test.ts`
+2. Write tests for:
+   - **Happy path**: Successfully commits input.md and decisions.md
+   - **Correct commit message**: Verifies format `RAF[NNN] Plan: project-name`
+   - **Not a git repo**: Warns and continues (doesn't throw)
+   - **Nothing to commit**: Warns and continues (doesn't throw)
+   - **Files don't exist**: Warns and continues (doesn't throw)
+3. Mock `child_process.exec` or the underlying git execution
+4. Verify correct files are staged (only input.md and decisions.md)
+5. Run tests and ensure they pass
+
+## Acceptance Criteria
+- [ ] Test file exists at `tests/utils/git.test.ts`
+- [ ] Tests cover successful commit scenario
+- [ ] Tests verify commit message format
+- [ ] Tests cover "not a git repo" scenario
+- [ ] Tests cover "nothing to commit" scenario
+- [ ] All tests pass with `npm test`
+
+## Notes
+- Follow existing test patterns in the codebase
+- Use Jest mocking for git command execution
+- Look at other test files in `tests/` for patterns and conventions

package/README.md

@@ -8,92 +8,91 @@ RAF is a CLI tool that orchestrates task planning and execution using Claude Cod
 
 **GitHub:** [https://github.com/john-veresk/raf](https://github.com/john-veresk/raf)
 
-## Features
+## Vision
 
-- **Interactive Planning**: Claude interviews you to break down complex tasks
-- **Smart Project Naming**: Auto-generates descriptive project names using Claude Haiku
-- **Automated Execution**: Execute plans with retry logic and progress tracking
-- **Resume Support**: Continue from where you left off after interruption
-- **Git Integration**: Automatic commits after each completed task
-- **Multi-Project Execution**: Run multiple projects in sequence
+Good software of the future will be built with good decisions by humans, not AI. RAF is software that builds other software by capitalizing on human ability to **make choices** and take ownership.
+
+## Why RAF?
+
+**Human decisions matter** — RAF focuses on interviewing you during planning. Right questions lead to right decisions, and right decisions lead to better software.
+
+**Better reviews** — Review the intent, decisions, plan and outcomes, not AI generated code.
+
+**Context rot** — Long AI sessions lose focus and make mistakes. RAF splits work into small, focused tasks that Claude executes one at a time with fresh context.
+
+**Reliable execution** — Modern LLMs are remarkably capable when given clear instructions. A well-crafted plan yields working solutions reliably. RAF helps you build good plans.
 
-## Installation
+**Save on tokens** — Less back-and-forth during debugging saves tokens, even with planning overhead.
+
+## Quick Start
 
 ```bash
+# Install
 npm install -g raf
+
+# Plan a project - Claude will interview you and create a detailed plan
+raf plan
+
+# Execute the plan
+raf do
 ```
 
+That's it! RAF will guide you through breaking down your task and then execute it step by step.
+
 ## Requirements
 
 - Node.js 20+
 - Claude Code CLI installed and configured
 
-## Usage
+## Features
 
-### Plan a Project
+- **Interactive Planning**: Claude interviews you to break down complex tasks into 3-8 distinct tasks
+- **Automated Execution**: Execute plans with retry logic and progress tracking
+- **Resume Support**: Continue from where you left off after interruption
+- **Git Integration**: Automatic commits after each completed task
+- **Task Dependencies**: Tasks can depend on other tasks, with automatic blocking on failure
 
-```bash
-raf plan [projectName]
-```
+## Commands
 
-Opens your `$EDITOR` to write a project description, then Claude will:
-1. Identify 3-8 distinct tasks
-2. Interview you about each task
-3. Create detailed plan files
+### `raf plan`
 
-To add tasks to an existing project:
+Opens your `$EDITOR` to write a project description, then Claude will interview you and create detailed task plans.
 
 ```bash
-raf plan --amend <identifier>
+raf plan              # Create a new project
+raf plan my-feature   # Create with a specific name
+raf plan --amend 3    # Add tasks to existing project #3
 ```
 
-### Execute Plans
+### `raf do`
 
-```bash
-raf do <projects...>
-```
-
-Execute one or more projects. Accepts project identifiers in multiple formats:
+Execute project tasks. Without arguments, shows a picker to select a pending project.
 
 ```bash
-raf do my-project           # By name
-raf do 3                    # By number
-raf do 001-my-project       # By folder name
-raf do 3 4 5                # Multiple projects
+raf do                # Interactive picker
+raf do 3              # Execute project #3
+raf do my-project     # Execute by name
+raf do 3 4 5          # Execute multiple projects
 ```
 
-Options:
-- `-t, --timeout <minutes>` - Timeout per task (default: 60)
-- `-v, --verbose` - Show full Claude output
-- `-d, --debug` - Save all logs and show debug output
-- `-f, --force` - Re-run all tasks regardless of status
+### `raf status`
 
-### Check Status
+Check project status.
 
 ```bash
-raf status [identifier]
+raf status            # List all projects
+raf status 3          # Show details for project #3
 ```
 
-Without an identifier, lists all projects with their status. With an identifier, shows detailed task list:
+## Status Symbols
 
-```bash
-raf status              # List all projects
-raf status my-project   # Show details for a project
-raf status 3            # By project number
-raf status --json       # Output as JSON
 ```
-
-Status badges:
-- `[ ]` pending
-- `[x]` completed
-- `[!]` failed
-
-Project status badges:
-- `[P]` planning
-- `[R]` ready
-- `[~]` executing
-- `[x]` completed
-- `[!]` failed
+○  pending     - task not yet started
+●  running     - task currently executing
+✓  completed   - task finished successfully
+✗  failed      - task failed
+⊘  blocked     - task blocked by failed dependency
+```
 
 ## Project Structure
 
@@ -102,7 +101,7 @@ RAF creates a `./RAF/` folder with numbered project directories:
 ```
 ./RAF/
 ├── 001-auth-system/
-│   ├── input.md           # Your original description
+│   ├── input.md           # Your original intent (raw prompt)
 │   ├── decisions.md       # Design decisions from planning
 │   ├── plans/             # Generated task plans
 │   ├── outcomes/          # Execution results
@@ -111,6 +110,35 @@ RAF creates a `./RAF/` folder with numbered project directories:
     └── ...
 ```
 
+## Command Reference
+
+### `raf plan [projectName]`
+
+| Option | Description |
+|--------|-------------|
+| `--amend <id>` | Add tasks to existing project |
+| `-y, --auto` | Skip permission prompts (runs in dangerous mode) |
+
+### `raf do [projects...]`
+
+| Option | Description |
+|--------|-------------|
+| `-t, --timeout <min>` | Timeout per task (default: 60) |
+| `-f, --force` | Re-run all tasks regardless of status |
+| `-d, --debug` | Save all logs and show debug output |
+| `-m, --model <name>` | Claude model (sonnet, haiku, opus) |
+| `--sonnet` | Shorthand for `--model sonnet` |
+
+Alias: `raf act`
+
+> **Note:** `raf do` and `raf plan -y` run Claude with `--dangerously-skip-permissions` for fully automated execution without interactive prompts.
+
+### `raf status [identifier]`
+
+| Option | Description |
+|--------|-------------|
+| `--json` | Output as JSON |
+
 ## License
 
 MIT

package/dist/commands/plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/commands/plan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqCpC,wBAAgB,iBAAiB,IAAI,OAAO,CAqC3C"}
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../src/commands/plan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsCpC,wBAAgB,iBAAiB,IAAI,OAAO,CAqC3C"}

package/dist/commands/plan.js

@@ -4,6 +4,7 @@ import { ProjectManager } from '../core/project-manager.js';
 import { ClaudeRunner } from '../core/claude-runner.js';
 import { openEditor, getInputTemplate } from '../core/editor.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
+import { commitPlanningArtifacts } from '../core/git.js';
 import { getPlanningPrompt } from '../prompts/planning.js';
 import { getAmendPrompt } from '../prompts/amend.js';
 import { validateEnvironment, reportValidation, validateProjectName, resolveModelOption, } from '../utils/validation.js';
@@ -156,6 +157,8 @@ async function runPlanCommand(projectName, model, autoMode = false) {
             for (const planFile of planFiles) {
                 logger.info(`  - plans/${planFile}`);
             }
+            // Commit planning artifacts (input.md and decisions.md)
+            await commitPlanningArtifacts(projectPath);
             logger.newline();
             logger.info(`Run 'raf do ${finalProjectName}' to execute the plans.`);
         }
@@ -308,6 +311,8 @@ async function runAmendCommand(identifier, model, autoMode = false) {
             for (const planFile of newPlanFiles) {
                 logger.info(`  - plans/${planFile}`);
             }
+            // Commit planning artifacts (input.md and decisions.md)
+            await commitPlanningArtifacts(projectPath);
             logger.newline();
             logger.info(`Total tasks: ${allPlanFiles.length}`);
             logger.info(`Run 'raf do ${identifier}' to execute the new tasks.`);