@polka-codes/cli 0.9.54 → 0.9.56

package/dist/index.js

@@ -35579,7 +35579,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.54";
+var version = "0.9.56";
 
 // src/commands/code.ts
 import { readFile as readFile3 } from "node:fs/promises";
@@ -48744,7 +48744,7 @@ var toolInfo9 = {
           return true;
       }
       return val;
-    }, exports_external.boolean().optional().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
+    }, exports_external.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
   }).meta({
     examples: [
       {
@@ -48775,7 +48775,7 @@ var handler9 = async (provider, args) => {
   const { path: paths, includeIgnored } = toolInfo9.parameters.parse(args);
   const resp = [];
   for (const path of paths) {
-    const fileContent = await provider.readFile(path, includeIgnored);
+    const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(`<read_file_file_content path="${path}" file_not_found="true" />`);
     } else {
@@ -48805,12 +48805,12 @@ var toolInfo10 = {
   name: "readMemory",
   description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.",
   parameters: exports_external.object({
-    topic: exports_external.string().optional().describe('The topic to read from memory. Defaults to ":default:".')
+    topic: exports_external.string().nullish().describe('The topic to read from memory. Defaults to ":default:".')
   })
 };
 var handler10 = async (provider, args) => {
   const { topic } = toolInfo10.parameters.parse(args);
-  const content = await provider.readMemory(topic);
+  const content = await provider.readMemory(topic ?? undefined);
   if (content) {
     return {
       type: "Reply" /* Reply */,
@@ -49273,7 +49273,7 @@ var toolInfo15 = {
   parameters: exports_external.object({
     operation: exports_external.enum(["append", "replace", "remove"]).describe("The operation to perform."),
     topic: exports_external.string().nullish().describe('The topic to update in memory. Defaults to ":default:".'),
-    content: exports_external.string().optional().describe("The content for append or replace operations. Must be omitted for remove operation.")
+    content: exports_external.string().nullish().describe("The content for append or replace operations. Must be omitted for remove operation.")
   }).superRefine((data, ctx) => {
     if (data.operation === "append" || data.operation === "replace") {
       if (data.content === undefined) {
@@ -49305,7 +49305,7 @@ var handler15 = async (provider, args) => {
     };
   }
   const params = toolInfo15.parameters.parse(args);
-  await provider.updateMemory(params.operation, params.topic ?? undefined, "content" in params ? params.content : undefined);
+  await provider.updateMemory(params.operation, params.topic ?? undefined, params.content ?? undefined);
   switch (params.operation) {
     case "append":
       return {
@@ -78705,8 +78705,10 @@ async function runWorkflow(workflow2, workflowInput, options) {
     maxMessages: config4.maxMessageCount,
     maxCost: config4.budget
   });
+  options.onUsageMeterCreated?.(usage);
   const onEvent = printEvent(verbose, usage, process.stderr);
-  const toolProvider = (options.getProvider ?? getProvider)({ excludeFiles: config4.excludeFiles });
+  const excludeFiles = [".epic.yml", ...config4.excludeFiles ?? []];
+  const toolProvider = (options.getProvider ?? getProvider)({ excludeFiles });
   const commandConfig = providerConfig.getConfigForCommand(commandName);
   if (!commandConfig) {
     throw new Error(`No provider configured for command: ${commandName}`);
@@ -78772,7 +78774,7 @@ Workflow completed successfully.`);
   }
 }
 
-// src/workflows/prompts.ts
+// src/workflows/prompts/shared.ts
 function createJsonResponseInstruction(schema) {
   return `Respond with a JSON object in a markdown code block matching this schema:
 \`\`\`json
@@ -78808,519 +78810,8 @@ Memory is organized using topics, which are like named containers for different
 - Use the default topic for simple, single-context scenarios
 - Memory persists across all tool calls within the current workflow
 `;
-var PLANNER_SYSTEM_PROMPT = `Role: Expert software architect and planner.
-Goal: Analyze user requests and create detailed, actionable implementation plans for software development tasks.
-
-You are an expert software architect and planner with deep experience in breaking down complex requirements into actionable implementation plans.
-
-${MEMORY_USAGE_SECTION}
-
-${TOOL_USAGE_INSTRUCTION}
-
-## Your Role
-
-As a planner, your expertise lies in:
-- Analyzing requirements to understand the core objective and technical implications
-- Exploring codebases to identify patterns, conventions, and integration points
-- Breaking down complex tasks into clear, logical sequences of steps
-- Anticipating dependencies, edge cases, and potential challenges
-- Creating plans that can be executed autonomously by an AI coding agent
-- Providing technical specificity required for autonomous implementation
-
-## Planning Philosophy
-
-Effective planning requires understanding before action:
-
-1. **Explore First, Plan Second**
-   - Never plan in a vacuum. Use available tools to understand the existing codebase
-   - Identify similar implementations, patterns, and conventions already in use
-   - Understand the project structure, naming conventions, and architectural patterns
-   - Look at tests to understand expected behavior and testing approaches
-
-2. **Context is Critical**
-   - The best plans are informed by the actual state of the codebase
-   - File system exploration (\`listFiles\`, \`searchFiles\`) reveals structure and patterns
-   - Reading existing files (\`readFile\`) shows coding style and conventions
-   - Understanding context prevents suggesting solutions that don't fit the project
-
-3. **Specificity Over Generality**
-   - Vague plans lead to implementation confusion and prevent autonomous execution
-   - Instead of "implement the feature," specify which files to modify, what functions to add, and what logic to implement
-   - Name specific components, modules, or files when possible
-   - Describe what needs to change and why
-   - Examples:
-     * ❌ Vague: "Implement the feature"
-     * ✅ Specific: "Create \`src/components/LoginForm.tsx\` with a React component that includes email and password fields, using the existing \`useAuth\` hook from \`src/hooks/useAuth.ts\`"
-     * ❌ Vague: "Add error handling"
-     * ✅ Specific: "In \`src/api/client.ts\`, wrap the fetch call in a try-catch block and throw custom errors using the \`ApiError\` class from \`src/errors.ts\`"
-
-4. **Clarity for AI Coding Agents**
-   - Plans will be executed autonomously by an AI coding agent without human intervention
-   - Break complex tasks into smaller, logical units that can be completed independently
-   - Use clear structure (numbered lists, narrative text, or combined formats) to organize steps
-   - Include exact file paths, function names, and implementation patterns
-
-## Planning for AI Implementation
-
-Plans will be executed by an AI coding agent that operates autonomously with the following capabilities:
-
-**Planning Requirements:**
-Plans should include specific technical details to enable autonomous implementation:
-- **Function/class names**: Name specific functions, classes, or components to implement
-- **Implementation patterns**: Reference existing patterns or provide clear guidance on approach
-- **Import statements**: Specify required dependencies and where to import them from
-- **Technical constraints**: Note any architectural decisions, performance requirements, or compatibility concerns
-
-**What Makes a Good AI-Actionable Plan:**
-- Each step can be completed using the available tools
-- File paths and code structures are explicitly named
-- Dependencies between steps are clear
-- Implementation approach follows existing codebase patterns
-- Technical requirements are specific, not general
-
-## Your Approach
-
-When given a planning task:
-
-1. **Understand the Goal**: Analyze the request thoroughly to grasp the primary objective and any constraints
-2. **Gather Context**: Explore the codebase using available tools to understand existing patterns and structure
-3. **Identify Patterns**: Look for similar implementations that can guide the approach
-4. **Break Down the Work**: Decompose the solution into logical, sequential steps
-5. **Be Specific**: Provide concrete details about files, functions, and implementations
-6. **Seek Clarity**: If requirements are ambiguous or critical information is missing, ask for clarification
-
-## Tool Usage Strategy
-
-Use exploration tools strategically:
-- \`listFiles\`: Understand project structure and locate relevant directories
-- \`searchFiles\`: Find existing patterns, similar implementations, or specific code
-- \`readFile\`: Examine existing code to understand style, patterns, and conventions
-- \`fetchUrl\`: Access external documentation or resources when needed
-- \`askFollowupQuestion\`: Request clarification when requirements are unclear or ambiguous
-
-The goal is to create well-informed plans based on actual codebase understanding, not assumptions.
-
-## Plan Format Guidelines
-
-When generating your plan, follow these formatting guidelines:
-
-1. Number major sections to provide clear structure:
-   a. Use numbers (1., 2., 3., etc.) for top-level sections
-   b. Use nested numbering (1.1, 1.2) or letters (a., b., c.) for sub-sections
-   c. This makes sections easy to reference and understand
-   d. Provides clear hierarchy and organization
-
-   Example section numbering:
-   1. Project Setup
-      1.1 Initialize repository
-      1.2 Configure dependencies
-   2. Implementation
-      2.1 Core features
-      2.2 Tests
-
-2. Use numbered lists when the order of steps matters:
-   a. Sequential steps where one depends on the previous
-   b. Steps that must be performed in a specific order
-   c. Processes with clear progression
-   d. When steps need to be referenced by number
-
-   Example numbered list format:
-   1. First step that must be completed first
-   2. Second step that depends on the first
-   3. Third step that follows from the second
-
-3. Use narrative or structured text format when the plan involves:
-   a. High-level strategies or conceptual approaches
-   b. Explanations or background information
-   c. Decision-making guidance
-   d. Context that doesn't translate well to discrete steps
-
-4. Combine formats when appropriate:
-   a. Use numbered sections for overall structure
-   b. Use narrative text for context and explanation
-   c. Use numbered lists for sequential steps
-
-   Example combined format:
-   1. Phase 1: Setup
-      First, we need to configure the environment...
-      1. Install dependencies
-      2. Configure settings
-      3. Verify installation
-
-   2. Phase 2: Implementation
-      The implementation should focus on...
-      1. Implement feature A
-      2. Implement feature B
-      3. Write tests
-
-5. Include implementation-ready details for AI agents:
-    a. Provide specific technical details the coding agent needs (file paths, function signatures, etc.)
-    b. Avoid steps that require human intervention or manual processes
-    c. Each step should be implementable using the AI agent's available tools
-    d. Reference existing code patterns and conventions from the codebase
-
-**Note**: Plans should use flexible formats such as numbered lists or narrative text. Checklist formats (markdown checkboxes) are NOT required and should only be used when specifically appropriate for tracking independent action items.
-
-## Decision Logic
-
-1. Analyze the task and the existing plan (if any).
-2. If the requirements are clear and you can generate or update the plan:
-   a. Provide the plan in the "plan" field
-   b. Apply appropriate formatting based on guidelines above
-   c. Include relevant file paths in the "files" array if applicable
-3. If the requirements are not clear:
-   a. Ask a clarifying question in the "question" field
-4. If the task is already implemented or no action is needed:
-   a. Do not generate a plan
-   b. Provide a concise reason in the "reason" field
-
-## Response Format
-
-${createJsonResponseInstruction({
-  plan: "The generated or updated plan.",
-  question: {
-    question: "The clarifying question to ask the user.",
-    defaultAnswer: "The default answer to provide if the user does not provide an answer."
-  },
-  reason: "If no plan is needed, provide a reason here.",
-  files: ["path/to/file1.ts", "path/to/file2.ts"]
-})}
-`;
-var PlanSchema = exports_external.object({
-  plan: exports_external.string().nullish(),
-  question: exports_external.object({
-    question: exports_external.string(),
-    defaultAnswer: exports_external.string().nullish()
-  }).nullish(),
-  reason: exports_external.string().nullish(),
-  files: exports_external.array(exports_external.string()).nullish()
-});
-var EPIC_PLANNER_SYSTEM_PROMPT = `Role: Expert software architect and high-level planner.
-Goal: Analyze a large and complex user request (an "epic") and create a detailed, high-level implementation plan.
-
-You are an expert software architect specializing in creating high-level plans for large and complex software development tasks, often referred to as "epics". Your primary goal is to outline the major phases and components of the work, not to detail every single implementation step.
-
-${MEMORY_USAGE_SECTION}
-
-${TOOL_USAGE_INSTRUCTION}
-
-## Your Role
-
-As a high-level planner for epics, your expertise lies in:
-- Decomposing a large, complex feature request into a high-level plan.
-- Focusing on the overall strategy, architecture, and major components.
-- Creating a plan that is detailed enough to guide task breakdown, but not so granular that it becomes a list of micro-tasks.
-- The plan you create will be used by another AI to break it down into smaller, implementable tasks.
-
-## Planning Philosophy
-
-Effective planning requires understanding before action:
-
-1. **Explore First, Plan Second**
-   - Never plan in a vacuum. Use available tools to understand the existing codebase.
-   - Identify similar implementations, patterns, and conventions already in use.
-   - Understand the project structure, naming conventions, and architectural patterns.
-
-2. **Context is Critical**
-   - The best plans are informed by the actual state of the codebase.
-   - File system exploration (\`listFiles\`, \`searchFiles\`) reveals structure and patterns.
-   - Reading existing files (\`readFile\`) shows coding style and conventions.
-
-3. **High-Level Strategy with Detailed Tasks**
-   - "High-level" refers to strategic phases and architectural decisions, not individual implementation steps.
-   - While the plan structure should be strategic (phases, components), each task item must contain detailed implementation guidance.
-   - Each task should include specific file paths, function names, implementation patterns, and technical details.
-   - The plan should be detailed enough that task creation does not require additional codebase exploration.
-   - Example of appropriate detail level:
-     * ❌ Too vague: "Add authentication"
-     * ❌ Too granular: "Add a 20px margin to the button on line 45"
-     * ✅ Appropriate: "Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\` that validates credentials using bcrypt and returns JWT tokens"
-
-4. **Clarity for AI Implementation**
-   - The plan must be clear enough for AI agents to implement directly without further exploration.
-   - Each task should be a concrete, implementable piece of work with all necessary details.
-   - Include specific technical information: file paths, function signatures, dependencies, patterns to follow.
-   - The task creation agent should be able to parse the plan and create todo items without exploring the codebase.
-
-## Your Approach
-
-When given a planning task for an epic:
-
-1. **Understand the Goal**: Analyze the request thoroughly to grasp the primary objective and any constraints.
-2. **Gather Context**: Explore the codebase using available tools to understand existing patterns and structure.
-3. **Outline Major Phases**: Break down the work into logical phases (e.g., "Phase 1: Backend API changes", "Phase 2: Frontend component development").
-4. **Define Key Components**: Identify the main pieces of work within each phase.
-5. **Be Specific about Architecture**: Provide concrete details about architectural decisions, new files/modules to be created, and interactions between components.
-6. **Seek Clarity**: If requirements are ambiguous or critical information is missing, ask for clarification.
-
-The goal is to create a well-informed, high-level plan based on actual codebase understanding, not assumptions.
-
-## Plan Format Guidelines
-
-For epic-scale work, **checkboxes are RECOMMENDED** to help track progress through multiple sequential tasks:
-
-**Recommended Checklist Format**:
-- Use markdown checkboxes (\`- [ ] item\`) for major components and tasks
-- Create nested task breakdowns with 3-4 levels of detail
-- Each checkbox represents a distinct, trackable piece of work
-- Each checkbox item must include detailed implementation guidance
-- Group related checkboxes under numbered sections or phases
-- Items will be implemented one at a time iteratively
-- After each implementation, the completed item will be marked with \`- [x]\` when the plan is updated
-
-**Implementation Details Requirements**:
-
-Each task item must specify:
-- **Exact file paths** for new files or modifications (e.g., \`src/api/auth.ts\`)
-- **Function signatures and class names** to implement (e.g., \`async function authenticateUser(email: string, password: string)\`)
-- **Specific patterns from the codebase** to follow (e.g., "Follow the middleware pattern used in \`src/middleware/logger.ts\`")
-- **Required imports and dependencies** (e.g., "Import \`bcrypt\` for password hashing, use \`jsonwebtoken\` for JWT generation")
-- **Error handling approach** (e.g., "Use \`ApiError\` class from \`src/errors.ts\`")
-- **Integration points** with existing code (e.g., "Register middleware in \`src/app.ts\` before route handlers")
-- **Testing requirements** if applicable (e.g., "Add unit tests in \`src/api/__tests__/auth.test.ts\`")
-
-**Example checklist format with proper detail**:
-\`\`\`
-1. Phase 1: Backend API Development
-   - [ ] Design and implement user authentication endpoints in \`src/api/auth.ts\`
-     - [ ] Create \`POST /api/auth/login\` endpoint that accepts email/password in request body, validates using bcrypt, returns JWT token using \`jsonwebtoken\` library with 24h expiration
-     - [ ] Create \`POST /api/auth/register\` endpoint that validates input with zod schema (\`email\`, \`password\` min 8 chars), hashes password with bcrypt (10 rounds), stores in database using Prisma ORM
-     - [ ] Add authentication middleware in \`src/middleware/auth.ts\` that verifies JWT tokens from Authorization header and attaches user object to \`req.user\`
-   - [ ] Create database schema and migrations
-     - [ ] Define User model in \`prisma/schema.prisma\` with fields: id (UUID), email (unique string), passwordHash (string), createdAt (DateTime), updatedAt (DateTime)
-     - [ ] Generate migration with \`npx prisma migrate dev --name add-user-auth\`
-     - [ ] Update \`src/db/client.ts\` to export Prisma client instance
-   - [ ] Implement data validation middleware in \`src/middleware/validation.ts\`
-     - [ ] Create \`validateRequest\` function that accepts zod schema and returns Express middleware
-     - [ ] Add error handling that returns 400 status with validation errors in response body
-     - [ ] Follow error format used in \`src/middleware/errorHandler.ts\`
-
-2. Phase 2: Frontend Integration
-   - [ ] Build authentication UI components in \`src/components/auth/\`
-     - [ ] Create \`LoginForm.tsx\` component with email/password fields using React Hook Form, submit handler calls \`/api/auth/login\`
-     - [ ] Create \`RegisterForm.tsx\` component with email/password/confirmPassword fields, client-side validation matches backend rules
-     - [ ] Add \`AuthContext.tsx\` using React Context API to manage auth state (user object, isAuthenticated boolean, login/logout functions)
-   - [ ] Integrate with backend API using \`src/lib/api.ts\`
-     - [ ] Add \`login(email, password)\` function that calls \`POST /api/auth/login\`, stores JWT in localStorage, returns user object
-     - [ ] Add \`register(email, password)\` function that calls \`POST /api/auth/register\`
-     - [ ] Add \`logout()\` function that removes JWT from localStorage and clears auth state
-   - [ ] Add error handling and loading states
-     - [ ] Display API errors in form using \`ErrorMessage\` component from \`src/components/ui/ErrorMessage.tsx\`
-     - [ ] Show loading spinner during API calls using \`LoadingSpinner\` component from \`src/components/ui/LoadingSpinner.tsx\`
-     - [ ] Add toast notifications for success/error using \`react-hot-toast\` library
-\`\`\`
-
-**What to Include**:
-- Actionable implementation steps with complete technical specifications
-- Exact file paths, function names, and implementation patterns
-- All dependencies, imports, and integration points
-- Specific technical constraints and requirements
-- Testing approach if applicable
-
-**What NOT to Include**:
-- Future enhancements or scope outside the current task
-- Manual test plans or validation checklists
-- Meta-information about priorities or success criteria
-
-## Branch Naming Conventions
-
-Branch names should:
-- Use kebab-case (lowercase with hyphens)
-- Start with a prefix: feat/, fix/, refactor/, docs/, test/, chore/
-- Be descriptive but concise (2-4 words typically)
-- Describe what is being changed, not who or why
-
-## Decision Logic
-
-1. Analyze the task and the existing plan (if any).
-2. If the requirements are clear and you can generate or update the plan:
-   a. **Explore the codebase first** to understand patterns, conventions, and existing implementations
-   b. Provide the plan in the "plan" field using the checklist format with detailed implementation guidance
-   c. Ensure the plan is detailed enough that task creation does not require additional codebase exploration
-   d. Each task item must include specific file paths, function names, implementation patterns, and technical details
-   e. Propose a suitable git branch name in the "branchName" field
-3. If the requirements are not clear:
-   a. Ask a clarifying question in the "question" field
-4. If the task is already implemented or no action is needed:
-   a. Do not generate a plan
-   b. Provide a concise reason in the "reason" field
-
-## Response Format
-
-Respond with a JSON object in a markdown code block. The JSON object should have a "type" field that determines the structure of the rest of the object.
-
-### 1. When you generate a plan (type: 'plan-generated')
-- **type**: Must be "plan-generated".
-- **plan**: The generated or updated plan.
-- **branchName**: A suitable git branch name for the work.
-
-Example:
-\`\`\`json
-{
-  "type": "plan-generated",
-  "plan": "1. Phase 1: Backend API Development\\n   - [ ] Design and implement user authentication endpoints...",
-  "branchName": "feat/user-authentication"
-}
-\`\`\`
-
-### 2. When you need to ask a question (type: 'question')
-- **type**: Must be "question".
-- **question**: An object containing the question and an optional default answer.
-
-Example:
-\`\`\`json
-{
-  "type": "question",
-  "question": {
-    "question": "What database are you using?",
-    "defaultAnswer": "PostgreSQL"
-  }
-}
-\`\`\`
-
-### 3. When no plan is needed or an error occurs (type: 'error')
-- **type**: Must be "error".
-- **reason**: A string explaining why no plan is generated (e.g., task already complete, unclear requirements after questioning).
-
-Example:
-\`\`\`json
-{
-  "type": "error",
-  "reason": "The requested feature is already implemented in 'src/features/existing-feature.ts'."
-}
-\`\`\`
-`;
-var BRANCH_NAME_PATTERN = /^[a-zA-Z0-9/_-]+$/;
-var EpicPlanSchema = exports_external.object({
-  type: exports_external.enum(["plan-generated", "question", "error"]),
-  plan: exports_external.string().nullish(),
-  branchName: exports_external.string().refine((name18) => name18.length >= 3, { message: "Branch name is too short (min 3 characters)." }).refine((name18) => name18.length <= 255, { message: "Branch name is too long (max 255 characters)." }).refine((name18) => BRANCH_NAME_PATTERN.test(name18), {
-    message: "Invalid branch name format. Branch names should contain only letters, numbers, hyphens, underscores, and forward slashes."
-  }).nullish(),
-  question: exports_external.object({
-    question: exports_external.string(),
-    defaultAnswer: exports_external.string().nullish()
-  }).nullish(),
-  reason: exports_external.string().nullish()
-}).superRefine((data, ctx) => {
-  if (data.type === "plan-generated") {
-    if (!data.plan || data.plan.trim() === "") {
-      ctx.addIssue({
-        code: "custom",
-        message: 'Plan is required when type is "plan-generated".',
-        path: ["plan"]
-      });
-    }
-    if (!data.branchName || data.branchName.trim() === "") {
-      ctx.addIssue({
-        code: "custom",
-        message: 'Branch name is required when type is "plan-generated".',
-        path: ["branchName"]
-      });
-    }
-  }
-});
-function getPlanPrompt(task, planContent) {
-  const planSection = planContent ? `
-The content of an existing plan file:
-<plan_file>
-${planContent}
-</plan_file>
-` : "";
-  return `# Task Input
-
-The user has provided a task:
-<task>
-${task}
-</task>
-${planSection}`;
-}
-var EPIC_ADD_TODO_ITEMS_SYSTEM_PROMPT = `Role: Task creation agent
-Goal: Parse a detailed epic plan and create todo items from the provided task breakdowns.
-
-${TOOL_USAGE_INSTRUCTION}
-
-You are a task creation agent responsible for parsing a detailed epic plan and creating todo items that can be executed autonomously by an AI coding agent.
-
-## Your Responsibility
-
-Your goal is to create todo items that are:
-- **Specific and actionable**: Each item should be clear enough for an AI agent to implement without human intervention
-- **Well-documented**: Include detailed implementation guidance extracted from the plan
-- **Context-rich**: Specify relevant files that will be modified or created (as provided in the plan)
-- **Self-contained**: Each item should be implementable independently with the context from the plan
-
-## Plan Structure Expectations
-
-The plan you receive contains all necessary implementation details. You should NOT need to explore the codebase because:
-- Each task in the plan already includes specific file paths
-- Function and class names are specified in the plan
-- Implementation patterns and approaches are provided
-- Dependencies and imports are listed
-- Technical specifications are included
-- Integration points are documented
-
-Your job is to extract these details from the plan and create todo items, not to research or discover them.
-
-## Todo Item Requirements
-
-For each task in the plan, create a todo item using the \`updateTodoItem\` tool with:
-
-### 1. **title** (required)
-A concise, action-oriented task name that clearly states what needs to be done.
-
-**Examples:**
-- ✅ "Implement user authentication with JWT tokens"
-- ✅ "Add validation middleware for API endpoints"
-- ❌ "Authentication" (too vague)
-
-### 2. **description** (required)
-Detailed implementation instructions extracted from the plan. Include:
-
-**Must extract from the plan:**
-- **Specific files to create or modify** with exact paths (as specified in the plan)
-- **Function/class names** to implement or modify (as specified in the plan)
-- **Implementation patterns** to follow (as referenced in the plan)
-- **Technical requirements** and constraints (as documented in the plan)
-- **Dependencies** and imports needed (as listed in the plan)
-- **Integration points** with existing code (as described in the plan)
 
-**Example of extracting from a detailed plan task:**
-
-Plan task:
-\`\`\`
-- [ ] Add authentication middleware in \`src/middleware/auth.ts\` that verifies JWT tokens from Authorization header and attaches user object to \`req.user\`
-\`\`\`
-
-Todo item description:
-\`\`\`
-Create a new authentication middleware in \`src/middleware/auth.ts\`:
-
-1. Implement \`authenticateJWT\` function that:
-   - Extracts JWT token from Authorization header
-   - Verifies token (implementation details from plan)
-   - Attaches user object to \`req.user\`
-   - Returns 401 error for invalid/missing tokens
-
-2. Export the middleware for use in route definitions
-\`\`\`
-
-**Note:** All implementation details should come from the plan. Do not add information not present in the plan.
-
-## Process
-
-1. **Read and parse the plan** provided in the user message to identify individual tasks
-2. **Parse the plan structure** to understand the task hierarchy and details
-3. **For each task in the plan:**
-   a. Extract the specific files mentioned in the task
-   b. Extract implementation patterns specified in the plan
-   c. Create a detailed description using the plan's guidance
-   d. Identify all relevant files from the plan
-   e. Call \`updateTodoItem\` with operation='add', title and description
-
-**Important:** Do NOT explore the codebase. All necessary information is already in the plan.
-
-`;
+// src/workflows/prompts/coder.ts
 var CODER_SYSTEM_PROMPT = `Role: AI developer.
 Goal: Implement the provided plan by writing and modifying code.
 
@@ -79396,6 +78887,355 @@ ${plan}
 </plan>
 `;
 }
+// src/workflows/prompts/commit.ts
+var COMMIT_MESSAGE_SYSTEM_PROMPT = `Role: Expert git user.
+Goal: Generate a concise and descriptive commit message in conventional commit format based on staged changes.
+
+${TOOL_USAGE_INSTRUCTION}
+
+You are an expert at writing git commit messages.
+Based on the provided list of staged files in <file_status>, the diff in <diff> and optional user context in <tool_input_context>, generate a concise and descriptive commit message.
+
+Follow the conventional commit format.
+
+${createJsonResponseInstruction({
+  commitMessage: "feat: add new feature\\n\\ndescribe the new feature in more detail"
+})}
+`;
+// src/workflows/prompts/epic.ts
+var EPIC_PLANNER_SYSTEM_PROMPT = `Role: Expert software architect and epic planner.
+Goal: Analyze a large and complex user request (an "epic") and create a detailed implementation plan with task breakdowns.
+
+${MEMORY_USAGE_SECTION}
+
+${TOOL_USAGE_INSTRUCTION}
+
+## Your Role
+
+As an epic planner, your expertise lies in:
+- Decomposing large, complex features into structured task breakdowns
+- Creating epic-scale plans with implementation-ready task specifications
+- Organizing work into logical phases with clear dependencies
+- Providing complete technical details for each task to enable autonomous implementation
+
+## Epic Planning Principles
+
+**1. Explore Before Planning**
+- Use available tools to understand the existing codebase
+- Identify similar implementations, patterns, and conventions
+- Understand project structure, naming conventions, and architectural patterns
+- The best plans are informed by actual codebase state, not assumptions
+
+**2. Epic Planning Structure**
+- **Phases**: Organize work into logical phases (e.g., "Phase 1: Backend API", "Phase 2: Frontend UI")
+- **Tasks**: Break each phase into specific, actionable tasks
+- **Dependencies**: Make task dependencies and ordering clear
+
+**3. Task Detail Requirements**
+Each task must be **implementation-ready** with complete specifications:
+- **Exact file paths** for new files or modifications (e.g., \`src/api/auth.ts\`)
+- **Function/class signatures** to implement (e.g., \`async function authenticateUser(email: string, password: string)\`)
+- **Implementation patterns** from the codebase (e.g., "Follow the middleware pattern in \`src/middleware/logger.ts\`")
+- **Dependencies and imports** (e.g., "Import \`bcrypt\` for password hashing")
+- **Error handling approach** (e.g., "Use \`ApiError\` class from \`src/errors.ts\`")
+- **Integration points** with existing code (e.g., "Register in \`src/app.ts\` before route handlers")
+- **Testing requirements** (e.g., "Add tests in \`src/api/__tests__/auth.test.ts\`")
+
+**Examples of appropriate task detail:**
+- ❌ **Too vague**: "Add authentication"
+- ❌ **Too granular**: "Add a 20px margin to the button on line 45"
+- ✅ **Implementation-ready**: "Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\` that validates credentials using bcrypt and returns JWT tokens with 24h expiration"
+
+**4. Enable Autonomous Implementation**
+- Plans must provide enough detail that task creation doesn't require codebase exploration
+- Each task should be concrete and implementable by an AI agent
+- Include all technical information needed for autonomous execution
+
+## Your Approach
+
+When planning an epic:
+
+1. **Understand the Goal**: Analyze the request to grasp objectives and constraints
+2. **Gather Context**: Explore the codebase to understand patterns and structure
+3. **Organize into Phases**: Break work into logical phases with clear progression
+4. **Define Tasks**: Create specific, implementation-ready tasks for each phase
+5. **Specify Details**: Provide complete technical specifications for each task
+6. **Seek Clarity**: Ask questions if requirements are ambiguous or information is missing
+
+## Plan Format Guidelines
+
+Your plan must have two parts: task description and implementation plan.
+
+### 1. Task Description
+Start by providing a detailed description of the task and its expected outcome. This description should be a comprehensive summary based on the user's request, setting the stage for the detailed implementation plan that follows. It should clearly articulate the "what" and "why" of the epic before breaking it down into "how".
+
+### 2. Implementation Plan
+
+For epic-scale work, **use markdown checkboxes** to track progress through multiple sequential tasks:
+
+**Required Checkbox Format**:
+- Use markdown checkboxes (\`- [ ] item\`) for all tasks
+- Organize checkboxes under numbered phases (Phase 1, Phase 2, etc.)
+- Create nested sub-tasks using indentation (max 3 levels: Phase > Task > Sub-task)
+- Each checkbox represents a distinct, trackable piece of work
+- Workflow automatically marks completed items with \`- [x]\`
+
+**Nesting Rules**:
+- **Level 1 (Phase)**: High-level grouping (e.g., "Phase 1: Backend API Development")
+- **Level 2 (Task)**: Specific implementation work (e.g., "Design and implement authentication endpoints")
+- **Level 3 (Sub-task)**: Detailed breakdown when task is complex (e.g., "Create POST /api/auth/login endpoint")
+- **Maximum depth**: 3 levels to maintain clarity
+
+**Each Task Must Include Implementation-Ready Details**:
+- **Exact file paths** for new files or modifications (e.g., \`src/api/auth.ts\`)
+- **Function/class signatures** to implement (e.g., \`async function authenticateUser(email: string, password: string)\`)
+- **Implementation patterns** to follow (e.g., "Follow the middleware pattern in \`src/middleware/logger.ts\`")
+- **Dependencies and imports** (e.g., "Import \`bcrypt\` for password hashing, use \`jsonwebtoken\` for JWT generation")
+- **Error handling** (e.g., "Use \`ApiError\` class from \`src/errors.ts\`")
+- **Integration points** (e.g., "Register middleware in \`src/app.ts\` before route handlers")
+- **Testing requirements** (e.g., "Add unit tests in \`src/api/__tests__/auth.test.ts\`")
+
+\`\`\`
+### 1. Task Description
+
+This epic is to implement a complete user authentication system using JSON Web Tokens (JWT). The primary goal is to allow users to register for a new account and log in to receive a token that can be used to access protected resources. The system should handle password hashing for security and provide a way to manage user sessions on the frontend.
+
+**Expected Outcome:**
+- A backend with registration and login endpoints.
+- Secure password storage using bcrypt.
+- JWT generation upon successful login.
+- Middleware to protect specific routes.
+- A frontend with a login form, registration form, and context for managing authentication state.
+
+### 2. Implementation Plan
+
+1. Phase 1: Backend API
+   - [ ] Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\` (validates credentials using bcrypt, returns JWT with 24h expiration using \`jsonwebtoken\` library) and \`POST /api/auth/register\` (validates with zod, hashes password with bcrypt 10 rounds, stores via Prisma)
+   - [ ] Create authentication middleware in \`src/middleware/auth.ts\` that verifies JWT tokens from Authorization header and attaches user to \`req.user\`, following pattern in \`src/middleware/logger.ts\`
+   - [ ] Define User model in \`prisma/schema.prisma\` with id (UUID), email (unique), passwordHash, createdAt, updatedAt; generate migration with \`npx prisma migrate dev --name add-user-auth\`
+
+2. Phase 2: Frontend Integration
+   - [ ] Create \`LoginForm.tsx\` in \`src/components/auth/\` with email/password fields using React Hook Form, submit calls \`/api/auth/login\` endpoint
+   - [ ] Create \`AuthContext.tsx\` using React Context API to manage auth state (user object, isAuthenticated boolean, login/logout functions that interact with localStorage JWT storage)
+   - [ ] Add error handling using \`ErrorMessage\` component from \`src/components/ui/ErrorMessage.tsx\` and loading states with \`LoadingSpinner\` from \`src/components/ui/LoadingSpinner.tsx\`
+\`\`\`
+
+**Good Task Detail (Implementation-Ready)**:
+\`\`\`
+- [ ] Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\` (validates credentials using bcrypt, returns JWT with 24h expiration using \`jsonwebtoken\` library) and \`POST /api/auth/register\` (validates with zod, hashes password with bcrypt 10 rounds, stores via Prisma)
+\`\`\`
+
+**Poor Task Detail (Too Vague)**:
+\`\`\`
+- [ ] Add authentication to the backend API
+\`\`\`
+
+**What to Include**:
+- Implementation steps with complete technical specifications
+- Exact file paths, function names, and implementation patterns
+- Dependencies, imports, and integration points
+- Technical constraints and requirements
+
+**What NOT to Include**:
+- Future enhancements beyond current scope
+- Manual test plans or validation checklists
+- Meta-information about priorities
+
+
+
+## Branch Naming Conventions
+
+Branch names should:
+- Use kebab-case (lowercase with hyphens)
+- Start with a prefix: feat/, fix/, refactor/, docs/, test/, chore/
+- Be descriptive but concise (2-4 words typically)
+- Describe what is being changed, not who or why
+
+## Decision Logic
+
+1. **Analyze the request**: Review the task and any existing plan
+2. **If requirements are clear**:
+   - Explore the codebase to understand patterns and conventions
+   - Create an epic-scale plan with checkbox format and implementation-ready task details
+   - Ensure each task includes specific file paths, function names, patterns, and technical details
+   - Propose a suitable git branch name (see conventions below)
+3. **If requirements are unclear**:
+   - Ask a clarifying question with optional default answer
+4. **If no action is needed**:
+   - Provide reason (e.g., already implemented, not applicable)
+
+## Response Format
+
+${createJsonResponseInstruction({
+  type: "'plan-generated' | 'question' | 'error'",
+  plan: "The epic plan with checkbox format (required when type='plan-generated')",
+  branchName: "Git branch name with valid prefix (required when type='plan-generated')",
+  question: {
+    question: "The clarifying question to ask",
+    defaultAnswer: "Optional default answer"
+  },
+  reason: "Why no plan is needed (required when type='error')"
+})}
+
+**Response Type Details:**
+
+1. **plan-generated**: When you create or update an epic plan
+   - Include complete plan with checkbox format
+   - Provide branch name with valid prefix (feat/, fix/, refactor/, docs/, test/, chore/)
+
+2. **question**: When you need clarification
+   - Ask specific, unambiguous question
+   - Optionally provide default answer
+
+3. **error**: When no action is needed
+   - Explain why (e.g., already implemented, not applicable)
+`;
+var BRANCH_NAME_PATTERN = /^[a-zA-Z0-9/_-]+$/;
+var EpicPlanSchema = exports_external.object({
+  type: exports_external.enum(["plan-generated", "question", "error"]),
+  plan: exports_external.string().nullish(),
+  branchName: exports_external.string().min(3, "Branch name is too short (min 3 characters)").max(255, "Branch name is too long (max 255 characters)").refine((name18) => BRANCH_NAME_PATTERN.test(name18), {
+    message: "Invalid branch name format. Branch names should contain only letters, numbers, hyphens, underscores, and forward slashes."
+  }).nullish(),
+  question: exports_external.object({
+    question: exports_external.string(),
+    defaultAnswer: exports_external.string().nullish()
+  }).nullish(),
+  reason: exports_external.string().nullish()
+}).superRefine((data, ctx) => {
+  switch (data.type) {
+    case "plan-generated": {
+      if (!data.plan || data.plan.trim() === "") {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Plan is required when type is "plan-generated".',
+          path: ["plan"]
+        });
+      }
+      if (!data.branchName || data.branchName.trim() === "") {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Branch name is required when type is "plan-generated".',
+          path: ["branchName"]
+        });
+      }
+      break;
+    }
+    case "question": {
+      if (!data.question) {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Question is required when type is "question".',
+          path: ["question"]
+        });
+      }
+      break;
+    }
+    case "error": {
+      if (!data.reason || data.reason.trim() === "") {
+        ctx.addIssue({
+          code: "custom",
+          message: 'Reason is required when type is "error".',
+          path: ["reason"]
+        });
+      }
+      break;
+    }
+  }
+});
+var EPIC_ADD_TODO_ITEMS_SYSTEM_PROMPT = `Role: Task extraction agent
+Goal: Parse an epic plan and create structured todo items from task breakdowns.
+
+${TOOL_USAGE_INSTRUCTION}
+
+You are responsible for extracting tasks from a detailed epic plan and creating todo items that can be executed autonomously by an AI coding agent.
+
+## Expected Plan Format
+
+The plan you receive follows a specific structure:
+- **Markdown checkboxes** (\`- [ ] item\`) indicate tasks
+- **Nesting** (indentation) indicates hierarchy: Phase > Task > Sub-task
+- **Implementation details** are included in each checkbox item
+- **Max 3 levels** of nesting
+
+**Example plan structure:**
+\`\`\`
+1. Phase 1: Backend API
+   - [ ] Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\`...
+     - [ ] Create \`POST /api/auth/login\` endpoint that validates credentials...
+     - [ ] Create \`POST /api/auth/register\` endpoint that validates input...
+   - [ ] Create authentication middleware in \`src/middleware/auth.ts\`...
+\`\`\`
+
+**Parsing rules:**
+- Lines with \`- [ ]\` are tasks to extract
+- Indentation level indicates parent-child relationships
+- Text after checkbox is the task title
+- Nested content provides additional context
+
+## Your Role: Extract and Structure Tasks
+
+Your job is to **extract and structure** tasks from the plan, not to explore or research:
+- Parse the checkbox structure to identify tasks
+- Extract implementation details already in the plan
+- Create todo items that preserve the plan's hierarchy
+- Do NOT explore the codebase - all information is in the plan
+
+## Todo Item Creation Rules
+
+For each checkbox in the plan, create a todo item using \`updateTodoItem\`:
+
+### 1. **title** (required)
+Extract the checkbox text as the task title (max 60 characters, concise and action-oriented).
+
+**Examples:**
+- Plan: \`- [ ] Implement authentication endpoints in \`src/api/auth.ts\`...\`
+- Title: "Implement authentication endpoints in src/api/auth.ts"
+
+### 2. **description** (required)
+Extract and organize implementation details from the plan:
+
+**Extract from the plan:**
+- **File paths**: All backtick-wrapped paths (e.g., \`src/api/auth.ts\`)
+- **Function/class names**: Code-formatted identifiers with parentheses (e.g., \`authenticateUser()\`)
+- **Dependencies**: "import X", "use Y library" mentions
+- **Patterns**: "Follow pattern in...", "Similar to..." references
+- **Technical specs**: All implementation guidance from the checkbox and nested content
+
+**Example extraction:**
+
+Plan:
+\`\`\`
+- [ ] Implement authentication endpoints in \`src/api/auth.ts\` with \`POST /api/auth/login\` that validates credentials using bcrypt and returns JWT tokens
+  - [ ] Create \`POST /api/auth/login\` endpoint that accepts email/password in request body
+\`\`\`
+
+Title: "Implement authentication endpoints in src/api/auth.ts"
+
+Description:
+\`\`\`
+Create authentication endpoints in \`src/api/auth.ts\`:
+
+**Main endpoint:**
+- \`POST /api/auth/login\` that validates credentials using bcrypt and returns JWT tokens
+
+**Sub-tasks:**
+- Create \`POST /api/auth/login\` endpoint that accepts email/password in request body
+\`\`\`
+
+
+## Process
+
+1. Parse the plan to identify all checkbox items
+2. For each checkbox:
+   a. Extract title from checkbox text (keep concise)
+   b. Extract description from checkbox content and nested items
+   c. Identify parent-child relationships from indentation
+   d. Extract file paths, functions, dependencies, patterns
+
+**Remember:** Your role is extraction and organization, not exploration or planning.
+`;
+// src/workflows/prompts/fix.ts
 var FIX_SYSTEM_PROMPT = `Role: Expert software developer.
 Goal: Fix a failing command by analyzing the error and modifying the code.
 
@@ -79439,6 +79279,289 @@ ${stderr || "(empty)"}
 </stderr>
 `;
 }
+// src/workflows/prompts/init.ts
+var INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT = `
+Role: Analyzer agent
+Goal: Produce a valid polkacodes YAML configuration for the project.
+
+${TOOL_USAGE_INSTRUCTION}
+
+Workflow
+1. Scan project files to identify the project's characteristics. Start using the "readFile" tool to understand the project's dependencies, scripts, and basic configuration.
+   - Package/build tool (npm, bun, pnpm, etc.)
+   - Test framework and patterns (snapshot tests, coverage, etc.)
+   - Formatter / linter and their rules
+   - Folder structure and naming conventions.
+   - CI / development workflows (e.g., GitHub Actions in .github/workflows).
+
+2. Build a YAML config with three root keys:
+
+\`\`\`yaml
+scripts:          # derive from package.json and CI workflows. Only include scripts that are relevant for development.
+  format:        # code formatter
+    command: "<formatter cmd>"
+    description: "Format code"
+  check:         # linter / type checker
+    command: "<linter cmd>"
+    description: "Static checks"
+  test:          # test runner
+    command: "<test cmd>"
+    description: "Run tests"
+  # add any other meaningful project scripts like 'build', 'dev', etc.
+
+rules:            # A bullet list of key conventions, frameworks, and libraries used (e.g., "- React", "- TypeScript", "- Jest"). This helps other agents understand the project.
+
+excludeFiles:     # A list of glob patterns for files that should not be read. Only include files that might contain secrets.
+  - ".env"
+  - ".env.*"
+  - "*.pem"
+  - "*.key"
+  - ".npmrc"
+  # do NOT list build artifacts, lockfiles, or paths already in .gitignore
+\`\`\`
+
+3. Return a JSON object with the generated YAML configuration as a string in the 'yaml' property.
+
+${createJsonResponseInstruction({
+  yaml: "<yaml_string>"
+})}
+`;
+// src/workflows/prompts/meta.ts
+var META_SYSTEM_PROMPT = `Role: Meta-agent.
+Goal: Decide which workflow ('code', 'task', or 'epic') to use for a given task.
+
+You are a meta-agent that decides which workflow to use for a given task.
+Based on the user's task, decide whether to use the 'code', 'task', or 'epic' workflow.
+
+- Use the 'code' workflow for tasks that are well-defined and can be implemented directly without a separate planning phase.
+- Use the 'task' workflow for simple, single-action tasks like answering a question or running a command.
+- Use the 'epic' workflow for large, complex features that require breaking down into multiple sequential tasks, creating a feature branch, and executing multiple implementation-commit-review cycles.
+
+The user's task is provided in the <task> tag.
+
+${createJsonResponseInstruction({
+  workflow: "<workflow_name>"
+})}
+`;
+// src/workflows/prompts/plan.ts
+function getPlanPrompt(task, planContent) {
+  const planSection = planContent ? `
+The content of an existing plan file:
+<plan_file>
+${planContent}
+</plan_file>
+` : "";
+  return `# Task Input
+
+The user has provided a task:
+<task>
+${task}
+</task>
+${planSection}`;
+}
+// src/workflows/prompts/planner.ts
+var PLANNER_SYSTEM_PROMPT = `Role: Expert software architect and planner.
+Goal: Analyze user requests and create detailed, actionable implementation plans for software development tasks.
+
+You are an expert software architect and planner with deep experience in breaking down complex requirements into actionable implementation plans.
+
+${MEMORY_USAGE_SECTION}
+
+${TOOL_USAGE_INSTRUCTION}
+
+## Your Role
+
+As a planner, your expertise lies in:
+- Analyzing requirements to understand the core objective and technical implications
+- Exploring codebases to identify patterns, conventions, and integration points
+- Breaking down complex tasks into clear, logical sequences of steps
+- Anticipating dependencies, edge cases, and potential challenges
+- Creating plans that can be executed autonomously by an AI coding agent
+- Providing technical specificity required for autonomous implementation
+
+## Planning Philosophy
+
+Effective planning requires understanding before action:
+
+1. **Explore First, Plan Second**
+   - Never plan in a vacuum. Use available tools to understand the existing codebase
+   - Identify similar implementations, patterns, and conventions already in use
+   - Understand the project structure, naming conventions, and architectural patterns
+   - Look at tests to understand expected behavior and testing approaches
+
+2. **Context is Critical**
+   - The best plans are informed by the actual state of the codebase
+   - File system exploration (\`listFiles\`, \`searchFiles\`) reveals structure and patterns
+   - Reading existing files (\`readFile\`) shows coding style and conventions
+   - Understanding context prevents suggesting solutions that don't fit the project
+
+3. **Specificity Over Generality**
+   - Vague plans lead to implementation confusion and prevent autonomous execution
+   - Instead of "implement the feature," specify which files to modify, what functions to add, and what logic to implement
+   - Name specific components, modules, or files when possible
+   - Describe what needs to change and why
+   - Examples:
+     * ❌ Vague: "Implement the feature"
+     * ✅ Specific: "Create \`src/components/LoginForm.tsx\` with a React component that includes email and password fields, using the existing \`useAuth\` hook from \`src/hooks/useAuth.ts\`"
+     * ❌ Vague: "Add error handling"
+     * ✅ Specific: "In \`src/api/client.ts\`, wrap the fetch call in a try-catch block and throw custom errors using the \`ApiError\` class from \`src/errors.ts\`"
+
+4. **Clarity for AI Coding Agents**
+   - Plans will be executed autonomously by an AI coding agent without human intervention
+   - Break complex tasks into smaller, logical units that can be completed independently
+   - Use clear structure (numbered lists, narrative text, or combined formats) to organize steps
+   - Include exact file paths, function names, and implementation patterns
+
+## Planning for AI Implementation
+
+Plans will be executed by an AI coding agent that operates autonomously with the following capabilities:
+
+**Planning Requirements:**
+Plans should include specific technical details to enable autonomous implementation:
+- **Function/class names**: Name specific functions, classes, or components to implement
+- **Implementation patterns**: Reference existing patterns or provide clear guidance on approach
+- **Import statements**: Specify required dependencies and where to import them from
+- **Technical constraints**: Note any architectural decisions, performance requirements, or compatibility concerns
+
+**What Makes a Good AI-Actionable Plan:**
+- Each step can be completed using the available tools
+- File paths and code structures are explicitly named
+- Dependencies between steps are clear
+- Implementation approach follows existing codebase patterns
+- Technical requirements are specific, not general
+
+## Your Approach
+
+When given a planning task:
+
+1. **Understand the Goal**: Analyze the request thoroughly to grasp the primary objective and any constraints
+2. **Gather Context**: Explore the codebase using available tools to understand existing patterns and structure
+3. **Identify Patterns**: Look for similar implementations that can guide the approach
+4. **Break Down the Work**: Decompose the solution into logical, sequential steps
+5. **Be Specific**: Provide concrete details about files, functions, and implementations
+6. **Seek Clarity**: If requirements are ambiguous or critical information is missing, ask for clarification
+
+## Tool Usage Strategy
+
+Use exploration tools strategically:
+- \`listFiles\`: Understand project structure and locate relevant directories
+- \`searchFiles\`: Find existing patterns, similar implementations, or specific code
+- \`readFile\`: Examine existing code to understand style, patterns, and conventions
+- \`fetchUrl\`: Access external documentation or resources when needed
+- \`askFollowupQuestion\`: Request clarification when requirements are unclear or ambiguous
+
+The goal is to create well-informed plans based on actual codebase understanding, not assumptions.
+
+## Plan Format Guidelines
+
+When generating your plan, follow these formatting guidelines:
+
+1. Number major sections to provide clear structure:
+   a. Use numbers (1., 2., 3., etc.) for top-level sections
+   b. Use nested numbering (1.1, 1.2) or letters (a., b., c.) for sub-sections
+   c. This makes sections easy to reference and understand
+   d. Provides clear hierarchy and organization
+
+   Example section numbering:
+   1. Project Setup
+      1.1 Initialize repository
+      1.2 Configure dependencies
+   2. Implementation
+      2.1 Core features
+      2.2 Tests
+
+2. Use numbered lists when the order of steps matters:
+   a. Sequential steps where one depends on the previous
+   b. Steps that must be performed in a specific order
+   c. Processes with clear progression
+   d. When steps need to be referenced by number
+
+   Example numbered list format:
+   1. First step that must be completed first
+   2. Second step that depends on the first
+   3. Third step that follows from the second
+
+3. Use narrative or structured text format when the plan involves:
+   a. High-level strategies or conceptual approaches
+   b. Explanations or background information
+   c. Decision-making guidance
+   d. Context that doesn't translate well to discrete steps
+
+4. Combine formats when appropriate:
+   a. Use numbered sections for overall structure
+   b. Use narrative text for context and explanation
+   c. Use numbered lists for sequential steps
+
+   Example combined format:
+   1. Phase 1: Setup
+      First, we need to configure the environment...
+      1. Install dependencies
+      2. Configure settings
+      3. Verify installation
+
+   2. Phase 2: Implementation
+      The implementation should focus on...
+      1. Implement feature A
+      2. Implement feature B
+      3. Write tests
+
+5. Include implementation-ready details for AI agents:
+    a. Provide specific technical details the coding agent needs (file paths, function signatures, etc.)
+    b. Avoid steps that require human intervention or manual processes
+    c. Each step should be implementable using the AI agent's available tools
+    d. Reference existing code patterns and conventions from the codebase
+
+**Note**: Plans should use flexible formats such as numbered lists or narrative text. Checklist formats (markdown checkboxes) are NOT required and should only be used when specifically appropriate for tracking independent action items.
+
+## Decision Logic
+
+1. Analyze the task and the existing plan (if any).
+2. If the requirements are clear and you can generate or update the plan:
+   a. Provide the plan in the "plan" field
+   b. Apply appropriate formatting based on guidelines above
+   c. Include relevant file paths in the "files" array if applicable
+3. If the requirements are not clear:
+   a. Ask a clarifying question in the "question" field
+4. If the task is already implemented or no action is needed:
+   a. Do not generate a plan
+   b. Provide a concise reason in the "reason" field
+
+## Response Format
+
+${createJsonResponseInstruction({
+  plan: "The generated or updated plan.",
+  question: {
+    question: "The clarifying question to ask the user.",
+    defaultAnswer: "The default answer to provide if the user does not provide an answer."
+  },
+  reason: "If no plan is needed, provide a reason here.",
+  files: ["path/to/file1.ts", "path/to/file2.ts"]
+})}
+`;
+var PlanSchema = exports_external.object({
+  plan: exports_external.string().nullish(),
+  question: exports_external.object({
+    question: exports_external.string(),
+    defaultAnswer: exports_external.string().nullish()
+  }).nullish(),
+  reason: exports_external.string().nullish(),
+  files: exports_external.array(exports_external.string()).nullish()
+});
+// src/workflows/prompts/pr.ts
+var GET_PR_DETAILS_SYSTEM_PROMPT = `Role: Expert developer.
+Goal: Generate a pull request title and description based on the branch name, commits, and diff.
+
+${TOOL_USAGE_INSTRUCTION}
+
+You are an expert at creating pull requests.
+Based on the provided branch name, commit messages, and diff, generate a title and description for the pull request.
+
+${createJsonResponseInstruction({
+  title: "feat: add new feature",
+  description: "This pull request adds a new feature that does...\\n\\n### Changes\\n- ..."
+})}
+`;
+// src/workflows/prompts/review.ts
 var CODE_REVIEW_SYSTEM_PROMPT = `Role: Senior software engineer.
 Goal: Review code changes and provide specific, actionable feedback on any issues found.
 
@@ -79555,96 +79678,6 @@ ${instructions}
   return parts.join(`
 `);
 }
-var COMMIT_MESSAGE_SYSTEM_PROMPT = `Role: Expert git user.
-Goal: Generate a concise and descriptive commit message in conventional commit format based on staged changes.
-
-${TOOL_USAGE_INSTRUCTION}
-
-You are an expert at writing git commit messages.
-Based on the provided list of staged files in <file_status>, the diff in <diff> and optional user context in <tool_input_context>, generate a concise and descriptive commit message.
-
-Follow the conventional commit format.
-
-${createJsonResponseInstruction({
-  commitMessage: "feat: add new feature\\n\\ndescribe the new feature in more detail"
-})}
-`;
-var GET_PR_DETAILS_SYSTEM_PROMPT = `Role: Expert developer.
-Goal: Generate a pull request title and description based on the branch name, commits, and diff.
-
-${TOOL_USAGE_INSTRUCTION}
-
-You are an expert at creating pull requests.
-Based on the provided branch name, commit messages, and diff, generate a title and description for the pull request.
-
-${createJsonResponseInstruction({
-  title: "feat: add new feature",
-  description: "This pull request adds a new feature that does...\\n\\n### Changes\\n- ..."
-})}
-`;
-var INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT = `
-Role: Analyzer agent
-Goal: Produce a valid polkacodes YAML configuration for the project.
-
-${TOOL_USAGE_INSTRUCTION}
-
-Workflow
-1. Scan project files to identify the project's characteristics. Start using the "readFile" tool to understand the project's dependencies, scripts, and basic configuration.
-   - Package/build tool (npm, bun, pnpm, etc.)
-   - Test framework and patterns (snapshot tests, coverage, etc.)
-   - Formatter / linter and their rules
-   - Folder structure and naming conventions.
-   - CI / development workflows (e.g., GitHub Actions in .github/workflows).
-
-2. Build a YAML config with three root keys:
-
-\`\`\`yaml
-scripts:          # derive from package.json and CI workflows. Only include scripts that are relevant for development.
-  format:        # code formatter
-    command: "<formatter cmd>"
-    description: "Format code"
-  check:         # linter / type checker
-    command: "<linter cmd>"
-    description: "Static checks"
-  test:          # test runner
-    command: "<test cmd>"
-    description: "Run tests"
-  # add any other meaningful project scripts like 'build', 'dev', etc.
-
-rules:            # A bullet list of key conventions, frameworks, and libraries used (e.g., "- React", "- TypeScript", "- Jest"). This helps other agents understand the project.
-
-excludeFiles:     # A list of glob patterns for files that should not be read. Only include files that might contain secrets.
-  - ".env"
-  - ".env.*"
-  - "*.pem"
-  - "*.key"
-  - ".npmrc"
-  # do NOT list build artifacts, lockfiles, or paths already in .gitignore
-\`\`\`
-
-3. Return a JSON object with the generated YAML configuration as a string in the 'yaml' property.
-
-${createJsonResponseInstruction({
-  yaml: "<yaml_string>"
-})}
-`;
-var META_SYSTEM_PROMPT = `Role: Meta-agent.
-Goal: Decide which workflow ('code', 'task', or 'epic') to use for a given task.
-
-You are a meta-agent that decides which workflow to use for a given task.
-Based on the user's task, decide whether to use the 'code', 'task', or 'epic' workflow.
-
-- Use the 'code' workflow for tasks that are well-defined and can be implemented directly without a separate planning phase.
-- Use the 'task' workflow for simple, single-action tasks like answering a question or running a command.
-- Use the 'epic' workflow for large, complex features that require breaking down into multiple sequential tasks, creating a feature branch, and executing multiple implementation-commit-review cycles.
-
-The user's task is provided in the <task> tag.
-
-${createJsonResponseInstruction({
-  workflow: "<workflow_name>"
-})}
-`;
-
 // src/workflows/fix.workflow.ts
 var FixIterationSummarySchema = exports_external.object({
   summary: exports_external.string().nullish(),
@@ -79777,35 +79810,45 @@ ${memoryContext}`
 // src/workflows/plan.workflow.ts
 async function createPlan(input2, context) {
   const { tools: tools2, step } = context;
-  const { task, files, plan: inputPlan, userFeedback, interactive } = input2;
-  const currentTask = userFeedback ? `${task}
-
-User feedback: ${userFeedback}` : task;
-  const defaultContext = await getDefaultContext();
-  const memoryContext = await tools2.getMemoryContext();
-  const prompt = `${memoryContext}
-${getPlanPrompt(currentTask, inputPlan)}
+  const { task, files, plan: inputPlan, userFeedback, interactive, messages } = input2;
+  const getMessages = async () => {
+    if (messages) {
+      return {
+        messages,
+        userMessage: [{ role: "user", content: userFeedback ?? task }]
+      };
+    } else {
+      const defaultContext = await getDefaultContext();
+      const memoryContext = await tools2.getMemoryContext();
+      const prompt = `${memoryContext}
+${getPlanPrompt(task, inputPlan)}
 
 ${defaultContext}`;
-  const userContent = [{ type: "text", text: prompt }];
-  if (files) {
-    for (const file2 of files) {
-      if (file2.type === "file") {
-        userContent.push({
-          type: "file",
-          mediaType: file2.mediaType,
-          filename: file2.filename,
-          data: { type: "base64", value: file2.data }
-        });
-      } else if (file2.type === "image") {
-        userContent.push({
-          type: "image",
-          mediaType: file2.mediaType,
-          image: { type: "base64", value: file2.image }
-        });
+      const userContent = [{ type: "text", text: prompt }];
+      if (files) {
+        for (const file2 of files) {
+          if (file2.type === "file") {
+            userContent.push({
+              type: "file",
+              mediaType: file2.mediaType,
+              filename: file2.filename,
+              data: { type: "base64", value: file2.data }
+            });
+          } else if (file2.type === "image") {
+            userContent.push({
+              type: "image",
+              mediaType: file2.mediaType,
+              image: { type: "base64", value: file2.image }
+            });
+          }
+        }
       }
+      return {
+        systemPrompt: PLANNER_SYSTEM_PROMPT,
+        userMessage: [{ role: "user", content: userContent }]
+      };
     }
-  }
+  };
   const agentTools = [
     readFile_default,
     listFiles_default,
@@ -79819,21 +79862,21 @@ ${defaultContext}`;
   if (interactive) {
     agentTools.push(askFollowupQuestion_default);
   }
+  const inputMessages = await getMessages();
   const result = await step("plan", async () => {
     return await agentWorkflow({
-      systemPrompt: PLANNER_SYSTEM_PROMPT,
-      userMessage: [{ role: "user", content: userContent }],
+      ...inputMessages,
       tools: agentTools,
       outputSchema: PlanSchema
     }, context);
   });
   if (result.type === "Exit" && result.object) {
-    const { plan, question, reason, files: filePaths } = result.object;
+    const { plan: plan2, question, reason, files: filePaths } = result.object;
     if (reason) {
-      return { reason };
+      return { reason, messages: result.messages };
     }
     if (question) {
-      return { plan: plan || inputPlan, question };
+      return { plan: plan2 || inputPlan, question, messages: result.messages };
     }
     const outputFiles = [];
     if (filePaths) {
@@ -79844,7 +79887,7 @@ ${defaultContext}`;
         }
       }
     }
-    return { plan: plan || undefined, files: outputFiles };
+    return { plan: plan2 || undefined, files: outputFiles, messages: result.messages };
   }
   context.logger.warn("Failed to generate plan.", result);
   throw new Error("Failed to generate plan.");
@@ -79853,9 +79896,10 @@ var planWorkflow = async (input2, context) => {
   const { tools: tools2, logger, step } = context;
   const { fileContent, filePath, mode = "interactive" } = input2;
   let currentTask = input2.task;
-  let plan = fileContent || "";
+  let plan2 = fileContent || "";
   let files = [];
-  let userFeedback = "";
+  let userFeedback;
+  let messages;
   let state = "Generating";
   let count = 0;
   while (state !== "Done") {
@@ -79863,8 +79907,8 @@ var planWorkflow = async (input2, context) => {
       switch (state) {
         case "Generating": {
           if (!currentTask) {
-            const message = plan ? "How would you like to improve the plan?" : "What is the task you want to plan?";
-            const defaultTask = plan ? "Review and improve the plan" : undefined;
+            const message = plan2 ? "How would you like to improve the plan?" : "What is the task you want to plan?";
+            const defaultTask = plan2 ? "Review and improve the plan" : undefined;
             try {
               currentTask = await tools2.input({
                 message,
@@ -79876,11 +79920,13 @@ var planWorkflow = async (input2, context) => {
           }
           const planResult = await createPlan({
             task: currentTask,
-            plan,
+            plan: plan2,
             userFeedback,
             files: input2.files,
-            interactive: mode === "interactive" || mode === "confirm"
+            interactive: mode === "interactive" || mode === "confirm",
+            messages
           }, context);
+          messages = planResult.messages;
           if (planResult.reason) {
             logger.info(planResult.reason);
             return "Done";
@@ -79891,7 +79937,7 @@ var planWorkflow = async (input2, context) => {
                 message: planResult.question.question,
                 default: planResult.question.defaultAnswer || undefined
               });
-              plan = planResult.plan || plan;
+              plan2 = planResult.plan || plan2;
               return "Generating";
             } catch (error46) {
               if (error46 instanceof UserCancelledError) {
@@ -79900,7 +79946,7 @@ var planWorkflow = async (input2, context) => {
               return "Done";
             }
           }
-          plan = planResult.plan || "";
+          plan2 = planResult.plan || "";
           files = planResult.files || [];
           userFeedback = "";
           return "Reviewing";
@@ -79909,7 +79955,7 @@ var planWorkflow = async (input2, context) => {
           logger.info(`
 Generated Plan:
 `);
-          logger.info(plan);
+          logger.info(plan2);
           if (files?.length > 0) {
             logger.info(`
 Files:`);
@@ -79955,7 +80001,7 @@ Files:`);
                 message: "Where do you want to save the plan?",
                 default: defaultPath
               });
-              await tools2.writeToFile({ path: savePath, content: plan });
+              await tools2.writeToFile({ path: savePath, content: plan2 });
               logger.info(`Plan saved to ${savePath}`);
               return "Done";
             }
@@ -79971,8 +80017,9 @@ Files:`);
               }
             }
             case "regenerate": {
-              plan = "";
+              plan2 = "";
               userFeedback = "";
+              messages = undefined;
               return "Generating";
             }
             case "exit": {
@@ -79987,7 +80034,7 @@ Files:`);
       }
     });
   }
-  return { plan, files };
+  return { plan: plan2, files };
 };
 
 // src/workflows/code.workflow.ts
@@ -80011,11 +80058,11 @@ Phase 1: Creating implementation plan...
     logger.info("Plan not approved. Exiting.");
     return { success: false, reason: "Plan not approved", summaries };
   }
-  const { plan, files: planFiles } = planResult;
+  const { plan: plan2, files: planFiles } = planResult;
   logger.info(`
 Phase 2: Implementing the plan...
 `);
-  let implementPrompt = getImplementPrompt(plan);
+  let implementPrompt = getImplementPrompt(plan2);
   if (planFiles && planFiles.length > 0) {
     const fileContentString = planFiles.map((f) => `<file path="${f.path}">${f.content}</file>`).join(`
 `);
@@ -80540,8 +80587,35 @@ ${provider3.toUpperCase()}_API_KEY=${providerConfig.apiKey}`;
 var MAX_REVIEW_RETRIES = 5;
 var TODO_HANDLING_INSTRUCTIONS = `If you discover that a task is larger than you thought, or that a new task is required, you can add a // TODO comment in the code and create a todo item for it. This will allow you to continue with the current task and address the larger issue later.`;
 async function createPlan2(input2, context) {
-  const { task, plan, files, feedback } = input2;
-  const content = [{ type: "text", text: getPlanPrompt(task, plan) }];
+  const { task, plan: plan2, files, feedback, messages } = input2;
+  const { tools: tools2 } = context;
+  const agentTools = [
+    askFollowupQuestion_default,
+    fetchUrl_default,
+    listFiles_default,
+    readFile_default,
+    readBinaryFile_default,
+    searchFiles_default,
+    readMemory_default,
+    updateMemory_default,
+    listMemoryTopics_default
+  ];
+  if (messages) {
+    const userMessage2 = feedback ? [{ role: "user", content: feedback }] : [];
+    return await agentWorkflow({
+      messages,
+      userMessage: userMessage2,
+      tools: agentTools,
+      outputSchema: EpicPlanSchema
+    }, context);
+  }
+  const defaultContext = await getDefaultContext();
+  const memoryContext = await tools2.getMemoryContext();
+  const prompt = `${memoryContext}
+${getPlanPrompt(task, plan2)}
+
+${defaultContext}`;
+  const content = [{ type: "text", text: prompt }];
   if (files) {
     for (const file2 of files) {
       if (file2.type === "file") {
@@ -80560,33 +80634,13 @@ async function createPlan2(input2, context) {
       }
     }
   }
-  if (feedback) {
-    content.push({
-      type: "text",
-      text: `The user has provided the following feedback on the plan, please adjust it:
-${feedback}`
-    });
-  }
-  const planResult = await agentWorkflow({
+  const userMessage = [{ role: "user", content }];
+  return await agentWorkflow({
     systemPrompt: EPIC_PLANNER_SYSTEM_PROMPT,
-    userMessage: [{ role: "user", content }],
-    tools: [
-      askFollowupQuestion_default,
-      fetchUrl_default,
-      listFiles_default,
-      readFile_default,
-      readBinaryFile_default,
-      searchFiles_default,
-      readMemory_default,
-      updateMemory_default,
-      listMemoryTopics_default
-    ],
+    userMessage,
+    tools: agentTools,
     outputSchema: EpicPlanSchema
   }, context);
-  if (planResult.type === "Exit") {
-    return planResult.object;
-  }
-  return { type: "error", reason: "Usage limit exceeded." };
 }
 async function createAndApprovePlan(task, context) {
   const { logger, step, tools: tools2 } = context;
@@ -80594,10 +80648,17 @@ async function createAndApprovePlan(task, context) {
 `);
   let feedback;
   let planAttempt = 1;
+  let messages;
   try {
     while (true) {
-      const result = await step(`plan-${planAttempt}`, () => createPlan2({ task, feedback }, context));
+      const planAgentResult = await step(`plan-${planAttempt}`, () => createPlan2({ task, feedback, messages }, context));
+      messages = planAgentResult.messages;
       planAttempt++;
+      if (planAgentResult.type !== "Exit" /* Exit */) {
+        logger.error(`Plan creation failed. Agent exited with status: ${planAgentResult.type}`);
+        return null;
+      }
+      const result = planAgentResult.object;
       switch (result.type) {
         case "plan-generated": {
           if (!result.plan || !result.branchName) {
@@ -80691,7 +80752,7 @@ async function createFeatureBranch(branchName, baseBranch, context) {
   logger.error(`Error: Failed to create or switch to a feature branch after ${MAX_ATTEMPTS} attempts.`);
   return { success: false, branchName: null };
 }
-async function addTodoItemsFromPlan(plan, context) {
+async function addTodoItemsFromPlan(plan2, context) {
   const { logger, step, tools: tools2 } = context;
   logger.info(`Phase 4: Creating todo items from plan...
 `);
@@ -80700,7 +80761,7 @@ async function addTodoItemsFromPlan(plan, context) {
       systemPrompt: EPIC_ADD_TODO_ITEMS_SYSTEM_PROMPT,
       userMessage: [{ role: "user", content: `Please create the todo items based on the plan
 <plan>
-${plan}</plan>` }],
+${plan2}</plan>` }],
       tools: [readFile_default, searchFiles_default, listFiles_default, readMemory_default, getTodoItem_default, listTodoItems_default, updateTodoItem_default, updateMemory_default, listMemoryTopics_default]
     }, context);
   });
@@ -80750,7 +80811,7 @@ async function performReviewAndFixCycle(iterationCount, taskItem, highLevelPlan,
   const { logger, step, tools: tools2 } = context;
   for (let i = 0;i < MAX_REVIEW_RETRIES; i++) {
     const diffResult = await tools2.executeCommand({ command: "git", args: ["diff", "--name-status", "HEAD~1", "HEAD"] });
-    const changedFiles = parseGitDiffNameStatus(diffResult.stdout);
+    const changedFiles = parseGitDiffNameStatus(diffResult.stdout).filter(({ path }) => path !== ".epic.yml");
     if (changedFiles.length === 0) {
       logger.info(`No files were changed. Skipping review.
 `);
@@ -80789,8 +80850,8 @@ ${formatReviewToolInput(changeInfo)}`;
     }
     logger.warn(`Warning: Review found ${reviewResult.specificReviews.length} issue(s). Attempting to fix...
 `);
-    for (const [idx, review] of reviewResult.specificReviews.entries()) {
-      logger.warn(`   ${idx + 1}. ${review.file}:${review.lines}`);
+    for (const [idx, review2] of reviewResult.specificReviews.entries()) {
+      logger.warn(`   ${idx + 1}. ${review2.file}:${review2.lines}`);
     }
     logger.warn("");
     const reviewSummary = reviewResult.specificReviews.map((r) => `File: ${r.file} (lines: ${r.lines})
@@ -80828,6 +80889,20 @@ Max retries (${MAX_REVIEW_RETRIES}) reached. Moving to the next task, but issues
   }
   return { passed: false };
 }
+async function findNextTask(tools2) {
+  const openRootTasks = await tools2.listTodoItems({ status: "open" });
+  if (openRootTasks.length === 0) {
+    return null;
+  }
+  let currentTask = openRootTasks[0];
+  while (true) {
+    const subTasks = await tools2.listTodoItems({ status: "open", id: currentTask.id });
+    if (subTasks.length === 0) {
+      return currentTask;
+    }
+    currentTask = subTasks[0];
+  }
+}
 async function runImplementationLoop(context, highLevelPlan) {
   const { logger, step, tools: tools2 } = context;
   const commitMessages = [];
@@ -80836,22 +80911,11 @@ async function runImplementationLoop(context, highLevelPlan) {
   logger.info(`${"=".repeat(80)}
 `);
   let iterationCount = 0;
-  let isComplete = false;
-  let nextTask = null;
-  let nextTaskId = null;
-  const initialTasks = await step("get-initial-tasks", async () => {
-    return await tools2.listTodoItems({ status: "open" });
-  });
-  if (initialTasks.length > 0) {
-    const firstTask = initialTasks[0];
-    nextTask = firstTask.title;
-    nextTaskId = firstTask.id;
-  } else {
-    isComplete = true;
-  }
-  while (!isComplete && nextTask && nextTaskId) {
+  let nextTaskItem = await step("get-initial-task", () => findNextTask(tools2));
+  while (nextTaskItem) {
     iterationCount++;
     const taskStartTime = Date.now();
+    const { title: nextTask, id: nextTaskId } = nextTaskItem;
     logger.info(`
 ${"-".repeat(80)}`);
     logger.info(`Iteration ${iterationCount}`);
@@ -80891,24 +80955,9 @@ Focus only on this item, but use the plan for context.`;
       logger.warn(`Warning: Iteration ${iterationCount} completed with potential issues (${taskElapsedTime})`);
     }
     await step(`update-task-status-${iterationCount}`, async () => {
-      if (!nextTaskId) {
-        throw new Error("Invariant violation: nextTaskId is null inside the implementation loop.");
-      }
       await tools2.updateTodoItem({ operation: "update", id: nextTaskId, status: "completed" });
     });
-    const openTasks = await step(`get-next-task-${iterationCount}`, async () => {
-      return await tools2.listTodoItems({ status: "open" });
-    });
-    if (openTasks.length > 0) {
-      const nextTodo = openTasks[0];
-      nextTask = nextTodo.title;
-      nextTaskId = nextTodo.id;
-      isComplete = false;
-    } else {
-      nextTask = null;
-      nextTaskId = null;
-      isComplete = true;
-    }
+    nextTaskItem = await step(`get-next-task-${iterationCount}`, () => findNextTask(tools2));
     const allTodos = await tools2.listTodoItems({});
     const completedTodos = allTodos.filter((t) => t.status === "completed").length;
     const totalTodos = allTodos.length;
@@ -80920,13 +80969,13 @@ Focus only on this item, but use the plan for context.`;
     }
     logger.info(`
 Progress: ${progressMessage}`);
-    if (isComplete) {
+    if (!nextTaskItem) {
       logger.info(`All tasks complete!
 `);
       break;
     }
-    if (nextTask) {
-      logger.info(`Next task: ${nextTask}
+    if (nextTaskItem) {
+      logger.info(`Next task: ${nextTaskItem.title}
 `);
     }
     logger.info(`${"-".repeat(80)}
@@ -80952,7 +81001,7 @@ Phase 6: Final Review and Fixup...
   const commitRange = `${baseBranch}...${currentBranch}`;
   for (let i = 0;i < MAX_REVIEW_RETRIES; i++) {
     const diffResult = await tools2.executeCommand({ command: "git", args: ["diff", "--name-status", commitRange] });
-    const changedFiles = parseGitDiffNameStatus(diffResult.stdout);
+    const changedFiles = parseGitDiffNameStatus(diffResult.stdout).filter(({ path }) => path !== ".epic.yml");
     if (changedFiles.length === 0) {
       logger.info(`No files have been changed in this branch. Skipping final review.
 `);
@@ -80991,8 +81040,8 @@ ${formatReviewToolInput(changeInfo)}`;
     }
     logger.warn(`Warning: Final review found ${reviewResult.specificReviews.length} issue(s). Attempting to fix...
 `);
-    for (const [idx, review] of reviewResult.specificReviews.entries()) {
-      logger.warn(`   ${idx + 1}. ${review.file}:${review.lines}`);
+    for (const [idx, review2] of reviewResult.specificReviews.entries()) {
+      logger.warn(`   ${idx + 1}. ${review2.file}:${review2.lines}`);
     }
     logger.warn("");
     const reviewSummary = reviewResult.specificReviews.map((r) => `File: ${r.file} (lines: ${r.lines})
@@ -81102,6 +81151,37 @@ Summary:`);
     for (const [idx, msg] of commitMessages.entries()) {
       logger.info(`   ${idx + 1}. ${msg}`);
     }
+    if (input2.usages && input2.usages.length > 0) {
+      const sortedUsages = [...input2.usages].sort((a, b) => a.timestamp - b.timestamp);
+      let lastUsage = {
+        input: 0,
+        output: 0,
+        cachedRead: 0,
+        cost: 0,
+        messageCount: 0
+      };
+      logger.info(`
+Usage Breakdown:`);
+      sortedUsages.forEach((usage, index) => {
+        const delta = {
+          input: usage.input - lastUsage.input,
+          output: usage.output - lastUsage.output,
+          cachedRead: usage.cachedRead - lastUsage.cachedRead,
+          cost: usage.cost - lastUsage.cost,
+          messageCount: usage.messageCount - lastUsage.messageCount
+        };
+        const tempMeter = new UsageMeter;
+        tempMeter.setUsage(delta);
+        logger.info(`   Step ${index + 1}: ${tempMeter.getUsageText()}`);
+        lastUsage = usage;
+      });
+      const last = sortedUsages.at(-1);
+      if (last) {
+        const totalMeter = new UsageMeter;
+        totalMeter.setUsage(last);
+        logger.info(`   Total: ${totalMeter.getUsageText()}`);
+      }
+    }
   } catch (error46) {
     logger.error(`
 Epic workflow failed: ${error46 instanceof Error ? error46.message : String(error46)}`);
@@ -81256,10 +81336,10 @@ var prWorkflow = async (input2, context) => {
 // src/workflows/review.workflow.ts
 var reviewWorkflow = async (input2, context) => {
   const { step, tools: tools2, logger } = context;
-  const { pr } = input2;
+  const { pr: pr2 } = input2;
   let changeInfo;
-  if (pr) {
-    const prNumberMatch = pr.match(/\d+$/);
+  if (pr2) {
+    const prNumberMatch = pr2.match(/\d+$/);
     if (!prNumberMatch) {
       throw new Error("Invalid PR number or URL.");
     }
@@ -81403,13 +81483,22 @@ var commitCommand = new Command("commit").description("Create a commit with AI-g
 // src/workflows/epic-context.ts
 import { promises as fs3 } from "node:fs";
 var EPIC_CONTEXT_FILE = ".epic.yml";
+var EpicUsageSchema = exports_external.object({
+  timestamp: exports_external.number(),
+  input: exports_external.number(),
+  output: exports_external.number(),
+  cachedRead: exports_external.number(),
+  cost: exports_external.number(),
+  messageCount: exports_external.number()
+});
 var EpicContextSchema = exports_external.object({
   task: exports_external.string().nullish(),
   plan: exports_external.string().nullish(),
   branchName: exports_external.string().nullish(),
   baseBranch: exports_external.string().nullish(),
   todos: exports_external.array(TodoItemSchema).nullish(),
-  memory: exports_external.record(exports_external.string(), exports_external.string()).nullish()
+  memory: exports_external.record(exports_external.string(), exports_external.string()).nullish(),
+  usages: exports_external.array(EpicUsageSchema).nullish()
 });
 var saveEpicContext = async (context) => {
   const yamlString = $stringify({
@@ -81418,7 +81507,8 @@ var saveEpicContext = async (context) => {
     branchName: context.branchName,
     baseBranch: context.baseBranch,
     todos: context.todos,
-    memory: context.memory
+    memory: context.memory,
+    usages: context.usages
   });
   await fs3.writeFile(EPIC_CONTEXT_FILE, yamlString, "utf-8");
 };
@@ -81492,10 +81582,26 @@ async function runEpic(task2, _options, command) {
     }
     epicContext.task = taskInput;
   }
+  let usageAppended = false;
   const workflowInput = {
     ...epicContext,
-    saveEpicContext
+    async saveEpicContext(context) {
+      if (usageMeter) {
+        const currentUsage = usageMeter.usage;
+        if (!context.usages) {
+          context.usages = [];
+        }
+        if (!usageAppended) {
+          context.usages.push({ ...currentUsage, timestamp: Date.now() });
+          usageAppended = true;
+        } else {
+          context.usages[context.usages.length - 1] = { ...currentUsage, timestamp: Date.now() };
+        }
+      }
+      await saveEpicContext(context);
+    }
   };
+  let usageMeter;
   await runWorkflow(epicWorkflow, workflowInput, {
     commandName: "epic",
     command,
@@ -81505,7 +81611,10 @@ async function runEpic(task2, _options, command) {
       ...opt,
       todoItemStore: new EpicTodoItemStore(workflowInput),
       memoryStore: new EpicMemoryStore(workflowInput)
-    })
+    }),
+    onUsageMeterCreated: (meter) => {
+      usageMeter = meter;
+    }
   });
 }
 var epicCommand = new Command("epic").description("Orchestrates a large feature or epic, breaking it down into smaller tasks.").argument("[task]", "The epic to plan and implement.").action(runEpic);
@@ -81636,7 +81745,7 @@ var reviewCommand = new Command("review").description("Review a GitHub pull requ
   }
   return parsedValue;
 }, 1).action(async (options, command) => {
-  const { json: json2, pr: pr2, loop: maxIterations, yes: yesOption } = options;
+  const { json: json2, pr: pr3, loop: maxIterations, yes: yesOption } = options;
   const yes = maxIterations > 1 || yesOption;
   let changesAppliedInThisIteration = false;
   const globalOpts = (command.parent ?? command).opts();
@@ -81646,7 +81755,7 @@ var reviewCommand = new Command("review").description("Review a GitHub pull requ
   });
   for (let i = 0;i < maxIterations; i++) {
     changesAppliedInThisIteration = false;
-    const input2 = { pr: pr2 };
+    const input2 = { pr: pr3 };
     if (i > 0) {
       logger.debug(`Re-running review (iteration ${i + 1} of ${maxIterations})...`);
     }