@polka-codes/cli 0.9.85 → 0.9.86

package/dist/index.js

@@ -39615,8 +39615,18 @@ var init_dynamic_types = __esm(() => {
 // ../core/src/workflow/dynamic.ts
 function convertJsonSchemaToZod(schema) {
   if (schema.enum) {
-    const enumValues = schema.enum.map((v) => String(v));
-    return exports_external.enum(enumValues);
+    const enumValues = schema.enum;
+    if (enumValues.length === 0) {
+      return exports_external.never();
+    }
+    if (enumValues.every((v) => typeof v === "string")) {
+      return exports_external.enum(enumValues);
+    }
+    const literals = enumValues.map((v) => exports_external.literal(v));
+    if (literals.length === 1) {
+      return literals[0];
+    }
+    return exports_external.union([literals[0], literals[1], ...literals.slice(2)]);
   }
   if (Array.isArray(schema.type)) {
     const types3 = schema.type;
@@ -39786,8 +39796,11 @@ ${errors4.map((e) => `  - ${e}`).join(`
   }
   return validatedInput;
 }
-function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false) {
+function evaluateCondition(condition, input, state, allowUnsafeCodeExecution = false, logger) {
   if (allowUnsafeCodeExecution) {
+    if (logger) {
+      logger.warn(`[SECURITY] Executing unsafe code evaluation for condition: ${condition}. This allows arbitrary JavaScript execution and should only be used for trusted workflows.`);
+    }
     const functionBody = `
       try {
         return ${condition};
@@ -73990,344 +74003,6 @@ ${createJsonResponseInstruction({
 `;
 });
 
-// src/workflows/prompts/epic.ts
-var EPIC_PLANNER_SYSTEM_PROMPT, BRANCH_NAME_PATTERN, EpicPlanSchema, EPIC_ADD_TODO_ITEMS_SYSTEM_PROMPT;
-var init_epic = __esm(() => {
-  init_zod();
-  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)
-`;
-  BRANCH_NAME_PATTERN = /^[a-zA-Z0-9/_-]+$/;
-  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((name17) => BRANCH_NAME_PATTERN.test(name17), {
-      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;
-      }
-    }
-  });
-  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
 function getFixUserPrompt(command, exitCode, stdout, stderr, task, prompt) {
   const taskSection = task ? `
@@ -74438,14 +74113,13 @@ ${createJsonResponseInstruction({
 var META_SYSTEM_PROMPT;
 var init_meta = __esm(() => {
   META_SYSTEM_PROMPT = `Role: Meta-agent.
-Goal: Decide which workflow ('code', 'task', or 'epic') to use for a given task.
+Goal: Decide which workflow ('code' or 'task') 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.
+Based on the user's task, decide whether to use the 'code' or 'task' 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.
 
@@ -74697,6 +74371,9 @@ ${value}
 </${tag}>`;
 }
 function getReviewInstructions(params) {
+  if (params.targetCommit) {
+    return `Review the changes in commit '${params.targetCommit}'. The gitDiff tool is NOT available for past commits. Use readFile to inspect the file contents and identify issues in the modified files listed in <file_status>.`;
+  }
   if (params.commitRange) {
     return `Review the pull request. Use the gitDiff tool with commit range '${params.commitRange}' to inspect the actual code changes.`;
   }
@@ -74720,6 +74397,7 @@ function formatReviewToolInput(params) {
     formatContext("pr_title", params.pullRequestTitle),
     formatContext("pr_description", params.pullRequestDescription),
     formatContext("commit_messages", params.commitMessages),
+    formatContext("target_commit", params.targetCommit),
     formatContext("user_context", params.context),
     formatContext("file_status", fileList),
     formatContext("review_instructions", getReviewInstructions(params))
@@ -74740,17 +74418,19 @@ ${TOOL_USAGE_INSTRUCTION}
 2.  **Select Files for Diff**: From the modified files, select only the reviewable source and configuration files.
     -   **Include**: Source code, config files, and template files.
     -   **Exclude**: Lockfiles, build artifacts, test snapshots, binary/media files, data and fixtures and other generated files.
-3.  **Inspect Changes**: Use the \`gitDiff\` tool on one file at a time to see the exact changes. When reviewing pull requests, use the \`commitRange\` parameter provided in the review instructions.
-4.  **Analyze and Review**: Analyze only the modified lines (additions/deletions) for issues. Provide specific, actionable feedback with accurate line numbers.
+3.  **Inspect Changes**:
+    -   When the \`gitDiff\` tool is available: Use it on one file at a time to see the exact changes. When reviewing pull requests, use the \`commitRange\` parameter provided in the review instructions.
+    -   When the \`gitDiff\` tool is NOT available (reviewing past commits): Use \`readFile\` to inspect the file contents. You will not have access to the exact diff, so focus on reviewing the code for issues in the modified files listed in \`<file_status>\`.
+4.  **Analyze and Review**: Analyze the code for issues. When using \`gitDiff\`, focus only on the modified lines (additions/deletions). Provide specific, actionable feedback with accurate line numbers.
 
 ## Critical Rules
 
--   **Focus on Changes**: ONLY review the actual changes shown in the diff. Do not comment on existing, unmodified code.
+-   **Focus on Changes**: When using \`gitDiff\`, ONLY review the actual changes shown in the diff. Do not comment on existing, unmodified code. When \`gitDiff\` is not available, focus on the modified files listed in \`<file_status>\`.
 -   **Focus Scope**: Do not comment on overall project structure or architecture unless directly impacted by the changes in the diff.
 -   **No Feature Requests**: Do not comment on missing features or functionality that are not part of this diff.
--   **One File at a Time**: Review files individually using \`gitDiff\` with the specific file path.
--   **No Empty Diffs**: MUST NOT call \`gitDiff\` with an empty or omitted file parameter.
--   **Accurate Line Numbers**: Use the line numbers from the diff annotations (\`[Line N]\` for additions, \`[Line N removed]\` for deletions).
+-   **One File at a Time**: Review files individually using \`gitDiff\` (when available) with the specific file path, or \`readFile\` when reviewing past commits.
+-   **No Empty Diffs**: MUST NOT call \`gitDiff\` with an empty or omitted file parameter when the tool is available.
+-   **Accurate Line Numbers**: When using \`gitDiff\`, use the line numbers from the diff annotations (\`[Line N]\` for additions, \`[Line N removed]\` for deletions). When \`gitDiff\` is not available, use line numbers from \`readFile\` output.
 -   **No Praise**: Provide only reviews for actual issues found. Do not include praise or positive feedback.
 -   **Clear Reasoning**: For each issue, provide clear reasoning explaining why it's a problem and what the impact could be.
 -   **Specific Advice**: Avoid generic advice. Provide concrete, actionable suggestions specific to the code being reviewed.
@@ -74762,6 +74442,7 @@ You may receive the following context:
 -   \`<user_context>\`: Specific review focus from the user
 -   \`<file_status>\`: List of modified files with their status
 -   \`<review_instructions>\`: Specific instructions for this review
+-   \`<target_commit>\`: The specific commit being reviewed (when reviewing past commits)
 
 ## Output Format
 
@@ -74824,7 +74505,6 @@ ${createJsonResponseInstruction({
 var init_prompts2 = __esm(() => {
   init_coder();
   init_commit();
-  init_epic();
   init_fix();
   init_init();
   init_meta();
@@ -88283,20 +87963,6 @@ ${item.review}
   }
   return formatted;
 }
-function formatElapsedTime(ms) {
-  const seconds = ms / 1000;
-  if (seconds < 60) {
-    return `${seconds.toFixed(1)}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = Math.floor(seconds % 60);
-  if (minutes < 60) {
-    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
-  }
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-}
 async function getDefaultContext(commandName) {
   const config4 = await loadConfig2();
   const cwd = process.cwd();
@@ -89493,6 +89159,219 @@ var init_tools3 = __esm(() => {
   init_updateTodoItem();
 });
 
+// src/utils/shell.ts
+function isWindows() {
+  return process.platform === "win32";
+}
+function quoteForShell(str) {
+  if (isWindows()) {
+    const escaped = str.replace(/"/g, '""');
+    return `"${escaped}"`;
+  } else {
+    return `'${str.replace(/'/g, "'\\''")}'`;
+  }
+}
+
+// src/workflows/git-file-tools.ts
+function extractTargetCommit(range, pr2) {
+  if (pr2) {
+    return null;
+  }
+  if (!range) {
+    return null;
+  }
+  const parts = range.split(/\.\.\.?/);
+  if (parts.length > 1) {
+    return parts[1].trim() || null;
+  }
+  return range.trim() || null;
+}
+function createGitReadFile(commit2) {
+  const toolInfo20 = {
+    name: "readFile",
+    description: `Read file contents from git commit ${commit2}. Use this to examine files at the specific commit being reviewed.`,
+    parameters: exports_external.object({
+      path: exports_external.preprocess((val) => {
+        if (!val)
+          return [];
+        const values = Array.isArray(val) ? val : [val];
+        return values.flatMap((i2) => typeof i2 === "string" ? i2.split(",") : []).filter((s2) => s2.length > 0);
+      }, exports_external.array(exports_external.string())).describe("The path of the file to read (relative to git root)").meta({ usageValue: "Comma separated paths here" })
+    }).meta({
+      examples: [
+        {
+          description: "Read the contents of a file at the commit",
+          input: {
+            path: "src/main.ts"
+          }
+        }
+      ]
+    })
+  };
+  const handler20 = async (provider3, args) => {
+    if (!provider3.executeCommand) {
+      return {
+        success: false,
+        message: {
+          type: "error-text",
+          value: "Not possible to execute command."
+        }
+      };
+    }
+    const { path: paths } = toolInfo20.parameters.parse(args);
+    const results = [];
+    for (const filePath of paths) {
+      const quotedCommit = quoteForShell(commit2);
+      const quotedPath = quoteForShell(filePath);
+      const result = await provider3.executeCommand(`git show ${quotedCommit}:${quotedPath}`, false);
+      if (result.exitCode === 0) {
+        results.push(`<read_file_file_content path="${filePath}">${result.stdout}</read_file_file_content>`);
+      } else {
+        results.push(`<read_file_file_content path="${filePath}" file_not_found="true"></read_file_file_content>`);
+      }
+    }
+    return {
+      success: true,
+      message: {
+        type: "text",
+        value: results.join(`
+`)
+      }
+    };
+  };
+  return {
+    ...toolInfo20,
+    handler: handler20
+  };
+}
+function createGitListFiles(commit2) {
+  const toolInfo20 = {
+    name: "listFiles",
+    description: `List files and directories at git commit ${commit2}. Shows the file tree as it existed at that commit.`,
+    parameters: exports_external.object({
+      path: exports_external.string().optional().describe("The path of the directory to list (relative to git root). Default is root.").meta({ usageValue: "Directory path here (optional)" }),
+      maxCount: exports_external.coerce.number().optional().default(2000).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" })
+    })
+  };
+  const handler20 = async (provider3, args) => {
+    if (!provider3.executeCommand) {
+      return {
+        success: false,
+        message: {
+          type: "error-text",
+          value: "Not possible to execute command."
+        }
+      };
+    }
+    const parsed = toolInfo20.parameters.parse(args);
+    const path2 = parsed.path || ".";
+    const quotedCommit = quoteForShell(commit2);
+    const quotedPath = quoteForShell(path2);
+    const result = await provider3.executeCommand(`git ls-tree -r --name-only ${quotedCommit} ${quotedPath}`, false);
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        message: {
+          type: "error-text",
+          value: `Failed to list files at commit ${commit2}: ${result.stderr}`
+        }
+      };
+    }
+    const files = result.stdout.trim().split(`
+`).filter((f3) => f3.length > 0);
+    const truncated = files.length > parsed.maxCount;
+    const displayFiles = truncated ? files.slice(0, parsed.maxCount) : files;
+    return {
+      success: true,
+      message: {
+        type: "text",
+        value: `<list_files_path>${path2}</list_files_path>
+<list_files_files>
+${displayFiles.join(`
+`)}
+</list_files_files>
+<list_files_truncated>${truncated}</list_files_truncated>`
+      }
+    };
+  };
+  return {
+    ...toolInfo20,
+    handler: handler20
+  };
+}
+function createGitReadBinaryFile(commit2) {
+  const toolInfo20 = {
+    name: "readBinaryFile",
+    description: `Read binary file contents from git commit ${commit2} and return as base64 encoded data. Use for images, fonts, and other binary files.`,
+    parameters: exports_external.object({
+      url: exports_external.string().describe("The URL or path of the binary file to read (relative to git root)")
+    })
+  };
+  const handler20 = async (provider3, args) => {
+    if (!provider3.executeCommand) {
+      return {
+        success: false,
+        message: {
+          type: "error-text",
+          value: "Not possible to execute command."
+        }
+      };
+    }
+    const { url: url2 } = toolInfo20.parameters.parse(args);
+    const quotedCommit = quoteForShell(commit2);
+    const quotedUrl = quoteForShell(url2);
+    const checkResult = await provider3.executeCommand(`git cat-file -e ${quotedCommit}:${quotedUrl}`, false);
+    if (checkResult.exitCode !== 0) {
+      return {
+        success: true,
+        message: {
+          type: "text",
+          value: `<read_binary_file_file_content url="${url2}" file_not_found="true"></read_binary_file_file_content>`
+        }
+      };
+    }
+    const result = await provider3.executeCommand(`git show ${quotedCommit}:${quotedUrl} | base64`, false);
+    if (result.exitCode === 0) {
+      const base64Data = result.stdout.replace(/\n/g, "");
+      return {
+        success: true,
+        message: {
+          type: "content",
+          value: [
+            {
+              type: "media",
+              url: url2,
+              data: base64Data
+            }
+          ]
+        }
+      };
+    } else {
+      return {
+        success: false,
+        message: {
+          type: "error-text",
+          value: `Failed to read binary file: ${result.stderr}`
+        }
+      };
+    }
+  };
+  return {
+    ...toolInfo20,
+    handler: handler20
+  };
+}
+function createGitAwareTools(commit2) {
+  return {
+    readFile: createGitReadFile(commit2),
+    listFiles: createGitListFiles(commit2),
+    readBinaryFile: createGitReadBinaryFile(commit2)
+  };
+}
+var init_git_file_tools = __esm(() => {
+  init_zod();
+});
+
 // src/workflows/review.workflow.ts
 var exports_review_workflow = {};
 __export(exports_review_workflow, {
@@ -89749,7 +89628,11 @@ var reviewWorkflow = async (input, context) => {
   if (!changeInfo) {
     return { overview: "No changes to review.", specificReviews: [] };
   }
-  const finalChangeInfo = changeInfo;
+  const targetCommit = extractTargetCommit(range, pr2);
+  const isReviewingCommit = targetCommit !== null;
+  const finalChangeInfo = targetCommit ? { ...changeInfo, targetCommit } : changeInfo;
+  const fileTools = isReviewingCommit && targetCommit ? createGitAwareTools(targetCommit) : { readFile: readFile_default, listFiles: listFiles_default, readBinaryFile: readBinaryFile_default };
+  const reviewTools = isReviewingCommit ? [fileTools.readFile, fileTools.readBinaryFile, fileTools.listFiles] : [readFile_default, readBinaryFile_default, searchFiles_default, listFiles_default, gitDiff_default];
   const result = await step("review", async () => {
     const defaultContext = await getDefaultContext("review");
     const memoryContext = await tools3.getMemoryContext();
@@ -89766,7 +89649,7 @@ ${memoryContext}`;
           content: fullContent
         }
       ],
-      tools: [readFile_default, readBinaryFile_default, searchFiles_default, listFiles_default, gitDiff_default],
+      tools: reviewTools,
       outputSchema: reviewOutputSchema
     }, context);
   });
@@ -89782,6 +89665,7 @@ ${memoryContext}`;
 var init_review_workflow = __esm(() => {
   init_src();
   init_tools3();
+  init_git_file_tools();
   init_prompts2();
   init_workflow_utils();
 });
@@ -89796,10 +89680,24 @@ var commitWorkflow = async (input, context) => {
   const { stagedFiles, unstagedFiles } = await tools3.printChangeFile();
   let hasStaged = stagedFiles.length > 0;
   const hasUnstaged = unstagedFiles.length > 0;
-  if (!hasStaged) {
+  if (input.files && input.files.length > 0) {
+    await step("stage-files", async () => {
+      const result2 = await tools3.executeCommand({
+        command: "git",
+        args: ["add", ...input.files]
+      });
+      if (result2.exitCode !== 0) {
+        throw new Error(`Failed to stage files: ${result2.stderr}`);
+      }
+    });
+    hasStaged = true;
+  } else if (!hasStaged) {
     if (input.all) {
       await step("stage-all", async () => {
-        await tools3.executeCommand({ command: "git", args: ["add", "."] });
+        const result2 = await tools3.executeCommand({ command: "git", args: ["add", "."] });
+        if (result2.exitCode !== 0) {
+          throw new Error(`Failed to stage files: ${result2.stderr}`);
+        }
       });
       hasStaged = true;
     } else if (hasUnstaged) {
@@ -89812,10 +89710,13 @@ var commitWorkflow = async (input, context) => {
       }
       if (confirmed) {
         await step("stage-all", async () => {
-          await tools3.executeCommand({
+          const result2 = await tools3.executeCommand({
             command: "git",
             args: ["add", "."]
           });
+          if (result2.exitCode !== 0) {
+            throw new Error(`Failed to stage files: ${result2.stderr}`);
+          }
         });
         hasStaged = true;
       } else if (input.interactive !== false) {
@@ -89891,663 +89792,6 @@ var init_commit_workflow = __esm(() => {
   init_workflow_utils();
 });
 
-// src/workflows/epic.workflow.ts
-var exports_epic_workflow = {};
-__export(exports_epic_workflow, {
-  epicWorkflow: () => epicWorkflow
-});
-async function createPlan2(input, context) {
-  const { task, plan: plan2, files, feedback, messages, additionalTools } = input;
-  const { tools: tools3 } = context;
-  const agentTools = [
-    askFollowupQuestion_default,
-    fetchUrl_default,
-    listFiles_default,
-    readFile_default,
-    readBinaryFile_default,
-    searchFiles_default,
-    readMemory_default,
-    updateMemory_default,
-    listMemoryTopics_default
-  ];
-  if (additionalTools.search) {
-    agentTools.push(additionalTools.search);
-  }
-  if (messages) {
-    const userMessage2 = feedback ? [{ role: "user", content: feedback }] : [];
-    return await agentWorkflow({
-      messages,
-      userMessage: userMessage2,
-      tools: agentTools,
-      outputSchema: EpicPlanSchema
-    }, context);
-  }
-  const defaultContext = await getDefaultContext("epic");
-  const memoryContext = await tools3.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") {
-        content.push({
-          type: "file",
-          mediaType: file2.mediaType,
-          filename: file2.filename,
-          data: { type: "base64", value: file2.data }
-        });
-      } else if (file2.type === "image") {
-        content.push({
-          type: "image",
-          mediaType: file2.mediaType,
-          image: { type: "base64", value: file2.image }
-        });
-      }
-    }
-  }
-  const userMessage = [{ role: "user", content }];
-  return await agentWorkflow({
-    systemPrompt: EPIC_PLANNER_SYSTEM_PROMPT,
-    userMessage,
-    tools: agentTools,
-    outputSchema: EpicPlanSchema
-  }, context);
-}
-async function createAndApprovePlan(task, context, saveUsageSnapshot, interactive = true, additionalTools) {
-  const { logger, step, tools: tools3 } = context;
-  logger.info(`Phase 2: Creating high-level plan...
-`);
-  let feedback;
-  let planAttempt = 1;
-  let messages;
-  try {
-    while (true) {
-      const planAgentResult = await step(`plan-${planAttempt}`, () => createPlan2({ task, feedback, messages, additionalTools }, context));
-      messages = planAgentResult.messages;
-      planAttempt++;
-      if (planAgentResult.type !== "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) {
-            logger.error("Invalid plan-generated response. Missing plan or branchName.");
-            return null;
-          }
-          logger.info(`Plan:
-${result.plan}`);
-          logger.info(`Suggested branch name: ${result.branchName}`);
-          if (!interactive) {
-            logger.info("Non-interactive mode: Auto-approving plan.");
-            await saveUsageSnapshot();
-            return { plan: result.plan, branchName: result.branchName };
-          }
-          feedback = await tools3.input({ message: "Press Enter to approve the plan, or provide feedback to refine it." });
-          if (feedback.trim() === "") {
-            logger.info(`High-level plan approved.
-`);
-            await saveUsageSnapshot();
-            return { plan: result.plan, branchName: result.branchName };
-          }
-          break;
-        }
-        case "question": {
-          if (!result.question) {
-            logger.error("Invalid question response. Missing question object.");
-            return null;
-          }
-          const answer = await tools3.input({
-            message: result.question.question,
-            default: result.question.defaultAnswer || undefined
-          });
-          feedback = `The user answered the question "${result.question.question}" with: "${answer}"`;
-          break;
-        }
-        case "error": {
-          logger.info(`Plan creation failed. Reason: ${result.reason || "Unknown error"}`);
-          return null;
-        }
-        default: {
-          logger.error(`Unknown response type from planner`);
-          return null;
-        }
-      }
-    }
-  } catch (e2) {
-    if (e2 instanceof UserCancelledError) {
-      logger.info("Plan creation cancelled by user.");
-      return null;
-    }
-    throw e2;
-  }
-}
-async function createFeatureBranch(branchName, baseBranch, context) {
-  const { logger, step, tools: tools3 } = context;
-  const MAX_ATTEMPTS = 10;
-  let currentBranchName = branchName;
-  logger.info(`Phase 3: Creating/switching to feature branch...
-`);
-  for (let attempt = 0;attempt < MAX_ATTEMPTS; attempt++) {
-    if (attempt > 0) {
-      currentBranchName = `${branchName}-${attempt}`;
-    }
-    logger.info(`Attempting to use branch name: '${currentBranchName}' (Attempt ${attempt + 1}/${MAX_ATTEMPTS})`);
-    const currentBranchResult = await step(`getCurrentBranch-${attempt}`, async () => tools3.executeCommand({ command: "git", args: ["rev-parse", "--abbrev-ref", "HEAD"] }));
-    const onBranch = currentBranchResult.stdout.trim();
-    if (onBranch === currentBranchName) {
-      logger.info(`Already on branch '${currentBranchName}'.`);
-      logger.info(`Successfully on branch '${currentBranchName}'.
-`);
-      return { success: true, branchName: currentBranchName };
-    }
-    const branchExistsResult = await step(`checkBranchExists-${attempt}`, async () => await tools3.executeCommand({ command: "git", args: ["rev-parse", "--verify", currentBranchName] }));
-    if (branchExistsResult.exitCode === 0) {
-      logger.info(`Branch '${currentBranchName}' already exists. Switching to it...`);
-      const checkoutResult = await step(`checkoutBranch-${attempt}`, async () => await tools3.executeCommand({ command: "git", args: ["checkout", currentBranchName] }));
-      if (checkoutResult.exitCode === 0) {
-        logger.info(`Successfully switched to branch '${currentBranchName}'.
-`);
-        return { success: true, branchName: currentBranchName };
-      }
-      logger.warn(`Warning: Failed to switch to existing branch '${currentBranchName}'. Git command failed.`);
-    } else {
-      logger.info(`Creating new branch '${currentBranchName}'...`);
-      const createBranchResult = await step(`createBranch-${attempt}`, async () => await tools3.executeCommand({
-        command: "git",
-        args: baseBranch ? ["checkout", "-b", currentBranchName, baseBranch] : ["checkout", "-b", currentBranchName]
-      }));
-      if (createBranchResult.exitCode === 0) {
-        logger.info(`Successfully created and switched to branch '${currentBranchName}'.
-`);
-        return { success: true, branchName: currentBranchName };
-      }
-      logger.warn(`Warning: Failed to create branch '${currentBranchName}'. Git command failed.`);
-    }
-  }
-  logger.error(`Error: Failed to create or switch to a feature branch after ${MAX_ATTEMPTS} attempts.`);
-  return { success: false, branchName: null };
-}
-async function addTodoItemsFromPlan(plan2, context) {
-  const { logger, step, tools: tools3 } = context;
-  logger.info(`Phase 4: Creating todo items from plan...
-`);
-  await step("add-todo-items", async () => {
-    await agentWorkflow({
-      systemPrompt: EPIC_ADD_TODO_ITEMS_SYSTEM_PROMPT,
-      userMessage: [{ role: "user", content: `Please create the todo items based on the plan
-<plan>
-${plan2}</plan>` }],
-      tools: [readFile_default, searchFiles_default, listFiles_default, readMemory_default, getTodoItem_default, listTodoItems_default, updateTodoItem_default, updateMemory_default, listMemoryTopics_default]
-    }, context);
-  });
-  const todos = await tools3.listTodoItems({});
-  logger.info(`Created ${todos.length} todo items.
-`);
-}
-async function runPreflightChecks(epicContext, context) {
-  const { logger, step, tools: tools3 } = context;
-  logger.info(`Phase 1: Running pre-flight checks...
-`);
-  const gitCheckResult = await step("gitCheck", async () => tools3.executeCommand({ command: "git", args: ["rev-parse", "--git-dir"] }));
-  if (gitCheckResult.exitCode !== 0) {
-    logger.error("Error: Git is not initialized in this directory. Please run `git init` first.");
-    logger.info("Suggestion: Run `git init` to initialize a git repository.\n");
-    return false;
-  }
-  if (epicContext.plan) {
-    logger.info("Found an existing `.epic.yml` file.");
-    if (!epicContext.branchName) {
-      throw new Error("Invalid epic context loaded from .epic.yml: branchName is required.");
-    }
-    const currentBranchResult = await step("getCurrentBranch", async () => tools3.executeCommand({ command: "git", args: ["rev-parse", "--abbrev-ref", "HEAD"] }));
-    const currentBranch = currentBranchResult.stdout.trim();
-    if (currentBranch !== epicContext.branchName) {
-      throw new Error(`You are on branch '${currentBranch}' but the epic was started on branch '${epicContext.branchName}'. Please switch to the correct branch to resume.`);
-    }
-    logger.info("Resuming previous epic session.");
-    return true;
-  }
-  const gitStatusResult = await step("gitStatus", async () => tools3.executeCommand({ command: "git status --porcelain", shell: true }));
-  if (gitStatusResult.stdout.trim() !== "") {
-    logger.error("Error: Your working directory is not clean. Please stash or commit your changes before running the epic workflow.");
-    logger.info("Suggestion: Run `git add .` and `git commit` to clean your working directory, or `git stash` to temporarily save changes.\n");
-    return false;
-  }
-  const baseBranchResult = await step("getBaseBranch", async () => tools3.executeCommand({ command: "git", args: ["rev-parse", "--abbrev-ref", "HEAD"] }));
-  if (baseBranchResult.exitCode === 0 && baseBranchResult.stdout.trim()) {
-    epicContext.baseBranch = baseBranchResult.stdout.trim();
-    logger.info(`Using current branch '${epicContext.baseBranch}' as the base for this epic.`);
-  }
-  logger.info(`Pre-flight checks passed.
-`);
-  return true;
-}
-async function performReviewAndFixCycle(iterationCount, taskItem, highLevelPlan, context, additionalTools) {
-  const { logger, step, tools: tools3 } = context;
-  const commitMessages = [];
-  for (let i2 = 0;i2 < MAX_REVIEW_RETRIES; i2++) {
-    const diffResult = await tools3.executeCommand({ command: "git", args: ["diff", "--name-status", "HEAD~1", "HEAD"] });
-    const changedFiles = parseGitDiffNameStatus(diffResult.stdout).filter(({ path: path3 }) => path3 !== ".epic.yml");
-    if (changedFiles.length === 0) {
-      logger.info(`No files were changed. Skipping review.
-`);
-      return { passed: true, commitMessages: [] };
-    }
-    logger.info(`
-Review iteration ${i2 + 1}/${MAX_REVIEW_RETRIES}`);
-    logger.info(`   Changed files: ${changedFiles.length}`);
-    const changeInfo = {
-      commitRange: "HEAD~1...HEAD",
-      changedFiles
-    };
-    const reviewAgentResult = await step(`review-${iterationCount}-${i2}`, { retry: 1 }, async () => {
-      const defaultContext = await getDefaultContext("review");
-      const memoryContext = await tools3.getMemoryContext();
-      const userMessage = `${defaultContext}
-${memoryContext}
-
-${formatReviewToolInput(changeInfo)}`;
-      return await agentWorkflow({
-        systemPrompt: CODE_REVIEW_SYSTEM_PROMPT,
-        userMessage: [{ role: "user", content: userMessage }],
-        tools: [readFile_default, readBinaryFile_default, searchFiles_default, listFiles_default, gitDiff_default, readMemory_default, updateMemory_default, listMemoryTopics_default],
-        outputSchema: reviewOutputSchema
-      }, context);
-    });
-    if (reviewAgentResult.type !== "Exit") {
-      logger.error(`Review agent failed with status: ${reviewAgentResult.type}.`);
-      break;
-    }
-    const reviewResult = reviewAgentResult.object;
-    if (!reviewResult || !reviewResult.specificReviews || reviewResult.specificReviews.length === 0) {
-      logger.info(`Review passed. No issues found.
-`);
-      return { passed: true, commitMessages };
-    }
-    logger.warn(`Warning: Review found ${reviewResult.specificReviews.length} issue(s). Attempting to fix...
-`);
-    for (const [idx, review2] of reviewResult.specificReviews.entries()) {
-      logger.warn(`   ${idx + 1}. ${review2.file}:${review2.lines}`);
-    }
-    logger.warn("");
-    const reviewSummary = reviewResult.specificReviews.map((r2) => `File: ${r2.file} (lines: ${r2.lines})
-Review: ${r2.review}`).join(`
-
-`);
-    const fixTask = `You are working on an epic. The original task was: "${taskItem}".
-
-Here is the full plan for context:
-<plan>
-${highLevelPlan}
-</plan>
-
-After an initial implementation, a review found the following issues. Please fix them:
-
-${reviewSummary}`;
-    await step(`fix-${iterationCount}-${i2}`, { retry: 1 }, async () => {
-      await codeWorkflow({
-        task: fixTask,
-        mode: "noninteractive",
-        additionalInstructions: TODO_HANDLING_INSTRUCTIONS,
-        customTools: [getTodoItem_default, listTodoItems_default, updateTodoItem_default, readMemory_default, updateMemory_default, listMemoryTopics_default],
-        interactive: false,
-        additionalTools
-      }, context);
-    });
-    await step(`commit-fix-${iterationCount}-${i2}`, async () => {
-      const commitMessage = await commitWorkflow({
-        all: true,
-        context: reviewSummary,
-        interactive: false,
-        additionalTools
-      }, context);
-      if (commitMessage) {
-        commitMessages.push(commitMessage);
-      }
-    });
-    if (i2 === MAX_REVIEW_RETRIES - 1) {
-      logger.error(`
-Max retries (${MAX_REVIEW_RETRIES}) reached. Moving to the next task, but issues might remain.
-`);
-      return { passed: false, commitMessages };
-    }
-  }
-  return { passed: false, commitMessages };
-}
-async function findNextTask(tools3) {
-  const openRootTasks = await tools3.listTodoItems({ status: "open" });
-  if (openRootTasks.length === 0) {
-    return null;
-  }
-  let currentTask = openRootTasks[0];
-  while (true) {
-    const subTasks = await tools3.listTodoItems({ status: "open", id: currentTask.id });
-    if (subTasks.length === 0) {
-      return currentTask;
-    }
-    currentTask = subTasks[0];
-  }
-}
-async function runImplementationLoop(context, highLevelPlan, saveUsageSnapshot, additionalTools, noReview) {
-  const { logger, step, tools: tools3 } = context;
-  const commitMessages = [];
-  logger.info(`Phase 5: Iterative Implementation Loop...
-`);
-  logger.info(`${"=".repeat(80)}
-`);
-  let iterationCount = 0;
-  let nextTaskItem = await step("get-initial-task", () => findNextTask(tools3));
-  while (nextTaskItem) {
-    iterationCount++;
-    const taskStartTime = Date.now();
-    const { title: nextTask, id: nextTaskId } = nextTaskItem;
-    logger.info(`
-${"-".repeat(80)}`);
-    logger.info(`Iteration ${iterationCount}`);
-    logger.info(`${"-".repeat(80)}`);
-    logger.info(`${nextTask}
-`);
-    await step(`task-${iterationCount}`, { retry: 1 }, async () => {
-      const taskWithContext = `You are working on an epic. Here is the full plan:
-
-<plan>
-${highLevelPlan}
-</plan>
-
-Your current task is to implement this specific item:
-${nextTask}
-
-Focus only on this item, but use the plan for context.`;
-      return await codeWorkflow({
-        task: taskWithContext,
-        mode: "noninteractive",
-        additionalInstructions: TODO_HANDLING_INSTRUCTIONS,
-        customTools: [getTodoItem_default, listTodoItems_default, updateTodoItem_default, readMemory_default, updateMemory_default, listMemoryTopics_default],
-        interactive: false,
-        additionalTools
-      }, context);
-    });
-    const commitMessage = `feat: ${nextTask}`;
-    await step(`commit-initial-${iterationCount}`, async () => {
-      await tools3.executeCommand({ command: "git", args: ["add", "."] });
-      await tools3.executeCommand({ command: "git", args: ["commit", "-m", commitMessage] });
-    });
-    commitMessages.push(commitMessage);
-    if (!noReview) {
-      const { passed: reviewPassed, commitMessages: fixCommitMessages } = await performReviewAndFixCycle(iterationCount, nextTask, highLevelPlan, context, additionalTools);
-      commitMessages.push(...fixCommitMessages);
-      const taskElapsed = Date.now() - taskStartTime;
-      const taskElapsedTime = formatElapsedTime(taskElapsed);
-      if (reviewPassed) {
-        logger.info(`Iteration ${iterationCount} completed successfully (${taskElapsedTime})`);
-      } else {
-        logger.warn(`Warning: Iteration ${iterationCount} completed with potential issues (${taskElapsedTime})`);
-      }
-    } else {
-      const taskElapsed = Date.now() - taskStartTime;
-      const taskElapsedTime = formatElapsedTime(taskElapsed);
-      logger.info(`Iteration ${iterationCount} completed (${taskElapsedTime})`);
-    }
-    await step(`update-task-status-${iterationCount}`, async () => {
-      await tools3.updateTodoItem({ operation: "update", id: nextTaskId, status: "completed" });
-    });
-    nextTaskItem = await step(`get-next-task-${iterationCount}`, () => findNextTask(tools3));
-    const allTodos = await tools3.listTodoItems({});
-    const completedTodos = allTodos.filter((t2) => t2.status === "completed").length;
-    const totalTodos = allTodos.length;
-    let progressMessage = "";
-    if (totalTodos > 0) {
-      progressMessage = `${completedTodos}/${totalTodos} items completed`;
-    } else {
-      progressMessage = `Iteration ${iterationCount} completed`;
-    }
-    logger.info(`
-Progress: ${progressMessage}`);
-    await saveUsageSnapshot();
-    if (!nextTaskItem) {
-      logger.info(`All tasks complete!
-`);
-      break;
-    }
-    if (nextTaskItem) {
-      logger.info(`Next task: ${nextTaskItem.title}
-`);
-    }
-    logger.info(`${"-".repeat(80)}
-`);
-  }
-  return commitMessages;
-}
-async function performFinalReviewAndFix(context, highLevelPlan, baseBranch, additionalTools) {
-  const { logger, step, tools: tools3 } = context;
-  logger.info(`
-Phase 6: Final Review and Fixup...
-`);
-  if (!baseBranch) {
-    logger.warn("Warning: Base branch is not defined. Skipping final review step.");
-    return { passed: true };
-  }
-  const currentBranchResult = await tools3.executeCommand({ command: "git", args: ["rev-parse", "--abbrev-ref", "HEAD"] });
-  const currentBranch = currentBranchResult.stdout.trim();
-  if (currentBranch === baseBranch) {
-    logger.info(`You are on the base branch ('${baseBranch}'). No final review needed.`);
-    return { passed: true };
-  }
-  const commitRange = `${baseBranch}...${currentBranch}`;
-  for (let i2 = 0;i2 < MAX_REVIEW_RETRIES; i2++) {
-    const diffResult = await tools3.executeCommand({ command: "git", args: ["diff", "--name-status", commitRange] });
-    const changedFiles = parseGitDiffNameStatus(diffResult.stdout).filter(({ path: path3 }) => path3 !== ".epic.yml");
-    if (changedFiles.length === 0) {
-      logger.info(`No files have been changed in this branch. Skipping final review.
-`);
-      return { passed: true };
-    }
-    logger.info(`
-Final review iteration ${i2 + 1}/${MAX_REVIEW_RETRIES}`);
-    logger.info(`   Changed files: ${changedFiles.length}`);
-    const changeInfo = {
-      commitRange,
-      changedFiles
-    };
-    const reviewAgentResult = await step(`final-review-${i2}`, async () => {
-      const defaultContext = await getDefaultContext("review");
-      const memoryContext = await tools3.getMemoryContext();
-      const userMessage = `${defaultContext}
-${memoryContext}
-
-${formatReviewToolInput(changeInfo)}`;
-      return await agentWorkflow({
-        systemPrompt: CODE_REVIEW_SYSTEM_PROMPT,
-        userMessage: [{ role: "user", content: userMessage }],
-        tools: [readFile_default, readBinaryFile_default, searchFiles_default, listFiles_default, gitDiff_default, readMemory_default, updateMemory_default, listMemoryTopics_default],
-        outputSchema: reviewOutputSchema
-      }, context);
-    });
-    if (reviewAgentResult.type !== "Exit") {
-      logger.error(`Review agent failed with status: ${reviewAgentResult.type}.`);
-      break;
-    }
-    const reviewResult = reviewAgentResult.object;
-    if (!reviewResult || !reviewResult.specificReviews || reviewResult.specificReviews.length === 0) {
-      logger.info(`Final review passed. No issues found.
-`);
-      return { passed: true };
-    }
-    logger.warn(`Warning: Final review found ${reviewResult.specificReviews.length} issue(s). Attempting to fix...
-`);
-    for (const [idx, review2] of reviewResult.specificReviews.entries()) {
-      logger.warn(`   ${idx + 1}. ${review2.file}:${review2.lines}`);
-    }
-    logger.warn("");
-    const reviewSummary = reviewResult.specificReviews.map((r2) => `File: ${r2.file} (lines: ${r2.lines})
-Review: ${r2.review}`).join(`
-
-`);
-    const fixTask = `You are working on an epic. The original task was to implement a feature based on this plan:
-
-<plan>
-${highLevelPlan}
-</plan>
-
-A final review of all the changes in the branch found the following issues. Please fix them:
-
-${reviewSummary}`;
-    await step(`final-fix-${i2}`, async () => {
-      await codeWorkflow({
-        task: fixTask,
-        mode: "noninteractive",
-        additionalInstructions: TODO_HANDLING_INSTRUCTIONS,
-        customTools: [getTodoItem_default, listTodoItems_default, updateTodoItem_default, readMemory_default, updateMemory_default, listMemoryTopics_default],
-        interactive: false,
-        additionalTools
-      }, context);
-    });
-    await step(`commit-final-fix-${i2}`, async () => {
-      await tools3.executeCommand({ command: "git", args: ["add", "."] });
-      await tools3.executeCommand({ command: "git", args: ["commit", "-m", "chore: apply automated review feedback"] });
-    });
-    if (i2 === MAX_REVIEW_RETRIES - 1) {
-      logger.error(`
-Max retries (${MAX_REVIEW_RETRIES}) reached for final review. Issues might remain.
-`);
-      return { passed: false };
-    }
-  }
-  return { passed: false };
-}
-var MAX_REVIEW_RETRIES = 5, 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.`, epicWorkflow = async (input, context) => {
-  const { logger, tools: tools3 } = context;
-  const { task, saveEpicContext, saveUsageSnapshot, additionalTools, noReview } = input;
-  const workflowStartTime = Date.now();
-  if (!task || task.trim() === "") {
-    logger.error("Error: Task cannot be empty. Please provide a valid task description.");
-    return;
-  }
-  if (!input.task) {
-    input.task = task;
-  }
-  try {
-    const preflightResult = await runPreflightChecks(input, context);
-    if (!preflightResult) {
-      return;
-    }
-    if (!input.plan) {
-      if (!input.task) {
-        logger.error("Error: Task is missing in epic context. Exiting.");
-        return;
-      }
-      const planResult = await createAndApprovePlan(input.task, context, saveUsageSnapshot, input.interactive, additionalTools);
-      if (!planResult)
-        return;
-      input.plan = planResult.plan;
-      input.branchName = planResult.branchName;
-      await saveEpicContext(input);
-    }
-    if (!input.plan) {
-      logger.error("Error: Plan is missing after planning phase. Exiting.");
-      return;
-    }
-    if (!input.branchName) {
-      logger.error("Error: Branch name is missing after planning phase. Exiting.");
-      return;
-    }
-    const branchResult = await createFeatureBranch(input.branchName, input.baseBranch ?? undefined, context);
-    if (!branchResult.success || !branchResult.branchName)
-      return;
-    if (input.branchName !== branchResult.branchName) {
-      input.branchName = branchResult.branchName;
-      await saveEpicContext(input);
-    }
-    const todos = await tools3.listTodoItems({});
-    if (todos.length === 0) {
-      await addTodoItemsFromPlan(input.plan, context);
-    }
-    const commitMessages = await runImplementationLoop(context, input.plan, saveUsageSnapshot, additionalTools, noReview);
-    if (!noReview) {
-      await performFinalReviewAndFix(context, input.plan, input.baseBranch ?? undefined, additionalTools);
-    }
-    await saveUsageSnapshot();
-    await tools3.executeCommand({ command: "git", args: ["rm", "-f", ".epic.yml"] });
-    const statusResult = await tools3.executeCommand({
-      command: "git",
-      args: ["status", "--porcelain", "--", ".epic.yml"]
-    });
-    if (statusResult.stdout.trim() !== "") {
-      await tools3.executeCommand({ command: "git", args: ["commit", "-m", "chore: remove .epic.yml", "--", ".epic.yml"] });
-      logger.info("Cleaned up .epic.yml file.");
-    }
-    const totalElapsed = Date.now() - workflowStartTime;
-    const totalElapsedTime = formatElapsedTime(totalElapsed);
-    logger.info(`
-${"=".repeat(80)}`);
-    logger.info("Epic Workflow Complete!");
-    logger.info(`${"=".repeat(80)}`);
-    logger.info(`
-Summary:`);
-    logger.info(`   Branch: ${input.branchName}`);
-    logger.info(`   Total time: ${totalElapsedTime}`);
-    logger.info(`   Total commits: ${commitMessages.length}`);
-    logger.info("Commits created:");
-    for (const [idx, msg] of commitMessages.entries()) {
-      logger.info(`   ${idx + 1}. ${msg}`);
-    }
-    if (input.usages && input.usages.length > 0) {
-      const sortedUsages = [...input.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 (error48) {
-    logger.error(`
-Epic workflow failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
-    if (input?.branchName) {
-      logger.info(`
-Branch '${input.branchName}' was created but work is incomplete.`);
-      logger.info(`To cleanup: git checkout <previous-branch> && git branch -D ${input.branchName}
-`);
-    }
-    throw error48;
-  }
-};
-var init_epic_workflow = __esm(() => {
-  init_src();
-  init_errors5();
-  init_tools3();
-  init_code_workflow();
-  init_commit_workflow();
-  init_prompts2();
-  init_workflow_utils();
-});
-
 // src/mcp/errors.ts
 var McpError, McpConnectionError, McpToolError, McpServerError;
 var init_errors6 = __esm(() => {
@@ -108161,94 +107405,6 @@ var init_sdk_client = __esm(() => {
   init_errors6();
 });
 
-// src/workflows/epic-context.ts
-var exports_epic_context = {};
-__export(exports_epic_context, {
-  saveEpicContext: () => saveEpicContext,
-  loadEpicContext: () => loadEpicContext,
-  EpicUsageSchema: () => EpicUsageSchema,
-  EpicTodoItemStore: () => EpicTodoItemStore,
-  EpicMemoryStore: () => EpicMemoryStore,
-  EpicContextSchema: () => EpicContextSchema,
-  EPIC_CONTEXT_FILE: () => EPIC_CONTEXT_FILE
-});
-import { promises as fs14 } from "node:fs";
-
-class EpicMemoryStore {
-  #context;
-  constructor(context) {
-    this.#context = context;
-  }
-  async read() {
-    return this.#context.memory ?? {};
-  }
-  async write(data) {
-    this.#context.memory = data;
-    await saveEpicContext(this.#context);
-  }
-}
-
-class EpicTodoItemStore {
-  #context;
-  constructor(context) {
-    this.#context = context;
-  }
-  async read() {
-    return this.#context.todos ?? [];
-  }
-  async write(data) {
-    this.#context.todos = data;
-    await saveEpicContext(this.#context);
-  }
-}
-var import_yaml5, EPIC_CONTEXT_FILE = ".epic.yml", EpicUsageSchema, EpicContextSchema, saveEpicContext = async (context) => {
-  const yamlString = import_yaml5.stringify({
-    task: context.task,
-    plan: context.plan,
-    branchName: context.branchName,
-    baseBranch: context.baseBranch,
-    todos: context.todos,
-    memory: context.memory,
-    usages: context.usages
-  });
-  await fs14.writeFile(EPIC_CONTEXT_FILE, yamlString, "utf-8");
-}, loadEpicContext = async () => {
-  let fileContent;
-  try {
-    fileContent = await fs14.readFile(EPIC_CONTEXT_FILE, "utf-8");
-  } catch {
-    return {};
-  }
-  try {
-    const loaded = import_yaml5.parse(fileContent);
-    return EpicContextSchema.parse(loaded);
-  } catch (_error) {
-    return {};
-  }
-};
-var init_epic_context = __esm(() => {
-  init_src();
-  init_zod();
-  import_yaml5 = __toESM(require_dist(), 1);
-  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()
-  });
-  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(),
-    usages: exports_external.array(EpicUsageSchema).nullish()
-  });
-});
-
 // src/index.ts
 var import_config2 = __toESM(require_config(), 1);
 
@@ -108268,7 +107424,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.85";
+var version = "0.9.86";
 
 // src/commands/agent.ts
 import { exec as exec3 } from "node:child_process";
@@ -108929,19 +108085,6 @@ async function adaptCommitWorkflow(input, context) {
     throw new WorkflowInvocationError("commit", error48 instanceof Error ? error48.message : String(error48), error48 instanceof Error ? error48 : undefined);
   }
 }
-async function adaptEpicWorkflow(input, context) {
-  try {
-    const { epicWorkflow: epicWorkflow2 } = await Promise.resolve().then(() => (init_epic_workflow(), exports_epic_workflow));
-    const _result = await epicWorkflow2(input, context);
-    return {
-      success: true,
-      data: null,
-      output: "Epic workflow completed"
-    };
-  } catch (error48) {
-    throw new WorkflowInvocationError("epic", "Epic workflow not available", error48 instanceof Error ? error48 : undefined);
-  }
-}
 async function invokeWorkflow(workflowName, input, context, signal) {
   if (signal?.aborted) {
     const abortReason = signal.reason ? String(signal.reason) : "Workflow was cancelled before execution";
@@ -108969,8 +108112,6 @@ async function invokeWorkflow(workflowName, input, context, signal) {
       return adaptReviewWorkflow(workflowInput, cliContext);
     case "commit":
       return adaptCommitWorkflow(workflowInput, cliContext);
-    case "epic":
-      return adaptEpicWorkflow(workflowInput, cliContext);
     default:
       throw new WorkflowInvocationError(workflowName, `Unknown workflow: ${workflowName}`);
   }
@@ -112417,19 +111558,6 @@ var createLogger = (options) => {
   };
 };
 
-// src/utils/shell.ts
-function isWindows() {
-  return process.platform === "win32";
-}
-function quoteForShell(str) {
-  if (isWindows()) {
-    const escaped = str.replace(/"/g, '""');
-    return `"${escaped}"`;
-  } else {
-    return `'${str.replace(/'/g, "'\\''")}'`;
-  }
-}
-
 // src/commands/agent.ts
 async function runAgent(goal, options, _command) {
   console.log("\uD83E\uDD16 Polka Agent");
@@ -112464,6 +111592,13 @@ async function runAgent(goal, options, _command) {
         });
         return { exitCode: 0, stdout, stderr };
       } catch (error48) {
+        if (error48.errno === "ENOBUFS" || error48.code === "ENOBUFS") {
+          return {
+            exitCode: 1,
+            stdout: error48.stdout || "",
+            stderr: `Command output exceeded buffer limit (10MB). The command produced too much output. Try using different arguments or redirecting output to a file. Original error: ${error48.message}`
+          };
+        }
         return {
           exitCode: error48.code || 1,
           stdout: error48.stdout || "",
@@ -112548,9 +111683,6 @@ var agentCommand = new Command("agent").description("Run autonomous agent (exper
 import { readFile as readFile12 } from "node:fs/promises";
 init_mime_types();
 
-// src/api.ts
-init_src3();
-
 // src/runWorkflow.ts
 init_src3();
 init_src();
@@ -112671,7 +111803,7 @@ function getProviderOptions(options) {
 init_errors6();
 
 // src/mcp/manager.ts
-init_zod();
+init_src();
 
 // src/mcp/client.ts
 async function createMcpClient(serverName, config4) {
@@ -112810,7 +111942,7 @@ class McpManager {
     for (const [fullToolName, { tool: tool3 }] of this.tools.entries()) {
       let zodSchema2;
       try {
-        zodSchema2 = this.jsonSchemaToZod(tool3.inputSchema);
+        zodSchema2 = convertJsonSchemaToZod(tool3.inputSchema);
       } catch (error48) {
         const errorMessage = error48 instanceof Error ? error48.message : String(error48);
         if (this.logger) {
@@ -112850,68 +111982,6 @@ class McpManager {
     }
     return toolInfos;
   }
-  jsonSchemaToZod(schema) {
-    const properties = {};
-    const required2 = [];
-    if (schema.properties && typeof schema.properties === "object") {
-      for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        const propDef = propSchema;
-        properties[propName] = this.convertProperty(propDef);
-      }
-    }
-    if (Array.isArray(schema.required)) {
-      required2.push(...schema.required);
-    }
-    const finalSchema = {};
-    for (const [key, value] of Object.entries(properties)) {
-      if (required2.includes(key)) {
-        finalSchema[key] = value;
-      } else {
-        finalSchema[key] = value.optional();
-      }
-    }
-    return exports_external.object(finalSchema);
-  }
-  convertProperty(propDef) {
-    const type = propDef.type;
-    if (propDef.enum && Array.isArray(propDef.enum)) {
-      const enumValues = propDef.enum;
-      if (enumValues.length > 0 && enumValues.every((v) => typeof v === "string")) {
-        return exports_external.enum(enumValues);
-      }
-    }
-    if (propDef.const !== undefined) {
-      const constValue = propDef.const;
-      if (typeof constValue === "string" || typeof constValue === "number" || typeof constValue === "boolean" || constValue === null) {
-        return exports_external.literal(constValue);
-      }
-    }
-    switch (type) {
-      case "string":
-        return exports_external.string();
-      case "number":
-      case "integer":
-        return exports_external.number();
-      case "boolean":
-        return exports_external.boolean();
-      case "array":
-        if (propDef.items && typeof propDef.items === "object") {
-          const itemsSchema = this.convertProperty(propDef.items);
-          return exports_external.array(itemsSchema);
-        }
-        return exports_external.array(exports_external.any());
-      case "object":
-        if (propDef.properties && typeof propDef.properties === "object") {
-          return this.jsonSchemaToZod(propDef);
-        }
-        return exports_external.record(exports_external.string(), exports_external.any());
-      default:
-        if (this.logger) {
-          this.logger.warn(`Unsupported JSON Schema type: ${type}, falling back to z.any(). Tools should validate their inputs.`);
-        }
-        return exports_external.any();
-    }
-  }
 }
 
 // src/options.ts
@@ -113601,7 +112671,7 @@ async function runWorkflow(workflow2, workflowInput, options) {
     throw new Error(`No provider configured for command: ${commandName}`);
   }
   const model = getModel(commandConfig);
-  const excludeFiles = [".epic.yml", ...config4.excludeFiles ?? []];
+  const excludeFiles = [...config4.excludeFiles ?? []];
   const toolProvider = (options.getProvider ?? getProvider)({
     excludeFiles,
     yes: context.yes,
@@ -113810,7 +112880,6 @@ var initWorkflow = async (input2, context) => {
 init_src();
 init_zod();
 init_code_workflow();
-init_epic_workflow();
 init_prompts2();
 
 // src/workflows/task.workflow.ts
@@ -113862,7 +112931,7 @@ Agent finished!
 
 // src/workflows/meta.workflow.ts
 var DecisionSchema = exports_external.object({
-  workflow: exports_external.enum(["code", "task", "epic"])
+  workflow: exports_external.enum(["code", "task"])
 });
 var metaWorkflow = async (input2, context) => {
   const { task } = input2;
@@ -113905,9 +112974,6 @@ Decision: Using '${decision.workflow}' workflow.`);
         additionalTools: input2.additionalTools
       }, context);
       break;
-    case "epic":
-      await epicWorkflow(input2, context);
-      break;
     default:
       throw new Error(`Unknown workflow: ${decision.workflow}`);
   }
@@ -113976,14 +113042,13 @@ init_review_workflow();
 init_workflow_utils();
 
 // src/api.ts
-init_epic_workflow();
-init_epic_context();
 async function commit3(options = {}) {
-  const { all, context: messageContext, interactive, onUsage, ...context } = options;
+  const { all, files, context: messageContext, interactive, onUsage, ...context } = options;
   const verbose = context.silent ? -1 : context.verbose ?? 0;
   const logger = createLogger({ verbose });
   const workflowInput = {
     ...all && { all: true },
+    ...files && { files },
     ...messageContext && { context: messageContext },
     interactive: interactive !== false
   };
@@ -114083,46 +113148,6 @@ async function plan3(options = {}) {
     onUsageMeterCreated: onUsage
   });
 }
-async function epic2(options = {}) {
-  const { task: task2, noReview, interactive, onUsage, getProvider: getProvider2, _workflowInput, _saveEpicContext, _saveUsageSnapshot, ...context } = options;
-  const verbose = context.silent ? -1 : context.verbose ?? 0;
-  const logger = createLogger({ verbose });
-  let epicContext = _workflowInput;
-  if (!epicContext) {
-    const { loadEpicContext: loadEpicContext2 } = await Promise.resolve().then(() => (init_epic_context(), exports_epic_context));
-    epicContext = await loadEpicContext2();
-  }
-  if (task2 && epicContext.task) {
-    throw new Error("Existing epic context found, but task was provided. Exiting.");
-  }
-  if (task2) {
-    epicContext.task = task2;
-  }
-  const providerGetter = getProvider2 || ((opt) => getProvider({
-    ...opt,
-    todoItemStore: new EpicTodoItemStore(epicContext),
-    memoryStore: new EpicMemoryStore(epicContext)
-  }));
-  const workflowInput = {
-    ...epicContext,
-    interactive: interactive !== false,
-    noReview: noReview ?? false,
-    saveEpicContext: _saveEpicContext || (async (ctx) => {
-      Object.assign(epicContext, ctx);
-      const { saveEpicContext: saveEpicContext2 } = await Promise.resolve().then(() => (init_epic_context(), exports_epic_context));
-      await saveEpicContext2(epicContext);
-    }),
-    saveUsageSnapshot: _saveUsageSnapshot || (async () => {})
-  };
-  await runWorkflow(epicWorkflow, workflowInput, {
-    commandName: "epic",
-    context,
-    logger,
-    onUsageMeterCreated: onUsage,
-    getProvider: providerGetter,
-    interactive: interactive !== false
-  });
-}
 
 // src/commands/code.ts
 var readStdin = async (timeoutMs = 1000) => {
@@ -114218,87 +113243,11 @@ var commitCommand = new Command("commit").description("Create a commit with AI-g
   await commit3({
     all: localOptions.all,
     context: message,
-    interactive: !globalOpts.yes,
-    ...globalOpts
+    files: globalOpts.file,
+    interactive: !globalOpts.yes
   });
 });
 
-// src/commands/epic.ts
-init_src3();
-init_epic_context();
-async function runEpic(task2, options, command) {
-  const globalOpts = (command.parent ?? command).opts();
-  const { verbose } = globalOpts;
-  const { review: review3 } = options;
-  const logger = createLogger({
-    verbose
-  });
-  let taskInput = task2;
-  const epicContext = await loadEpicContext();
-  if (epicContext.task) {
-    if (taskInput) {
-      logger.error("Error: Existing epic context found, but task was provided via CLI args. Exiting.");
-      return;
-    }
-    logger.info("Resuming existing epic session. Task:");
-    logger.info(`   ${epicContext.task}`);
-  } else {
-    if (!taskInput) {
-      taskInput = await getUserInput("What feature do you want to implement?");
-      if (!taskInput) {
-        logger.info("No task provided. Exiting.");
-        return;
-      }
-    }
-  }
-  let usageMeter;
-  try {
-    await epic2({
-      task: taskInput,
-      noReview: review3 === false,
-      interactive: !globalOpts.yes,
-      onUsage: (meter) => {
-        usageMeter = meter;
-      },
-      ...globalOpts,
-      getProvider: (opt) => getProvider({
-        ...opt,
-        todoItemStore: new EpicTodoItemStore(epicContext),
-        memoryStore: new EpicMemoryStore(epicContext)
-      }),
-      _workflowInput: epicContext,
-      _saveEpicContext: async (context) => {
-        if (context.task)
-          epicContext.task = context.task;
-        if (context.plan)
-          epicContext.plan = context.plan;
-        if (context.branchName)
-          epicContext.branchName = context.branchName;
-        if (context.baseBranch)
-          epicContext.baseBranch = context.baseBranch;
-        await saveEpicContext(epicContext);
-      },
-      _saveUsageSnapshot: async () => {
-        if (usageMeter) {
-          const currentUsage = usageMeter.usage;
-          if (!epicContext.usages) {
-            epicContext.usages = [];
-          }
-          epicContext.usages.push({ ...currentUsage, timestamp: Date.now() });
-          await saveEpicContext(epicContext);
-        }
-      }
-    });
-  } catch (error48) {
-    if (error48 instanceof Error && error48.message.includes("Existing epic context found")) {
-      logger.error(`Error: ${error48.message}`);
-      return;
-    }
-    throw error48;
-  }
-}
-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.").option("--no-review", "Disable the review step").action(runEpic);
-
 // src/commands/fix.ts
 var fixCommand = new Command("fix").description("Fix issues by running a command and letting an agent fix it.").argument("[command]", "The command to run").option("-p, --prompt <prompt>", "Additional prompt for the agent.").action(async (commandArg, options, cmd) => {
   const globalOpts = (cmd.parent ?? cmd).opts();
@@ -114316,7 +113265,7 @@ init_src3();
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
 import { join as join13 } from "node:path";
 init_lodash();
-var import_yaml6 = __toESM(require_dist(), 1);
+var import_yaml5 = __toESM(require_dist(), 1);
 
 // src/builtin-commands.ts
 var BUILT_IN_COMMANDS = ["code", "commit", "pr", "review", "fix", "plan", "workflow", "run", "init", "meta", "skills"];
@@ -114701,7 +113650,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
       case "global": {
         const globalConfig2 = loadConfigAtPath(globalConfigPath) ?? {};
         set_default(globalConfig2, ["providers", provider3, "apiKey"], apiKey);
-        writeFileSync(globalConfigPath, import_yaml6.stringify(globalConfig2));
+        writeFileSync(globalConfigPath, import_yaml5.stringify(globalConfig2));
         logger.info(`API key saved to global config file: ${globalConfigPath}`);
         providerConfig.apiKey = undefined;
         break;
@@ -114736,7 +113685,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
   if (providerConfig.apiKey) {
     set_default(finalConfig, ["providers", provider3, "apiKey"], providerConfig.apiKey);
   }
-  writeFileSync(configPath, import_yaml6.stringify(finalConfig));
+  writeFileSync(configPath, import_yaml5.stringify(finalConfig));
   logger.info(`Configuration saved to ${configPath}`);
   let shouldAnalyze = false;
   if (!isGlobal && interactive) {
@@ -116078,7 +115027,12 @@ function createExecutionContext(_logger) {
 async function executeWorkflow(workflow3, input2, commandName, logger) {
   try {
     const context = createExecutionContext(logger);
-    const result = await runWorkflow(workflow3, input2, {
+    const workflowInput = {
+      ...input2,
+      interactive: false,
+      additionalTools: {}
+    };
+    const result = await runWorkflow(workflow3, workflowInput, {
       commandName,
       context,
       logger,
@@ -116086,7 +115040,7 @@ async function executeWorkflow(workflow3, input2, commandName, logger) {
       interactive: false
     });
     if (!result) {
-      return "Workflow completed with no output";
+      return "Error: Workflow returned no result (possible internal error or workflow produced no output)";
     }
     if (typeof result === "string") {
       return result;
@@ -116127,16 +115081,14 @@ The workflow will:
 Best used for implementing new features, refactoring existing code, fixing bugs across multiple files, adding tests, or code modernization.
 
 Parameters:
-- task (required): Detailed description of what needs to be implemented or changed
-- files (optional): Specific file paths to focus on. When provided, the AI will primarily analyze and modify these files`,
+- task (required): Detailed description of what needs to be implemented or changed`,
       inputSchema: exports_external.object({
-        task: exports_external.string().describe("The coding task to execute - be specific about what needs to be done"),
-        files: exports_external.array(exports_external.string()).optional().describe("Specific files to focus on (optional)")
+        task: exports_external.string().describe("The coding task to execute - be specific about what needs to be done")
       }),
       handler: async (args) => {
-        const { task: task2, files } = args;
-        logger.info(`MCP: Executing code workflow - task: "${task2}"${files ? `, files: ${files.join(", ")}` : ""}`);
-        return await executeWorkflow(codeWorkflow, { task: task2, files }, "code", logger);
+        const { task: task2 } = args;
+        logger.info(`MCP: Executing code workflow - task: "${task2}"`);
+        return await executeWorkflow(codeWorkflow, { task: task2 }, "code", logger);
       }
     },
     {
@@ -116291,57 +115243,12 @@ Parameters:
         return await executeWorkflow(fixWorkflow, { task: task2 }, "fix", logger);
       }
     },
-    {
-      name: "epic",
-      description: `Break down large features into manageable tasks and implement them systematically.
-
-The workflow will:
-- Take a high-level feature or goal description
-- Decompose it into smaller, concrete tasks
-- Create an ordered todo list with clear definitions
-- Implement tasks sequentially, handling dependencies
-- Track progress and provide summaries after each task
-- Continue until the entire epic is complete
-
-Process:
-1. Understand epic requirements and constraints
-2. Break down into specific, actionable tasks
-3. Create and prioritize the todo list
-4. For each task:
-   - Analyze what needs to be done
-   - Make necessary code changes
-   - Test and verify the implementation
-   - Mark task complete and move to next
-5. Provide final completion summary
-
-Best used for large features, multi-component implementations, or complex refactoring projects that span multiple files or modules.
-
-Parameters:
-- epic (required): High-level description of the epic/feature to implement`,
-      inputSchema: exports_external.object({
-        epic: exports_external.string().describe("Description of the epic to implement - describe the overall feature or goal, not specific implementation steps")
-      }),
-      handler: async (args) => {
-        const { epic: epicTask } = args;
-        logger.info(`MCP: Executing epic workflow - epic: "${epicTask}"`);
-        try {
-          await epic2({
-            ...createExecutionContext(logger),
-            task: epicTask,
-            interactive: false
-          });
-          return "Epic workflow completed successfully";
-        } catch (error48) {
-          return `Error: ${error48 instanceof Error ? error48.message : String(error48)}`;
-        }
-      }
-    },
     {
       name: "commit",
       description: `Create a git commit with an AI-generated, well-formatted commit message.
 
 The workflow will:
-- Stage all changes (git add .)
+- Stage specified files (all files or specific files)
 - Analyze the diff to understand what changed
 - Generate a clear, descriptive commit message following best practices
 - Create the commit with the generated message
@@ -116359,17 +115266,21 @@ Best practices followed:
 - Wrap body lines at 72 characters
 
 Parameters:
-- message (optional): Custom commit message. If not provided, AI analyzes changes and generates an appropriate message following best practices`,
+- message (optional): Custom commit message. If not provided, AI analyzes changes and generates an appropriate message following best practices
+- stageFiles (optional): Files to stage before committing. Use "all" to stage all files, or provide an array of specific file paths to stage`,
       inputSchema: exports_external.object({
-        message: exports_external.string().optional().describe("Optional commit message - if not provided, AI will analyze changes and generate an appropriate message")
+        message: exports_external.string().optional().describe("Optional commit message - if not provided, AI will analyze changes and generate an appropriate message"),
+        stageFiles: exports_external.union([exports_external.literal("all"), exports_external.array(exports_external.string())]).optional().describe('Files to stage: "all" for all files, or array of specific file paths')
       }),
       handler: async (args) => {
-        const { message } = args;
-        logger.info(`MCP: Executing commit workflow${message ? ` - message: "${message}"` : ""}`);
+        const { message, stageFiles } = args;
+        logger.info(`MCP: Executing commit workflow${message ? ` - message: "${message}"` : ""}${stageFiles ? ` - stageFiles: "${JSON.stringify(stageFiles)}"` : ""}`);
         try {
           await commit3({
             ...createExecutionContext(logger),
             context: message,
+            all: stageFiles === "all",
+            files: Array.isArray(stageFiles) ? stageFiles : undefined,
             interactive: false
           });
           return "Commit created successfully";
@@ -116498,9 +115409,9 @@ function validateScriptPermissions(script, logger) {
   }
   if ("script" in script && script.permissions) {
     logger?.warn("Script permissions are currently advisory only. Scripts run with full process permissions.");
-    const { fs: fs15, network, subprocess } = script.permissions;
-    if (fs15 && !["read", "write", "none"].includes(fs15)) {
-      throw new ScriptValidationError(`Invalid fs permission: ${fs15}. Must be 'read', 'write', or 'none'`);
+    const { fs: fs14, network, subprocess } = script.permissions;
+    if (fs14 && !["read", "write", "none"].includes(fs14)) {
+      throw new ScriptValidationError(`Invalid fs permission: ${fs14}. Must be 'read', 'write', or 'none'`);
     }
     if (typeof network !== "boolean" && network !== undefined) {
       throw new ScriptValidationError(`Invalid network permission: must be true or false`);
@@ -116665,56 +115576,12 @@ async function executeScript(script, name18, logger, args = []) {
 }
 
 // src/commands/meta.ts
-init_epic_context();
 async function runMeta(task2, command) {
   const globalOpts = (command.parent ?? command).opts();
   const { verbose } = globalOpts;
   const logger = createLogger({
     verbose
   });
-  const epicContext = await loadEpicContext();
-  if (epicContext.task) {
-    if (task2) {
-      logger.error("Error: Existing epic context found.");
-      logger.info(`Current task: ${epicContext.task}`);
-      logger.info('Use "polka epic --clear" to start a new task.');
-      return;
-    }
-    logger.info("Resuming existing epic session. Task:");
-    logger.info(`   ${epicContext.task}`);
-    let usageMeter2;
-    const saveUsageSnapshot2 = async () => {
-      if (usageMeter2) {
-        const currentUsage = usageMeter2.usage;
-        if (!epicContext.usages) {
-          epicContext.usages = [];
-        }
-        epicContext.usages.push({ ...currentUsage, timestamp: Date.now() });
-      }
-    };
-    const workflowInput2 = {
-      ...epicContext,
-      async saveEpicContext(context) {
-        await saveEpicContext(context);
-      },
-      saveUsageSnapshot: saveUsageSnapshot2,
-      interactive: !globalOpts.yes
-    };
-    await runWorkflow(metaWorkflow, workflowInput2, {
-      commandName: "meta",
-      context: globalOpts,
-      logger,
-      onUsageMeterCreated: (meter) => {
-        usageMeter2 = meter;
-      },
-      getProvider: (opt) => getProvider({
-        ...opt,
-        todoItemStore: new EpicTodoItemStore(workflowInput2),
-        memoryStore: new EpicMemoryStore(workflowInput2)
-      })
-    });
-    return;
-  }
   if (task2) {
     const trimmedTask = task2.trim();
     const words2 = trimmedTask.split(/\s+/);
@@ -116744,37 +115611,17 @@ async function runMeta(task2, command) {
       logger.info('  For tasks: polka "detailed task description"');
       return;
     }
-    epicContext.task = task2;
-    let usageMeter2;
-    const saveUsageSnapshot2 = async () => {
-      if (usageMeter2) {
-        const currentUsage = usageMeter2.usage;
-        if (!epicContext.usages) {
-          epicContext.usages = [];
-        }
-        epicContext.usages.push({ ...currentUsage, timestamp: Date.now() });
-      }
-    };
     const workflowInput2 = {
-      ...epicContext,
-      async saveEpicContext(context) {
-        await saveEpicContext(context);
-      },
-      saveUsageSnapshot: saveUsageSnapshot2,
-      interactive: !globalOpts.yes
+      task: task2,
+      interactive: !globalOpts.yes,
+      additionalTools: {}
     };
     await runWorkflow(metaWorkflow, workflowInput2, {
       commandName: "meta",
       context: globalOpts,
       logger,
-      onUsageMeterCreated: (meter) => {
-        usageMeter2 = meter;
-      },
-      getProvider: (opt) => getProvider({
-        ...opt,
-        todoItemStore: new EpicTodoItemStore(workflowInput2),
-        memoryStore: new EpicMemoryStore(workflowInput2)
-      })
+      requiresProvider: true,
+      interactive: !globalOpts.yes
     });
     return;
   }
@@ -116801,37 +115648,17 @@ async function runMeta(task2, command) {
     logger.info('  For tasks: polka "detailed task description"');
     return;
   }
-  epicContext.task = input2;
-  let usageMeter;
-  const saveUsageSnapshot = async () => {
-    if (usageMeter) {
-      const currentUsage = usageMeter.usage;
-      if (!epicContext.usages) {
-        epicContext.usages = [];
-      }
-      epicContext.usages.push({ ...currentUsage, timestamp: Date.now() });
-    }
-  };
   const workflowInput = {
-    ...epicContext,
-    async saveEpicContext(context) {
-      await saveEpicContext(context);
-    },
-    saveUsageSnapshot,
-    interactive: !globalOpts.yes
+    task: input2,
+    interactive: !globalOpts.yes,
+    additionalTools: {}
   };
   await runWorkflow(metaWorkflow, workflowInput, {
     commandName: "meta",
     context: globalOpts,
     logger,
-    onUsageMeterCreated: (meter) => {
-      usageMeter = meter;
-    },
-    getProvider: (opt) => getProvider({
-      ...opt,
-      todoItemStore: new EpicTodoItemStore(workflowInput),
-      memoryStore: new EpicMemoryStore(workflowInput)
-    })
+    requiresProvider: true,
+    interactive: !globalOpts.yes
   });
 }
 async function tryExecuteCommand(commandName, logger) {
@@ -117340,7 +116167,6 @@ program2.addCommand(prCommand);
 program2.addCommand(reviewCommand);
 program2.addCommand(planCommand);
 program2.addCommand(codeCommand);
-program2.addCommand(epicCommand);
 program2.addCommand(fixCommand);
 program2.addCommand(runCommand);
 program2.addCommand(skillsCommand);
@@ -117362,7 +116188,6 @@ export {
   reviewCode,
   plan3 as plan,
   fix3 as fix,
-  epic2 as epic,
   createPr,
   commit3 as commit,
   code2 as code