pdd change doesn't wait for response after posting clarification/architecture questions

[niti-go]

When pdd change posts clarification questions (Step 4) or architectural questions (Step 7) to a GitHub issue, the workflow continues to the next step instead of stopping to wait for a response.

Steps to Reproduce

1. Run pdd change on an issue that requires architectural or requirements clarification
2. Observe that Step 7 posts a GitHub comment with "Workflow paused - awaiting architectural decisions"
3. The workflow continues into Steps 8–13 without waiting

Root Cause

There is a mismatch between what the orchestrator looks for and what the prompts instruct the LLM to output.

In agentic_change_orchestrator.py:319-323, _check_hard_stop detects stop conditions by checking for these strings in the step output:

if step_num == 4 and "Clarification Needed" in output: # title case if step_num == 7 and "Architectural Decision Needed" in output: # title case

But the step prompts instruct the LLM to output a differently-formatted stop line:

• agentic_change_step7_architecture_LLM.prompt:184: STOP_CONDITION: Architectural decision needed (different casing)
• agentic_change_step4_clarify_LLM.prompt follows the same pattern

The strings don't match. When the LLM writes the stop condition only in the GitHub comment (not in its own tool output), _check_hard_stop never finds the trigger phrase and the workflow proceeds.

Expected Behavior

When Step 4 or Step 7 determines that user input is needed and posts clarification questions, the workflow should stop and exit with a message indicating it's waiting for a response.

Possible Fix

Either:

• Update _check_hard_stop to also check for "STOP_CONDITION:" (the format the prompts actually produce), or
• Align the prompts' STOP_CONDITION: format with the title-case strings the orchestrator expects

[prompt-driven-github]

🚀 Job Queued!

Job ID: XWxiu7pJLkQSMbbSzYom
Triggered by: @jiaminc-cmu
Label: bug

View Live Progress
Model: pdd-opus (claude-opus-4-6)

[prompt-driven-github]

Step 1: Duplicate Check

Status: No duplicates found

Search Performed

• Searched for: _check_hard_stop, stop condition clarification workflow paused, pdd change wait response, hard stop orchestrator step, STOP_CONDITION architectural decision, casing mismatch prompt, workflow continues without waiting, clarification needed string match
• Issues reviewed: ~40 results across 8 searches (open and closed)

Findings

No existing issues address the same root cause — the casing mismatch between _check_hard_stop string comparisons ("Clarification Needed" / "Architectural Decision Needed" in title case) and the prompt-instructed output format (STOP_CONDITION: Architectural decision needed). This is a new, distinct bug.

Closest issues reviewed:

• pdd-change finished step 1-5 but failed at step 6 #530 (pdd-change failed at step 6) — different failure point, unrelated root cause
• Agentic bug workflow timeouts on complex steps (4, 5, 7) #256 (Agentic bug workflow timeouts on steps 4, 5, 7) — about timeouts, not stop-condition detection
• Agentic Change Orchestrator fails when step outputs contain JSON braces #325, pdd change fails at step 5 when previous step output contains JSON with curly braces #352, pdd change: KeyError '\n "type"' in Step 5 prompt template due to unescaped JSON in included prompting_guide.md #373, Bug: pdd change fails at step 5 due to template injection in step outputs #376, pdd change fails at Step 5 with 'Context missing key for step 5: url' #392 (Step 5 failures) — all related to template injection / JSON parsing, not stop-condition string matching

This appears to be a new issue and should proceed with investigation.

---

Proceeding to Step 2: Documentation Check

[prompt-driven-github]

Step 2: Documentation Check

Status: Confirmed Bug

Documentation Reviewed

• README.md (lines 2004-2006) — pdd change workflow documentation
• pdd/agentic_change_orchestrator.py (lines 313-324) — _check_hard_stop function
• pdd/prompts/agentic_change_step7_architecture_LLM.prompt (lines 180-191) — Step 7 stop condition instructions
• pdd/prompts/agentic_change_step4_clarify_LLM.prompt (lines 108-165) — Step 4 clarification template
• tests/test_agentic_change_orchestrator.py (lines 447-479) — Tests for hard stop behavior

Findings

The documentation explicitly states this behavior should work:

README.md (line 2004): "Steps 4 and 7 may pause the workflow to ask clarifying or architectural questions. When this happens, answer the questions in the GitHub issue and run pdd change again."

However, there is a confirmed mismatch between the orchestrator code and the prompt instructions:

Component	String Used
_check_hard_stop (line 319)	"Clarification Needed" (title case)
_check_hard_stop (line 323)	"Architectural Decision Needed" (title case)
Step 7 prompt (line 184)	STOP_CONDITION: Architectural decision needed (lowercase "decision needed")
Step 4 prompt	No STOP_CONDITION marker at all — only includes "Clarification Needed" in the GitHub comment template, not as a required LLM output format

Additional finding: The existing test (test_step7_prompt_has_stop_condition_marker, line 471) verifies the prompt contains the STOP_CONDITION text, but the mock in test_check_hard_stop_step7 (line 450) hardcodes "Architectural Decision Needed" in the simulated LLM output — so the test passes but doesn't catch the real-world casing mismatch.

Two distinct issues:

1. Step 7: Casing mismatch — orchestrator expects "Architectural Decision Needed" but prompt tells LLM to output "Architectural decision needed"
2. Step 4: Missing stop condition format entirely — prompt has no STOP_CONDITION: instruction, so the LLM may only include "Clarification Needed" in the GitHub comment body (not in its direct output to the orchestrator)

---

Proceeding to Step 3: Triage

[prompt-driven-github]

Step 3: Triage

Status: Proceed

Summary

We have sufficient information to reproduce this bug:

1. Expected behavior: When Steps 4 or 7 determine user input is needed, the workflow should stop and wait.

2. Actual behavior: The workflow continues past these steps without stopping.

3. Root cause verified in code:

   • _check_hard_stop at agentic_change_orchestrator.py:319 checks for "Clarification Needed" (title case)
   • _check_hard_stop at agentic_change_orchestrator.py:323 checks for "Architectural Decision Needed" (title case)
   • The Step 7 prompt at agentic_change_step7_architecture_LLM.prompt:184 instructs the LLM to output STOP_CONDITION: Architectural decision needed (different casing, prefixed format)
   • Step 4 prompt lacks a STOP_CONDITION marker entirely — "Clarification Needed" only appears in the GitHub comment template, not as a required LLM output

4. Reproduction path is clear: We can write a unit test that calls _check_hard_stop(7, "STOP_CONDITION: Architectural decision needed") and observe it returns None instead of triggering the stop. Similarly for step 4.

5. Fix approach: Align the string matching in _check_hard_stop with what the prompts actually instruct the LLM to produce, and ensure the Step 4 prompt includes a proper STOP_CONDITION marker.

---

Proceeding to Step 4: Reproduction

[prompt-driven-github]

Step 4: Reproduction

Status: Reproduced

Environment

• Python 3.12.3, Linux 6.9.12
• pytest 8.3.5
• Commit: 1565d9d (HEAD of main)

Steps Taken

1. Read _check_hard_stop in pdd/agentic_change_orchestrator.py:313-330 — confirmed it checks for exact title-case strings: "Clarification Needed" (step 4) and "Architectural Decision Needed" (step 7)
2. Read pdd/prompts/agentic_change_step7_architecture_LLM.prompt:184 — confirmed the prompt instructs the LLM to output STOP_CONDITION: Architectural decision needed (lowercase "decision needed")
3. Read pdd/prompts/agentic_change_step4_clarify_LLM.prompt — confirmed there is no STOP_CONDITION: marker at all; "Clarification Needed" only appears inside the GitHub comment markdown template
4. Wrote and ran 5 targeted unit tests against _check_hard_stop directly

Observed Behavior

tests/test_issue_643_hard_stop_casing.py::test_step7_title_case_matches PASSED        # Control: exact title-case works
tests/test_issue_643_hard_stop_casing.py::test_step7_prompt_format_does_not_match FAILED  # BUG: "STOP_CONDITION: Architectural decision needed" → returns None
tests/test_issue_643_hard_stop_casing.py::test_step7_lowercase_decision_does_not_match FAILED  # BUG: "Architectural decision needed" → returns None
tests/test_issue_643_hard_stop_casing.py::test_step4_title_case_matches PASSED        # Control: exact title-case works
tests/test_issue_643_hard_stop_casing.py::test_step4_prompt_format_github_comment_only FAILED  # BUG: "STOP_CONDITION: Clarification needed" → returns None

3 failed, 2 passed

The two control tests pass (title-case strings match), while all three prompt-realistic formats fail — confirming the casing mismatch causes _check_hard_stop to return None, allowing the workflow to proceed past steps 4 and 7.

Affected Files

• pdd/agentic_change_orchestrator.py:319 — checks "Clarification Needed" (title case) but prompt output uses lowercase "needed"
• pdd/agentic_change_orchestrator.py:323 — checks "Architectural Decision Needed" (title case) but prompt instructs "Architectural decision needed"
• pdd/prompts/agentic_change_step7_architecture_LLM.prompt:184 — instructs LLM to output STOP_CONDITION: Architectural decision needed
• pdd/prompts/agentic_change_step4_clarify_LLM.prompt — has no STOP_CONDITION: marker; relies on GitHub comment template containing the phrase

Notes

• The existing tests in test_agentic_change_orchestrator.py mask this bug by hardcoding the exact title-case strings in mock outputs (e.g., "Duplicate of #999"), never testing the actual format the prompts produce.
• Two distinct issues confirmed: (1) casing mismatch between orchestrator and prompt for step 7, and (2) missing STOP_CONDITION marker entirely for step 4.
• Reproduction test added at tests/test_issue_643_hard_stop_casing.py.

---

Proceeding to Step 5: Root Cause Analysis

[prompt-driven-github]

Step 5: Root Cause Analysis

Root Cause Identified: Yes

Summary

The _check_hard_stop() function in agentic_change_orchestrator.py uses case-sensitive in checks against the LLM step output, but two of the eight stop-condition prompts produce strings that don't match what the orchestrator expects. Specifically, the Step 7 prompt instructs the LLM to output "STOP_CONDITION: Architectural decision needed" (lowercase "decision needed") while the orchestrator checks for "Architectural Decision Needed" (title case). The Step 4 prompt has no explicit STOP_CONDITION marker at all — the phrase "Clarification Needed" only appears inside a GitHub comment markdown template, so whether the LLM echoes it in its tool output is unreliable. This means the orchestrator's string check silently fails and the workflow continues past steps that should be hard stops.

Technical Details

• Location: pdd/agentic_change_orchestrator.py:313-330
• Problematic Code:

def _check_hard_stop(step_num: int, output: str) -> Optional[str]:
    # ...
    if step_num == 4 and "Clarification Needed" in output:   # <-- title case "N"
        return "Clarification needed"
    if step_num == 7 and "Architectural Decision Needed" in output:  # <-- title case "D" and "N"
        return "Architectural decision needed"

• Why it fails: Python's in operator is case-sensitive. The Step 7 prompt (agentic_change_step7_architecture_LLM.prompt:184) tells the LLM to output "STOP_CONDITION: Architectural decision needed" — with lowercase "d" and "n". The substring "Architectural Decision Needed" (title case) is never found in that output. For Step 4, the prompt has no STOP_CONDITION line at all, so the LLM may not include "Clarification Needed" in its direct output.

External Research

• Search terms: "case sensitive string matching LLM output stop condition", "prompt output format mismatch orchestrator"
• Sources checked: GitHub issues on this repo, StackOverflow, Python docs
• Relevant findings: This is a straightforward string comparison bug, not related to any dependency or framework issue. It's a known anti-pattern when using case-sensitive matching on LLM outputs — LLMs don't reliably respect exact casing instructions. However, in this codebase, the fix is simpler: align the two mismatched prompts with the pattern already used by all other steps.

Repository History

• Relevant commits: 1565d9d ("Bump version") — this is the initial commit for all files in this repo snapshot. Both the orchestrator and prompt files were introduced together.
• Related PRs: No PRs found specifically touching _check_hard_stop. The function was part of the initial implementation.
• Similar past issues: No duplicate or similar issues found (confirmed in Step 1).

Experiments Performed

1. Reproduction tests (tests/test_issue_643_hard_stop_casing.py): 3 of 5 tests fail, confirming both mismatches:
   • test_step7_prompt_format_does_not_match — "STOP_CONDITION: Architectural decision needed" → _check_hard_stop returns None (FAIL)
   • test_step7_lowercase_decision_does_not_match — "Architectural decision needed" → returns None (FAIL)
   • test_step4_prompt_format_github_comment_only — "STOP_CONDITION: Clarification needed" → returns None (FAIL)
2. Cross-prompt comparison: Verified that steps 1, 2, 6, 8 all use matching casing between prompt templates and _check_hard_stop checks. Steps 4 and 7 are the only ones that deviate.

Fix Scope

• Type: Localized
• The fix is contained to a single function (_check_hard_stop) with a secondary change needed in one prompt file. Only 2 lines in the orchestrator and 1 prompt file need modification — well below the cross-cutting threshold.

Fix Location

• File(s) to modify:
  1. pdd/agentic_change_orchestrator.py:319,323 — make the string checks case-insensitive (use .lower() on both sides or check for the STOP_CONDITION: prefix format)
  2. pdd/prompts/agentic_change_step4_clarify_LLM.prompt — add an explicit STOP_CONDITION: Clarification Needed output instruction section (matching the pattern in step7_architecture_LLM.prompt:180-191)
• Why this location: The orchestrator's _check_hard_stop is where the string comparison happens, and it's the gatekeeper for workflow continuation. The Step 4 prompt is missing the required output instruction entirely.
• Existing pattern: Steps 1, 2, 6, and 8 all use exact title-case phrases in both the prompt template output format AND the _check_hard_stop checks, and they work correctly. Step 7's prompt deviates with different casing, and Step 4 lacks the instruction altogether.
• Fix approach: Two-part fix aligned with the existing working pattern:
  1. In _check_hard_stop (lines 319, 323): Make the comparisons case-insensitive by converting output.lower() and comparing against lowercase strings. This makes the function robust against minor casing variations from LLM output while maintaining backward compatibility with existing working steps.
  2. In agentic_change_step4_clarify_LLM.prompt: Add a % CRITICAL: Output Format for Stop Condition section (identical structure to step7_architecture_LLM.prompt:180-191) instructing the LLM to include STOP_CONDITION: Clarification Needed in its final output when clarification is needed.

---

Proceeding to Step 5.5: Prompt Classification

[prompt-driven-github]

Step 5.5: Prompt Classification

Classification: Mixed — Code Bug + Prompt Defect

DEFECT_TYPE: code
PROMPT_FIXED: pdd/prompts/agentic_change_step4_clarify_LLM.prompt

Analysis

This issue contains two distinct defects affecting the same feature (hard-stop detection):

1. Step 7 — Code Bug: The code in _check_hard_stop() checks for "Architectural Decision Needed" (title case), but the step 7 prompt instructs the LLM to output STOP_CONDITION: Architectural decision needed (lowercase). The code doesn't match the prompt specification.

2. Step 4 — Prompt Defect: The step 4 prompt has no STOP_CONDITION: output instruction at all. The phrase "Clarification Needed" only appears inside a GitHub comment markdown template — the prompt never tells the LLM to echo a parseable stop marker in its own output. Step 7's prompt has this critical section; step 4's prompt was missing it entirely.

Evidence

Step 7 (Code Bug):

• Prompt specifies: STOP_CONDITION: Architectural decision needed (lowercase "decision needed") — at line 184 of agentic_change_step7_architecture_LLM.prompt
• Code implements: "Architectural Decision Needed" (title case) — at line 323 of agentic_change_orchestrator.py
• User expects: Workflow stops when architectural decisions are needed — matches prompt intent

Step 4 (Prompt Defect):

• Prompt specifies: No STOP_CONDITION: output format at all
• Code implements: Checks for "Clarification Needed" in output — at line 319 of agentic_change_orchestrator.py
• User expects: Workflow stops when clarification is needed — the prompt was incomplete

Prompt Change Made

File: pdd/prompts/agentic_change_step4_clarify_LLM.prompt

Before: (ends at line 164)

- This is a HARD STOP - if clarification is needed, the workflow terminates here
- When `pdd change` is run again, this step will re-evaluate based on new comments

After:

- This is a HARD STOP - if clarification is needed, the workflow terminates here
- When `pdd change` is run again, this step will re-evaluate based on new comments

% CRITICAL: Output Format for Stop Condition

If clarification is needed, your final response MUST include this exact line:

STOP_CONDITION: Clarification needed

This line MUST:
- Appear in your final output (not just in the GitHub comment)
- Use exact casing shown above (lowercase "needed")
- Be on its own line for reliable parsing

If NO clarification is needed (proceeding to Step 5), do NOT include this line.

Remaining Code Fix Needed

The _check_hard_stop() function at pdd/agentic_change_orchestrator.py:319,323 must be updated to:

1. Check for the STOP_CONDITION: prefix format (which both prompts now use)
2. Use case-insensitive matching to be robust against LLM casing variations

Conclusion

The step 4 prompt defect has been fixed (added STOP_CONDITION: output instruction matching step 7's pattern). The step 7 casing mismatch is a code bug — the code must be updated to match the prompt specifications. Proceeding with test generation using DEFECT_TYPE: code since code changes are still required.

---

Proceeding to Step 6: Test Plan

[prompt-driven-github]

Step 6: Test Plan

Existing Test Coverage

• Test file: tests/test_agentic_change_orchestrator.py
• Current coverage: Tests exist for hard stops at step 1 (duplicate), step 9 (FAIL), and step 7 — but the step 7 test (test_step7_stop_with_stop_condition_marker, line 440) hardcodes "Architectural Decision Needed" (title case) in the mock output, which matches _check_hard_stop but does NOT match what the prompt actually instructs the LLM to output (STOP_CONDITION: Architectural decision needed). There is also a prompt-content test (test_step7_prompt_has_stop_condition_marker, line 471) that verifies the prompt contains the STOP_CONDITION text, but no test bridges the gap between the prompt format and the orchestrator's detection logic.
• Gap 1: No test for step 4 (Clarification Needed) hard stop at all — neither the mock-output path nor the prompt-format path
• Gap 2: No test that uses the actual LLM output format (STOP_CONDITION: Architectural decision needed / STOP_CONDITION: Clarification needed) as input to _check_hard_stop — the existing test masks the bug by using the title-case string directly
• Gap 3: No test for case-insensitive matching — if the LLM varies casing slightly, the stop is missed

Proposed Tests

All tests target _check_hard_stop directly (unit tests) and the full orchestrator flow (integration tests).

Test 1: test_check_hard_stop_step4_with_stop_condition_format (Primary bug — Step 4)

• Input: step_num=4, output="... STOP_CONDITION: Clarification needed ..."
• Expected: Returns "Clarification needed" (hard stop triggered)
• Actual (before fix): Returns None — the orchestrator checks for "Clarification Needed" (title case) but the prompt outputs lowercase "needed"

Test 2: test_check_hard_stop_step7_with_stop_condition_format (Primary bug — Step 7)

• Input: step_num=7, output="... STOP_CONDITION: Architectural decision needed ..."
• Expected: Returns "Architectural decision needed" (hard stop triggered)
• Actual (before fix): Returns None — the orchestrator checks for "Architectural Decision Needed" (title case) but the prompt outputs lowercase "decision needed"

Test 3: test_check_hard_stop_step4_case_insensitive (Edge case — casing robustness)

• Input: step_num=4, output with various casings: "clarification needed", "CLARIFICATION NEEDED", "Clarification needed"
• Expected: All trigger the hard stop

Test 4: test_check_hard_stop_step7_case_insensitive (Edge case — casing robustness)

• Input: step_num=7, output with various casings: "architectural decision needed", "ARCHITECTURAL DECISION NEEDED"
• Expected: All trigger the hard stop

Test 5: test_orchestrator_stops_step4_clarification (Integration — full orchestrator flow)

• Input: Mock step 4 to return "STOP_CONDITION: Clarification needed" (the actual prompt-instructed format)
• Expected: run_agentic_change_orchestrator returns (False, "Stopped at step 4: Clarification needed", ...), steps 5+ are not executed
• Actual (before fix): Workflow continues past step 4

Test 6: test_orchestrator_stops_step7_architecture (Integration — full orchestrator flow)

• Input: Mock step 7 to return "STOP_CONDITION: Architectural decision needed" (the actual prompt-instructed format)
• Expected: run_agentic_change_orchestrator returns (False, "Stopped at step 7: Architectural decision needed", ...), steps 8+ are not executed
• Actual (before fix): Workflow continues past step 7

Test 7: test_check_hard_stop_no_false_positives (Regression — existing stops unaffected)

• Input: Verify all existing hard stop conditions still work: step 1 "Duplicate of #", step 2 "Already Implemented", step 6 "No Dev Units Found", step 8 "No Changes Required", step 9 "FAIL:"
• Expected: All return correct stop reasons (no regression)

Test 8: test_step4_prompt_has_stop_condition_marker (Prompt validation)

• Input: Read agentic_change_step4_clarify_LLM.prompt
• Expected: Contains STOP_CONDITION: Clarification needed (the prompt fix from step 5.5)

Channel Analysis

• Return value channel: _check_hard_stop returns None vs a stop string → tested by Tests 1-4, 7
• Orchestrator output channel: run_agentic_change_orchestrator returns (False, "Stopped at step N: reason", ...) → tested by Tests 5-6
• Console output channel (Rich): The orchestrator prints [yellow]Investigation stopped at Step N: ...[/yellow] via Rich console — this is a secondary output of the same code path, covered implicitly by the integration tests since the stop reason flows from the same _check_hard_stop return
• State persistence channel: When hard stop triggers, state is saved with last_completed_step — could verify state file reflects the correct stop step (covered by existing tests for other hard stops)

Test Location

• File: tests/test_agentic_change_orchestrator.py (append new tests to existing file)
• Framework: pytest (consistent with project conventions)
• Fixtures: Reuse existing mock_dependencies and temp_cwd fixtures

Notes

• The unit tests on _check_hard_stop are the most important — they directly test the string matching logic that is the root cause
• Integration tests confirm the end-to-end flow but depend on the same code path
• The prompt validation test (Test 8) ensures the step 4 prompt fix from step 5.5 stays in place
• All tests should be independent and not rely on test execution order

---

Proceeding to Step 7: Generate Test

[prompt-driven-github]

Step 7: Generated Test

Test File

tests/test_issue_643_hard_stop_casing.py

Test Code

"""
Tests for Issue #643: _check_hard_stop doesn't detect stop conditions due to
casing mismatch between orchestrator checks and prompt-instructed LLM output.

Bug: The orchestrator checks for "Clarification Needed" (title case) and
"Architectural Decision Needed" (title case), but the prompts instruct the LLM
to output "STOP_CONDITION: Clarification needed" and "STOP_CONDITION:
Architectural decision needed" (lowercase). The strings don't match, so the
workflow never stops.

These tests verify:
1. _check_hard_stop detects the STOP_CONDITION format the prompts actually produce
2. _check_hard_stop handles case-insensitive matching
3. Prompts contain the correct STOP_CONDITION markers
4. Integration: orchestrator halts when step output contains prompt-format stops
"""

import pytest
from pathlib import Path
from unittest.mock import patch, MagicMock

from pdd.agentic_change_orchestrator import _check_hard_stop


class TestCheckHardStopStep4ClarificationBug:
    """Tests for Step 4 clarification stop condition (issue #643)."""

    def test_step4_detects_stop_condition_format(self):
        """_check_hard_stop must detect 'STOP_CONDITION: Clarification needed'"""
        output = "STOP_CONDITION: Clarification needed"
        result = _check_hard_stop(step_num=4, output=output)
        assert result is not None  # FAILS: only checks for title-case "Clarification Needed"

    def test_step4_detects_lowercase_clarification_needed(self):
        """_check_hard_stop must detect 'Clarification needed' (lowercase 'n')"""
        output = "Clarification needed"
        result = _check_hard_stop(step_num=4, output=output)
        assert result is not None  # FAILS: only checks for "Clarification Needed"

    def test_step4_still_detects_title_case(self):
        """Regression: the original title-case format must still work."""
        output = "Clarification Needed"
        result = _check_hard_stop(step_num=4, output=output)
        assert result is not None  # PASSES (existing behavior)


class TestCheckHardStopStep7ArchitectureBug:
    """Tests for Step 7 architectural stop condition (issue #643)."""

    def test_step7_detects_stop_condition_format(self):
        """_check_hard_stop must detect 'STOP_CONDITION: Architectural decision needed'"""
        output = "STOP_CONDITION: Architectural decision needed"
        result = _check_hard_stop(step_num=7, output=output)
        assert result is not None  # FAILS: only checks for "Architectural Decision Needed"

    def test_step7_detects_lowercase_decision_needed(self):
        """_check_hard_stop must detect 'Architectural decision needed' (lowercase)"""
        output = "Architectural decision needed"
        result = _check_hard_stop(step_num=7, output=output)
        assert result is not None  # FAILS: only checks for "Architectural Decision Needed"

    def test_step7_still_detects_title_case(self):
        """Regression: the original title-case format must still work."""
        output = "Architectural Decision Needed"
        result = _check_hard_stop(step_num=7, output=output)
        assert result is not None  # PASSES (existing behavior)


class TestPromptStopConditionMarkers:
    """Verify that the prompts contain the STOP_CONDITION markers."""

    def test_step4_prompt_has_stop_condition(self):
        """Step 4 prompt must contain STOP_CONDITION: Clarification needed."""
        # PASSES — prompt was already updated in step 5.5

    def test_step7_prompt_has_stop_condition(self):
        """Step 7 prompt must contain STOP_CONDITION: Architectural decision needed."""
        # PASSES — prompt already had this marker


class TestOrchestratorHaltsOnPromptFormatStop:
    """Integration: orchestrator halts when steps output STOP_CONDITION format."""

    def test_step4_halts_on_stop_condition_format(self):
        """Orchestrator must halt at Step 4 on 'STOP_CONDITION: Clarification needed'"""
        # FAILS: orchestrator runs all 21 steps (call_count=21, expected <=4)

    def test_step7_halts_on_stop_condition_format(self):
        """Orchestrator must halt at Step 7 on 'STOP_CONDITION: Architectural decision needed'"""
        # FAILS: orchestrator runs all 21 steps (call_count=21, expected <=7)

What This Test Verifies

10 tests total — 6 FAIL on buggy code, 4 PASS:

Test	Result	Why
test_step4_detects_stop_condition_format	FAIL	_check_hard_stop doesn't detect STOP_CONDITION: Clarification needed
test_step4_detects_lowercase_clarification_needed	FAIL	Only checks for title-case "Clarification Needed"
test_step4_still_detects_title_case	PASS	Regression — existing title-case check works
test_step7_detects_stop_condition_format	FAIL	_check_hard_stop doesn't detect STOP_CONDITION: Architectural decision needed
test_step7_detects_lowercase_decision_needed	FAIL	Only checks for "Architectural Decision Needed"
test_step7_still_detects_title_case	PASS	Regression — existing title-case check works
test_step4_prompt_has_stop_condition	PASS	Prompt was updated in step 5.5
test_step7_prompt_has_stop_condition	PASS	Prompt already had the marker
test_step4_halts_on_stop_condition_format	FAIL	Orchestrator ran 21 steps instead of stopping at step 4
test_step7_halts_on_stop_condition_format	FAIL	Orchestrator ran 21 steps instead of stopping at step 7

Running the Test

python -m pytest tests/test_issue_643_hard_stop_casing.py -v

---

Proceeding to Step 8: Verification

[prompt-driven-github]

Step 8: Verification Complete

Test Execution

tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep4ClarificationBug::test_step4_detects_stop_condition_format FAILED
tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep4ClarificationBug::test_step4_detects_lowercase_clarification_needed FAILED
tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep4ClarificationBug::test_step4_still_detects_title_case PASSED
tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep7ArchitectureBug::test_step7_detects_stop_condition_format FAILED
tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep7ArchitectureBug::test_step7_detects_lowercase_decision_needed FAILED
tests/test_issue_643_hard_stop_casing.py::TestCheckHardStopStep7ArchitectureBug::test_step7_still_detects_title_case PASSED
tests/test_issue_643_hard_stop_casing.py::TestPromptStopConditionMarkers::test_step4_prompt_has_stop_condition PASSED
tests/test_issue_643_hard_stop_casing.py::TestPromptStopConditionMarkers::test_step7_prompt_has_stop_condition PASSED
tests/test_issue_643_hard_stop_casing.py::TestOrchestratorHaltsOnPromptFormatStop::test_step4_halts_on_stop_condition_format FAILED
tests/test_issue_643_hard_stop_casing.py::TestOrchestratorHaltsOnPromptFormatStop::test_step7_halts_on_stop_condition_format FAILED

========================= 6 failed, 4 passed in 3.72s =========================

Verification Status

PASS: Test correctly detects the bug

All 6 bug-detecting tests fail for the correct reason:

• 4 unit tests fail because _check_hard_stop returns None when given the prompt-instructed output format (lowercase casing / STOP_CONDITION: prefix)
• 2 integration tests fail because the orchestrator runs all 21 steps instead of halting at step 4 or step 7 — confirming the workflow continues without stopping
• 4 passing tests confirm: regression cases (title-case still works) and prompt validation (both prompts now contain STOP_CONDITION markers)

Summary

Step	Result
Duplicate Check	✅ No duplicates found
Documentation	✅ Bug confirmed against docs
Triage	✅ Proceed — clear root cause identified
Reproduction	✅ Bug reproduced with 3/5 failures
Root Cause	✅ Case-sensitive mismatch in _check_hard_stop
Prompt Classification	✅ Mixed defect: code bug + prompt defect (prompt fixed)
Test Plan	✅ 8 tests planned (unit + integration + validation)
Test Generation	✅ 10 tests created, 6 fail on current code
Verification	✅ All 6 failures are for the correct reason

Bug Details

• Location: pdd/agentic_change_orchestrator.py:319-323
• Root Cause: _check_hard_stop uses case-sensitive string matching ("Clarification Needed", "Architectural Decision Needed") but the prompts instruct the LLM to output lowercase variants ("STOP_CONDITION: Clarification needed", "STOP_CONDITION: Architectural decision needed"). The strings never match, so the workflow never stops.
• Test File: tests/test_issue_643_hard_stop_casing.py

Next Steps

1. Fix _check_hard_stop to use case-insensitive matching and detect the STOP_CONDITION: prefix format
2. Run the test to confirm all 10 tests pass
3. Run full test suite to check for regressions
4. Submit PR with fix and test

---

Proceeding to Step 9: E2E Tests

[prompt-driven-github]

Step 9: E2E Test

Environment Discovery

• Repository language: Python
• Test framework: pytest 8.3.5
• Existing E2E tests found: Yes — 50+ files matching test_e2e_issue_* pattern in tests/
• Test configuration: pyproject.toml [tool.pytest.ini_options] with @pytest.mark.e2e marker
• Fixtures/helpers used: mock_cwd fixture (tmp_path with .git/.pdd dirs), matching existing patterns
• Environment variables required: None (LLM layer is mocked)
• Auth/credentials: Not needed — only LLM execution is mocked

E2E Test File

tests/test_e2e_issue_643_hard_stop_casing.py

Test Type

Integration — exercises the full run_agentic_change_orchestrator loop with real prompt loading, real _check_hard_stop, and real step sequencing. Only the LLM execution layer and state persistence are mocked.

What This Test Verifies

When pdd change runs steps 4 or 7 and the LLM outputs the stop condition in the format the prompts instruct (STOP_CONDITION: Clarification needed / STOP_CONDITION: Architectural decision needed), the orchestrator must halt and not continue to subsequent steps.

Tests (6 total)

Test	Expected	Status
test_step4_halts_on_prompt_instructed_stop_condition	Halt at step 4 on STOP_CONDITION: Clarification needed	FAIL (bug)
test_step4_halts_on_lowercase_clarification_needed	Halt at step 4 on Clarification needed	FAIL (bug)
test_step7_halts_on_prompt_instructed_stop_condition	Halt at step 7 on STOP_CONDITION: Architectural decision needed	FAIL (bug)
test_step7_halts_on_lowercase_architectural_decision_needed	Halt at step 7 on Architectural decision needed	FAIL (bug)
test_step4_still_halts_on_title_case	Halt on Clarification Needed (regression)	PASS
test_step7_still_halts_on_title_case	Halt on Architectural Decision Needed (regression)	PASS

Test Execution Result

tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643Step4HardStopE2E::test_step4_halts_on_prompt_instructed_stop_condition FAILED
tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643Step4HardStopE2E::test_step4_halts_on_lowercase_clarification_needed FAILED
tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643Step7HardStopE2E::test_step7_halts_on_prompt_instructed_stop_condition FAILED
tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643Step7HardStopE2E::test_step7_halts_on_lowercase_architectural_decision_needed FAILED
tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643RegressionE2E::test_step4_still_halts_on_title_case PASSED
tests/test_e2e_issue_643_hard_stop_casing.py::TestIssue643RegressionE2E::test_step7_still_halts_on_title_case PASSED

4 failed, 2 passed in 4.53s

Failure details: All 4 bug tests show the orchestrator executing steps [1, 2, 3, 4, 5, 6, 7, 8] — continuing past the stop point because _check_hard_stop doesn't recognize the lowercase/STOP_CONDITION format.

E2E Test Status

PASS: E2E test correctly detects the bug — 4 tests fail due to the casing mismatch in _check_hard_stop, 2 regression tests confirm existing title-case detection still works.

---

Proceeding to Step 10: Create Draft PR