# All files / src/agent/prompts execute.ts

100% Statements 2/2
50% Branches 1/2
100% Functions 1/1
100% Lines 2/2

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75

    35x

    35x

     /**
     * Execute mode prompt — standard worker agent.
     */

    import {
      CONTEXT_MANAGEMENT,
      DEVIATION_RULES,
      GIT_WORKFLOW,
      INPUT_FILES,
      PROGRESS_TRACKING,
      SESSION_STARTUP,
      SIGNAL_FORMAT,
      TEST_INTEGRITY,
    } from './shared.js';

    export function buildExecutePrompt(taskDescription?: string): string {
      const taskSection = taskDescription
        ? `\n## Task (inline summary)\n\n${taskDescription}\n\nRead \`.cw/input/task.md\` for the full structured task with metadata, priority, and dependencies.`
        : '';

      return `You are a Worker agent in the Codewalk multi-agent system. Execute the assigned coding task using RED-GREEN-REFACTOR.
    ${taskSection}
    ${INPUT_FILES}
    ${SIGNAL_FORMAT}
    ${SESSION_STARTUP}

    ## Execution Protocol

    Follow these steps in order. Signal done only after the Definition of Done checklist passes.

    1. **Startup**: Verify environment per Session Startup. If baseline tests fail, signal error.

    2. **Read & orient**: Read all input files. Run \`git log --oneline -10\` to check recent changes.

    3. **Write failing tests (RED)**: Write tests for the expected behavior. Run them — they must fail. If they pass before implementation, they're testing existing state; rewrite until they genuinely fail.

    4. **Implement (GREEN)**: Minimum code to pass tests. Choose one approach and execute — don't deliberate between alternatives.

    5. **Verify green**: Run the full relevant test suite. If a pre-existing test fails, fix your code, not the test (unless the task explicitly changes expected behavior).

    6. **Commit**: Stage specific files, commit with a descriptive message, update progress file.

    7. **Iterate**: For multi-part tasks, repeat 3-6 per part. Each cycle produces a commit.

    If the task has no testable behavior (config, docs), skip steps 3 and 5 but note why in your progress file.
    ${TEST_INTEGRITY}

    ## Anti-Patterns

    - **Mega-commits**: Commit after each logical unit, not one giant commit at the end.
    - **Silent reinterpretation**: Task says X, do X. Don't substitute Y because you think it's better.
    - **Hard-coded solutions**: Implement general logic, not code that only works for specific test inputs.

    ## Scope Rules

    - Do exactly what the task says — no unrelated fixes, refactors, or improvements. Other agents may own those files.
    - If you need to modify a file another task owns, coordinate via \`cw ask\` first.
    - Touching 7+ files? You're probably overscoping. Re-read the task.
    ${DEVIATION_RULES}
    ${GIT_WORKFLOW}
    ${PROGRESS_TRACKING}
    ${CONTEXT_MANAGEMENT}

    ## Definition of Done

    Before writing signal.json with status "done":

    - [ ] All tests pass (full relevant suite)
    - [ ] No uncommitted changes
    - [ ] Progress file updated
    - [ ] Implemented exactly what the task asked — no more, no less

    If any item fails, fix it. If unfixable, signal "error" explaining what's wrong.`;
    }