claude-task-master 0.1.7__tar.gz → 0.1.8__tar.gz

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-task-master
-Version: 0.1.7
+Version: 0.1.8
 Summary: Autonomous task orchestration system that keeps Claude working until a goal is achieved
 Author: Claude Task Master Team
 License-Expression: MIT

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-task-master"
-version = "0.1.7"
+version = "0.1.8"
 description = "Autonomous task orchestration system that keeps Claude working until a goal is achieved"
 readme = "README.md"
 requires-python = ">=3.12"

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/__init__.py

@@ -3,5 +3,5 @@
 Uses Claude Agent SDK to keep Claude working until a goal is achieved.
 """
 
-__version__ = "0.1.7"
+__version__ = "0.1.8"
 __all__ = ["__version__"]

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/agent.py

@@ -170,15 +170,35 @@ class AgentWrapper:
                 ValueError("query must be callable"),
             )
 
-    def run_planning_phase(self, goal: str, context: str = "") -> dict[str, Any]:
+    def run_planning_phase(
+        self, goal: str, context: str = "", coding_style: str | None = None
+    ) -> dict[str, Any]:
         """Run planning phase with read-only tools.
 
         Always uses Opus (smartest model) for planning to ensure
         high-quality task breakdown and complexity classification.
 
+        Args:
+            goal: The goal to plan for.
+            context: Additional context for planning.
+            coding_style: Optional coding style guide to inject into prompt.
+
+        Delegates to AgentPhaseExecutor for implementation.
+        """
+        return self._phase_executor.run_planning_phase(goal, context, coding_style)
+
+    def generate_coding_style(self) -> dict[str, Any]:
+        """Generate a coding style guide by analyzing the codebase.
+
+        Analyzes CLAUDE.md, convention files, and codebase to create a
+        concise coding style guide with workflow and conventions.
+
+        Returns:
+            Dict with 'coding_style' and 'raw_output' keys.
+
         Delegates to AgentPhaseExecutor for implementation.
         """
-        return self._phase_executor.run_planning_phase(goal, context)
+        return self._phase_executor.generate_coding_style()
 
     def run_work_session(
         self,
@@ -190,6 +210,7 @@ class AgentWrapper:
         create_pr: bool = True,
         pr_group_info: dict | None = None,
         target_branch: str = "main",
+        coding_style: str | None = None,
     ) -> dict[str, Any]:
         """Run a work session with full tools.
 
@@ -203,6 +224,7 @@ class AgentWrapper:
             create_pr: If True, instruct agent to create PR. If False, commit only.
             pr_group_info: Optional dict with PR group context (name, completed_tasks, etc).
             target_branch: The target branch for rebasing (default: "main").
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'output', 'success', and 'model_used' keys.
@@ -218,6 +240,7 @@ class AgentWrapper:
             create_pr=create_pr,
             pr_group_info=pr_group_info,
             target_branch=target_branch,
+            coding_style=coding_style,
         )
 
     def verify_success_criteria(self, criteria: str, context: str = "") -> dict[str, Any]:

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/agent_phases.py

@@ -13,7 +13,13 @@ from typing import TYPE_CHECKING, Any, TypeVar
 
 from . import console
 from .agent_models import ModelType, get_tools_for_phase
-from .prompts import build_planning_prompt, build_verification_prompt, build_work_prompt
+from .prompts import (
+    build_coding_style_prompt,
+    build_planning_prompt,
+    build_verification_prompt,
+    build_work_prompt,
+    extract_coding_style,
+)
 
 if TYPE_CHECKING:
     from .agent_query import AgentQueryExecutor
@@ -104,7 +110,9 @@ class AgentPhaseExecutor:
         self.get_agents_func = get_agents_func
         self.process_message_func = process_message_func
 
-    def run_planning_phase(self, goal: str, context: str = "") -> dict[str, Any]:
+    def run_planning_phase(
+        self, goal: str, context: str = "", coding_style: str | None = None
+    ) -> dict[str, Any]:
         """Run planning phase with read-only tools.
 
         Always uses Opus (smartest model) for planning to ensure
@@ -113,12 +121,17 @@ class AgentPhaseExecutor:
         Args:
             goal: The goal to plan for.
             context: Additional context for planning.
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'plan', 'criteria', and 'raw_output' keys.
         """
         # Build prompt for planning
-        prompt = build_planning_prompt(goal=goal, context=context if context else None)
+        prompt = build_planning_prompt(
+            goal=goal,
+            context=context if context else None,
+            coding_style=coding_style,
+        )
 
         # Always use Opus for planning (smartest model)
         console.info("Planning with Opus (smartest model)...")
@@ -152,6 +165,7 @@ class AgentPhaseExecutor:
         create_pr: bool = True,
         pr_group_info: dict | None = None,
         target_branch: str = "main",
+        coding_style: str | None = None,
     ) -> dict[str, Any]:
         """Run a work session with full tools.
 
@@ -165,6 +179,7 @@ class AgentPhaseExecutor:
             create_pr: If True, instruct agent to create PR. If False, commit only.
             pr_group_info: Optional dict with PR group context (name, completed_tasks, etc).
             target_branch: The target branch for rebasing (default: "main").
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'output', 'success', and 'model_used' keys.
@@ -178,6 +193,7 @@ class AgentPhaseExecutor:
             create_pr=create_pr,
             pr_group_info=pr_group_info,
             target_branch=target_branch,
+            coding_style=coding_style,
         )
 
         # Run async query with optional model override
@@ -328,3 +344,37 @@ class AgentPhaseExecutor:
 
         # Default criteria if none specified
         return "All tasks in the task list are completed successfully."
+
+    def generate_coding_style(self) -> dict[str, Any]:
+        """Generate a coding style guide by analyzing the codebase.
+
+        Analyzes CLAUDE.md, convention files, and sample source files
+        to create a concise coding style guide.
+
+        Returns:
+            Dict with 'coding_style' and 'raw_output' keys.
+        """
+        # Build prompt for coding style generation
+        prompt = build_coding_style_prompt()
+
+        console.info("Generating coding style guide with Opus...")
+
+        # Run with planning tools (read-only) and Opus for quality
+        result = run_async_with_cleanup(
+            self.query_executor.run_query(
+                prompt=prompt,
+                tools=self.get_tools_for_phase("planning"),
+                model_override=ModelType.OPUS,  # Use Opus for quality
+                get_model_name_func=self.get_model_name_func,
+                get_agents_func=self.get_agents_func,
+                process_message_func=self.process_message_func,
+            )
+        )
+
+        # Extract the coding style content
+        coding_style = extract_coding_style(result)
+
+        return {
+            "coding_style": coding_style,
+            "raw_output": result,
+        }

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/orchestrator.py

@@ -1337,11 +1337,15 @@ After fixing everything, run the tests again to confirm they pass.
 After completing your fixes, end with: TASK COMPLETE"""
 
         try:
+            # Load coding style for consistent style in fix session
+            coding_style = self.state_manager.load_coding_style()
+
             self.agent.run_work_session(
                 task_description=task_description,
                 context=context,
                 model_override=ModelType.OPUS,
                 create_pr=True,
+                coding_style=coding_style,
             )
             state.session_count += 1
             self.state_manager.save_state(state)

claude_task_master-0.1.8/src/claude_task_master/core/planner.py

@@ -0,0 +1,84 @@
+"""Planner - Orchestrates initial planning phase (read-only tools)."""
+
+from typing import Any
+
+from . import console
+from .agent import AgentWrapper
+from .state import StateManager
+
+
+class Planner:
+    """Handles the initial planning phase."""
+
+    def __init__(self, agent: AgentWrapper, state_manager: StateManager):
+        """Initialize planner."""
+        self.agent = agent
+        self.state_manager = state_manager
+
+    def ensure_coding_style(self) -> str | None:
+        """Ensure coding style guide exists, generating it if needed.
+
+        Checks if coding-style.md exists. If not, generates it by analyzing
+        CLAUDE.md and convention files in the codebase.
+
+        Returns:
+            The coding style guide content, or None if generation failed.
+        """
+        # Check if coding style already exists
+        coding_style = self.state_manager.load_coding_style()
+        if coding_style:
+            console.info("Using existing coding style guide")
+            return coding_style
+
+        # Generate coding style by analyzing codebase
+        console.info("Generating coding style guide from codebase...")
+        result = self.agent.generate_coding_style()
+
+        coding_style_content: str = result.get("coding_style", "")
+        if coding_style_content:
+            self.state_manager.save_coding_style(coding_style_content)
+            console.success("Coding style guide generated and saved")
+            return coding_style_content
+
+        console.warning("Could not generate coding style guide")
+        return None
+
+    def create_plan(self, goal: str) -> dict[str, Any]:
+        """Create initial task plan using read-only tools.
+
+        First generates coding style guide if it doesn't exist, then
+        runs planning phase with the coding style injected.
+        """
+        # Ensure coding style exists (generate if needed)
+        coding_style = self.ensure_coding_style()
+
+        # Load any existing context
+        context = self.state_manager.load_context()
+
+        # Run planning phase with Claude (with coding style)
+        result = self.agent.run_planning_phase(
+            goal=goal, context=context, coding_style=coding_style
+        )
+
+        # Extract plan and criteria from result
+        plan = result.get("plan", "")
+        criteria = result.get("criteria", "")
+
+        # Save to state
+        if plan:
+            self.state_manager.save_plan(plan)
+        if criteria:
+            self.state_manager.save_criteria(criteria)
+
+        return result
+
+    def update_plan_progress(self, task_index: int, completed: bool) -> None:
+        """Update task completion status in plan."""
+        plan = self.state_manager.load_plan()
+        if not plan:
+            return
+
+        # TODO: Parse markdown checkboxes and update status
+        # This will require parsing the plan.md file and toggling checkboxes
+
+        self.state_manager.save_plan(plan)

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/prompts.py

@@ -1,6 +1,7 @@
 """Prompt Templates - Centralized, maintainable prompt generation.
 
 This module provides structured prompt templates for different agent phases:
+- Coding Style: Generate concise coding style guide from codebase analysis
 - Planning: Initial codebase analysis and task creation
 - Plan Update: Modifying existing plans based on change requests
 - Working: Task execution with verification
@@ -12,6 +13,7 @@ All prompts are designed to be concise, structured, and token-efficient.
 This module re-exports all prompt functions for backward compatibility.
 The actual implementations are in:
 - prompts_base.py: PromptSection, PromptBuilder
+- prompts_coding_style.py: build_coding_style_prompt, extract_coding_style
 - prompts_planning.py: build_planning_prompt
 - prompts_plan_update.py: build_plan_update_prompt
 - prompts_working.py: build_work_prompt
@@ -24,6 +26,9 @@ from __future__ import annotations
 # Re-export base classes
 from .prompts_base import PromptBuilder, PromptSection
 
+# Re-export coding style prompts
+from .prompts_coding_style import build_coding_style_prompt, extract_coding_style
+
 # Re-export planning prompts
 from .prompts_plan_update import build_plan_update_prompt
 from .prompts_planning import build_planning_prompt
@@ -43,6 +48,9 @@ __all__ = [
     # Base classes
     "PromptSection",
     "PromptBuilder",
+    # Coding Style
+    "build_coding_style_prompt",
+    "extract_coding_style",
     # Planning
     "build_planning_prompt",
     "build_plan_update_prompt",

claude_task_master-0.1.8/src/claude_task_master/core/prompts_coding_style.py

@@ -0,0 +1,160 @@
+"""Coding Style Generation Prompt for Claude Task Master.
+
+This module contains the prompt for generating a concise coding style guide
+by analyzing CLAUDE.md and convention files. The generated guide captures:
+- Coding workflow (TDD, development process)
+- Code style conventions (naming, formatting)
+- Project-specific requirements
+
+The guide is saved to coding-style.md and injected into planning and work
+prompts to save tokens while ensuring consistent code quality.
+"""
+
+from __future__ import annotations
+
+from .prompts_base import PromptBuilder
+
+
+def build_coding_style_prompt() -> str:
+    """Build the prompt for generating a coding style guide.
+
+    This prompt instructs Claude to analyze CLAUDE.md and convention files
+    to create a concise coding style guide that captures the project's
+    workflow (TDD, development process) and code conventions.
+
+    Returns:
+        Complete coding style generation prompt.
+    """
+    builder = PromptBuilder(
+        intro="""You are analyzing a codebase to extract its coding workflow and style guide.
+
+Your mission: **Create a CONCISE coding guide (under 600 words).**
+
+Focus on extracting:
+1. **Development workflow** (TDD, test-first, iteration patterns)
+2. **Code conventions** (naming, formatting, imports)
+3. **Project-specific requirements** (from CLAUDE.md)
+
+This guide will be injected into every coding task, so keep it SHORT and ACTIONABLE.
+
+## TOOL RESTRICTIONS (MANDATORY)
+
+**ALLOWED TOOLS (use ONLY these):**
+- `Read` - Read files to understand patterns
+- `Glob` - Find files by pattern
+- `Grep` - Search for code patterns
+- `Bash` - Run commands (check configs, linters, etc.)
+
+**FORBIDDEN TOOLS (NEVER use):**
+- `Write` - Do NOT write any files
+- `Edit` - Do NOT edit any files
+- `Task` - Do NOT launch any agents"""
+    )
+
+    builder.add_section(
+        "Step 1: Read CLAUDE.md (PRIORITY)",
+        """**Start by reading `CLAUDE.md` at the repository root.**
+
+This file contains the project's coding requirements and workflow instructions.
+Extract:
+- Development workflow (TDD, test-driven, iteration patterns)
+- Code quality requirements
+- Testing approach (test first? mock patterns?)
+- Any specific coding rules or constraints
+
+Also check these if CLAUDE.md doesn't exist:
+- `.claude/instructions.md`
+- `CONTRIBUTING.md`
+- `.cursorrules`, `.github/copilot-instructions.md`""",
+    )
+
+    builder.add_section(
+        "Step 2: Check Configs",
+        """Quickly scan linter/formatter configs for conventions:
+
+- Python: `pyproject.toml` [tool.ruff], `ruff.toml`
+- JS/TS: `.eslintrc`, `.prettierrc`, `biome.json`
+- General: `.editorconfig`
+
+Note line length, quote style, import ordering rules.""",
+    )
+
+    builder.add_section(
+        "Step 3: Generate Coding Guide",
+        """Create a CONCISE guide with these sections (skip if not applicable):
+
+```markdown
+# Coding Style
+
+## Workflow
+- [TDD approach? Test-first? Iteration pattern?]
+- [Required checks before commit: tests, lint, types?]
+
+## Code Style
+- [Naming: snake_case, camelCase, etc.]
+- [Formatting: line length, quotes, indentation]
+- [Imports: ordering, grouping]
+
+## Types
+- [Type annotations required? Strictness level?]
+
+## Testing
+- [Test file naming, location]
+- [Assertion style, mock patterns]
+- [Coverage requirements?]
+
+## Error Handling
+- [Exception patterns, logging approach]
+
+## Project-Specific
+- [Any unique requirements from CLAUDE.md]
+```
+
+**Rules:**
+- Each section: 2-4 bullet points MAX
+- Be SPECIFIC and ACTIONABLE: "Run `pytest` before commit" not "Test your code"
+- Capture the WORKFLOW, not just style
+- Include actual commands where relevant
+- Total guide: under 600 words""",
+    )
+
+    builder.add_section(
+        "Output Format",
+        """Output ONLY the coding guide in markdown format.
+
+Start with `# Coding Style` and include only relevant sections.
+
+Do NOT include explanations or meta-commentary - just the guide itself.
+
+End with:
+```
+CODING_STYLE_COMPLETE
+```""",
+    )
+
+    return builder.build()
+
+
+def extract_coding_style(result: str) -> str:
+    """Extract the coding style guide from the generation result.
+
+    Args:
+        result: The raw output from the coding style generation.
+
+    Returns:
+        The extracted coding style guide content.
+    """
+    # Remove the completion marker if present
+    content = result.replace("CODING_STYLE_COMPLETE", "").strip()
+
+    # If it starts with markdown header, return as-is
+    if content.startswith("# Coding Style") or content.startswith("# coding style"):
+        return content
+
+    # Try to find the coding style section
+    if "# Coding Style" in content:
+        idx = content.index("# Coding Style")
+        return content[idx:].strip()
+
+    # Fallback: wrap the content
+    return f"# Coding Style\n\n{content}"

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/prompts_planning.py

@@ -9,12 +9,15 @@ from __future__ import annotations
 from .prompts_base import PromptBuilder
 
 
-def build_planning_prompt(goal: str, context: str | None = None) -> str:
+def build_planning_prompt(
+    goal: str, context: str | None = None, coding_style: str | None = None
+) -> str:
     """Build the planning phase prompt.
 
     Args:
         goal: The user's goal to achieve.
         context: Optional accumulated context from previous sessions.
+        coding_style: Optional coding style guide to inject.
 
     Returns:
         Complete planning prompt.
@@ -65,16 +68,37 @@ You just need to OUTPUT the plan as TEXT in your response.
     if context:
         builder.add_section("Previous Context", context.strip())
 
+    # Coding style section if available (generated from codebase analysis)
+    if coding_style:
+        builder.add_section(
+            "Project Coding Style",
+            f"""The following coding style guide was extracted from this codebase.
+**Tasks you create MUST respect these conventions.**
+
+{coding_style.strip()}""",
+        )
+
     # Exploration phase - READ ONLY
     builder.add_section(
         "Step 1: Explore Codebase (READ ONLY)",
         """Thoroughly analyze the codebase using READ-ONLY operations:
-1. **Read** key files (README, configs, main modules)
-2. **Glob** to find patterns (`**/*.py`, `src/**/*.ts`)
-3. **Grep** for specific code (class definitions, imports)
-4. **Identify** tests, CI config, and coding standards
 
-Understand the architecture before creating tasks.""",
+**CRITICAL: Read Project Conventions FIRST**
+1. **Read `CLAUDE.md`** (if exists) - Contains coding requirements, project instructions,
+   and conventions that MUST be followed. This file defines how code should be written.
+2. Also check: `.claude/instructions.md`, `CONTRIBUTING.md`, `.cursorrules`, `.github/copilot-instructions.md`
+
+**Then explore the codebase:**
+3. **Read** key files (README, configs, main modules)
+4. **Glob** to find patterns (`**/*.py`, `src/**/*.ts`)
+5. **Grep** for specific code (class definitions, imports)
+6. **Identify** tests, CI config, and existing code patterns
+
+**Remember:** Any coding requirements found in `CLAUDE.md` or similar convention files
+MUST be respected when creating tasks. Include relevant requirements in task descriptions
+so the working phase follows project standards.
+
+Understand the architecture AND coding standards before creating tasks.""",
     )
 
     # Task creation phase - organized by PR

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/prompts_working.py

@@ -18,6 +18,7 @@ def build_work_prompt(
     create_pr: bool = True,
     pr_group_info: dict | None = None,
     target_branch: str = "main",
+    coding_style: str | None = None,
 ) -> str:
     """Build the work session prompt.
 
@@ -33,6 +34,7 @@ def build_work_prompt(
             - completed_tasks: List of completed task descriptions in this group
             - remaining_tasks: Number of tasks remaining after current
         target_branch: The target branch for rebasing (default: "main").
+        coding_style: Optional coding style guide to follow.
 
     Returns:
         Complete work session prompt.
@@ -86,6 +88,15 @@ def build_work_prompt(
     if context:
         builder.add_section("Context", context.strip())
 
+    # Coding style section - concise guide to follow
+    if coding_style:
+        builder.add_section(
+            "Coding Style (MUST FOLLOW)",
+            f"""Follow these project conventions:
+
+{coding_style.strip()}""",
+        )
+
     # File hints
     if file_hints:
         files_list = "\n".join(f"- `{f}`" for f in file_hints[:10])  # Limit to 10
@@ -194,12 +205,18 @@ git status
 - Check existing patterns
 - Identify tests to run
 
-**3. Make changes**
+**3. Read project conventions FIRST**
+- Check for `CLAUDE.md` at the repository root - it contains coding requirements
+- Also check: `.claude/instructions.md`, `CONTRIBUTING.md`, `.cursorrules`
+- These files define project-specific coding standards you MUST follow
+
+**4. Make changes**
 - Edit existing files, Write new files
-- Follow project coding style
+- Follow project coding style from `CLAUDE.md` and conventions files
 - Stay focused on current task
+- Match existing patterns and code style in the codebase
 
-**4. Verify work**
+**5. Verify work**
 ```bash
 # Common verification commands
 pytest                    # Python tests
@@ -208,7 +225,7 @@ ruff check . && mypy .   # Python lint/types
 eslint . && tsc          # JS lint/types
 ```
 
-**5. Commit properly**
+**6. Commit properly**
 ```bash
 git add -A && git commit -m "$(cat <<'EOF'
 type: Brief description (50 chars)
@@ -224,7 +241,7 @@ EOF
 **Note:** The `.claude-task-master/` directory is automatically gitignored - it contains
 orchestrator state files that should never be committed.
 
-**6. Rebase onto {target_branch} BEFORE pushing** (CRITICAL!)
+**7. Rebase onto {target_branch} BEFORE pushing** (CRITICAL!)
 ```bash
 git fetch origin {target_branch}
 git rebase origin/{target_branch}
@@ -249,7 +266,7 @@ while you were working. You MUST rebase before pushing.
 - **Package versions**: Usually take the newer version from {target_branch}
 - **Config files**: Merge both sets of changes carefully
 
-**7. Push and Create PR** (REQUIRED - DO NOT SKIP!)
+**8. Push and Create PR** (REQUIRED - DO NOT SKIP!)
 ```bash
 git push -u origin HEAD
 gh pr create --title "type: description" --body "..." --label "claudetm"
@@ -269,7 +286,7 @@ If label doesn't exist, create it and retry.
 
 **The orchestrator handles CI/reviews/merge automatically.**
 
-**8. Log File Best Practices**
+**9. Log File Best Practices**
 - For log/progress files, use APPEND mode (don't read entire file)
 - Example: `echo "message" >> progress.md` instead of Read + Write
 - This avoids context bloat from reading large log files"""
@@ -290,12 +307,18 @@ git status
 - Check existing patterns
 - Identify tests to run
 
-**3. Make changes**
+**3. Read project conventions FIRST**
+- Check for `CLAUDE.md` at the repository root - it contains coding requirements
+- Also check: `.claude/instructions.md`, `CONTRIBUTING.md`, `.cursorrules`
+- These files define project-specific coding standards you MUST follow
+
+**4. Make changes**
 - Edit existing files, Write new files
-- Follow project coding style
+- Follow project coding style from `CLAUDE.md` and conventions files
 - Stay focused on current task
+- Match existing patterns and code style in the codebase
 
-**4. Verify work**
+**5. Verify work**
 ```bash
 # Common verification commands
 pytest                    # Python tests
@@ -304,7 +327,7 @@ ruff check . && mypy .   # Python lint/types
 eslint . && tsc          # JS lint/types
 ```
 
-**5. Commit properly**
+**6. Commit properly**
 ```bash
 git add -A && git commit -m "$(cat <<'EOF'
 type: Brief description (50 chars)
@@ -320,13 +343,13 @@ EOF
 **Note:** The `.claude-task-master/` directory is automatically gitignored - it contains
 orchestrator state files that should never be committed.
 
-**6. DO NOT create PR yet**
+**7. DO NOT create PR yet**
 
 ⚠️ **More tasks remain in this PR group. Just commit, do NOT push or create PR.**
 
 The orchestrator will tell you when to create the PR (after all tasks in this group are done).
 
-**7. Log File Best Practices**
+**8. Log File Best Practices**
 - For log/progress files, use APPEND mode (don't read entire file)
 - Example: `echo "message" >> progress.md` instead of Read + Write
 - This avoids context bloat from reading large log files"""

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/state_backup.py

@@ -121,7 +121,11 @@ class BackupRecoveryMixin:
         return self._create_backup(self.state_file)
 
     def cleanup_on_success(self, run_id: str) -> None:
-        """Clean up all state files except logs on success.
+        """Clean up all state files except logs and coding-style.md on success.
+
+        Preserves:
+        - logs/ directory (keeps last 10 log files)
+        - coding-style.md (reusable across runs to save tokens)
 
         Args:
             run_id: The run ID (used for identifying which log file belongs to this run).
@@ -129,10 +133,14 @@ class BackupRecoveryMixin:
         # Release session lock first
         self.release_session_lock()
 
-        # Delete all files in state directory except logs/
+        # Files to preserve (besides logs/ directory)
+        preserved_files = {"coding-style.md"}
+
+        # Delete all files in state directory except preserved ones and logs/
         for item in self.state_dir.iterdir():
             if item.is_file():
-                item.unlink()
+                if item.name not in preserved_files:
+                    item.unlink()
             elif item.is_dir() and item != self.logs_dir:
                 shutil.rmtree(item)
 

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/state_file_ops.py

@@ -126,6 +126,26 @@ class FileOperationsMixin:
             return context_file.read_text()
         return ""
 
+    def save_coding_style(self, coding_style: str) -> None:
+        """Save coding style guide to coding-style.md.
+
+        Args:
+            coding_style: The coding style guide content.
+        """
+        coding_style_file = self.state_dir / "coding-style.md"
+        coding_style_file.write_text(coding_style)
+
+    def load_coding_style(self) -> str | None:
+        """Load coding style guide from coding-style.md.
+
+        Returns:
+            The coding style guide content, or None if not found.
+        """
+        coding_style_file = self.state_dir / "coding-style.md"
+        if coding_style_file.exists():
+            return coding_style_file.read_text()
+        return None
+
     def _parse_plan_tasks(self, plan: str) -> list[str]:
         """Parse tasks from plan markdown.
 

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master/core/task_runner.py

@@ -324,6 +324,13 @@ Please complete this task."""
         # Set task context for Claude prefix display [claude HH:MM:SS N/M]
         set_task_context(state.current_task_index + 1, len(tasks))
 
+        # Load coding style guide for token-efficient style injection
+        try:
+            coding_style = self.state_manager.load_coding_style()
+        except Exception as e:
+            console.warning(f"Could not load coding style: {e}")
+            coding_style = None
+
         # Run work session with model routing based on task complexity
         try:
             # Convert string model name to ModelType enum
@@ -339,6 +346,7 @@ Please complete this task."""
                 create_pr=should_create_pr,
                 pr_group_info=pr_group_info,
                 target_branch=target_branch,
+                coding_style=coding_style,
             )
         except AgentError:
             if self.logger:

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-task-master
-Version: 0.1.7
+Version: 0.1.8
 Summary: Autonomous task orchestration system that keeps Claude working until a goal is achieved
 Author: Claude Task Master Team
 License-Expression: MIT

{claude_task_master-0.1.7 → claude_task_master-0.1.8}/src/claude_task_master.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ src/claude_task_master/core/pr_context.py
 src/claude_task_master/core/progress_tracker.py
 src/claude_task_master/core/prompts.py
 src/claude_task_master/core/prompts_base.py
+src/claude_task_master/core/prompts_coding_style.py
 src/claude_task_master/core/prompts_plan_update.py
 src/claude_task_master/core/prompts_planning.py
 src/claude_task_master/core/prompts_verification.py

claude_task_master-0.1.7/src/claude_task_master/core/planner.py

@@ -1,46 +0,0 @@
-"""Planner - Orchestrates initial planning phase (read-only tools)."""
-
-from typing import Any
-
-from .agent import AgentWrapper
-from .state import StateManager
-
-
-class Planner:
-    """Handles the initial planning phase."""
-
-    def __init__(self, agent: AgentWrapper, state_manager: StateManager):
-        """Initialize planner."""
-        self.agent = agent
-        self.state_manager = state_manager
-
-    def create_plan(self, goal: str) -> dict[str, Any]:
-        """Create initial task plan using read-only tools."""
-        # Load any existing context
-        context = self.state_manager.load_context()
-
-        # Run planning phase with Claude
-        result = self.agent.run_planning_phase(goal=goal, context=context)
-
-        # Extract plan and criteria from result
-        plan = result.get("plan", "")
-        criteria = result.get("criteria", "")
-
-        # Save to state
-        if plan:
-            self.state_manager.save_plan(plan)
-        if criteria:
-            self.state_manager.save_criteria(criteria)
-
-        return result
-
-    def update_plan_progress(self, task_index: int, completed: bool) -> None:
-        """Update task completion status in plan."""
-        plan = self.state_manager.load_plan()
-        if not plan:
-            return
-
-        # TODO: Parse markdown checkboxes and update status
-        # This will require parsing the plan.md file and toggling checkboxes
-
-        self.state_manager.save_plan(plan)