claude-kanban 0.3.1 → 0.5.0

package/dist/bin/cli.js

@@ -4,6 +4,10 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import open from "open";
+import { existsSync as existsSync4 } from "fs";
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+import { join as join6 } from "path";
 
 // src/server/index.ts
 import express from "express";
@@ -14,9 +18,9 @@ import { fileURLToPath } from "url";
 import { existsSync as existsSync3 } from "fs";
 
 // src/server/services/executor.ts
-import { spawn, execSync } from "child_process";
+import { spawn } from "child_process";
 import { join as join4 } from "path";
-import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4, rmSync } from "fs";
+import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4 } from "fs";
 import { EventEmitter } from "events";
 
 // src/server/services/project.ts
@@ -526,10 +530,9 @@ function getRecentProgress(projectPath, lines = 100) {
 // src/server/services/executor.ts
 var KANBAN_DIR4 = ".claude-kanban";
 var LOGS_DIR = "logs";
-var WORKTREES_DIR = "worktrees";
 var TaskExecutor = class extends EventEmitter {
   projectPath;
-  runningTasks = /* @__PURE__ */ new Map();
+  runningTask = null;
   afkMode = false;
   afkIteration = 0;
   afkMaxIterations = 0;
@@ -635,186 +638,47 @@ ${summary}
     }
   }
   /**
-   * Check if project is a git repository
+   * Check if a task is currently running
    */
-  isGitRepo() {
-    try {
-      execSync("git rev-parse --is-inside-work-tree", {
-        cwd: this.projectPath,
-        stdio: "pipe"
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get worktrees directory path
-   */
-  getWorktreesDir() {
-    return join4(this.projectPath, KANBAN_DIR4, WORKTREES_DIR);
-  }
-  /**
-   * Get worktree path for a task
-   */
-  getWorktreePath(taskId) {
-    return join4(this.getWorktreesDir(), taskId);
+  isRunning() {
+    return this.runningTask !== null;
   }
   /**
-   * Get branch name for a task
+   * Get the currently running task ID
    */
-  getBranchName(taskId) {
-    return `task/${taskId}`;
-  }
-  /**
-   * Create a git worktree for isolated task execution
-   */
-  createWorktree(taskId) {
-    if (!this.isGitRepo()) {
-      console.log("[executor] Not a git repo, skipping worktree creation");
-      return null;
-    }
-    const worktreePath = this.getWorktreePath(taskId);
-    const branchName = this.getBranchName(taskId);
-    try {
-      const worktreesDir = this.getWorktreesDir();
-      if (!existsSync2(worktreesDir)) {
-        mkdirSync2(worktreesDir, { recursive: true });
-      }
-      if (existsSync2(worktreePath)) {
-        this.removeWorktree(taskId);
-      }
-      try {
-        execSync(`git rev-parse --verify ${branchName}`, {
-          cwd: this.projectPath,
-          stdio: "pipe"
-        });
-        execSync(`git branch -D ${branchName}`, {
-          cwd: this.projectPath,
-          stdio: "pipe"
-        });
-      } catch {
-      }
-      execSync(`git worktree add -b ${branchName} "${worktreePath}"`, {
-        cwd: this.projectPath,
-        stdio: "pipe"
-      });
-      console.log(`[executor] Created worktree at ${worktreePath} on branch ${branchName}`);
-      return { worktreePath, branchName };
-    } catch (error) {
-      console.error("[executor] Failed to create worktree:", error);
-      return null;
-    }
-  }
-  /**
-   * Remove a git worktree
-   */
-  removeWorktree(taskId) {
-    const worktreePath = this.getWorktreePath(taskId);
-    const branchName = this.getBranchName(taskId);
-    try {
-      if (existsSync2(worktreePath)) {
-        execSync(`git worktree remove "${worktreePath}" --force`, {
-          cwd: this.projectPath,
-          stdio: "pipe"
-        });
-        console.log(`[executor] Removed worktree at ${worktreePath}`);
-      }
-    } catch (error) {
-      console.error("[executor] Failed to remove worktree via git:", error);
-      try {
-        if (existsSync2(worktreePath)) {
-          rmSync(worktreePath, { recursive: true, force: true });
-          execSync("git worktree prune", {
-            cwd: this.projectPath,
-            stdio: "pipe"
-          });
-        }
-      } catch {
-        console.error("[executor] Failed to force remove worktree directory");
-      }
-    }
-    try {
-      execSync(`git branch -D ${branchName}`, {
-        cwd: this.projectPath,
-        stdio: "pipe"
-      });
-      console.log(`[executor] Deleted branch ${branchName}`);
-    } catch {
-    }
-  }
-  /**
-   * Merge worktree branch back to main branch
-   */
-  mergeWorktreeBranch(taskId) {
-    const branchName = this.getBranchName(taskId);
-    try {
-      const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
-        cwd: this.projectPath,
-        encoding: "utf-8"
-      }).trim();
-      execSync(`git merge ${branchName} --no-edit`, {
-        cwd: this.projectPath,
-        stdio: "pipe"
-      });
-      console.log(`[executor] Merged ${branchName} into ${currentBranch}`);
-      return true;
-    } catch (error) {
-      console.error("[executor] Failed to merge branch:", error);
-      return false;
-    }
-  }
-  /**
-   * Get number of currently running tasks
-   */
-  getRunningCount() {
-    return this.runningTasks.size;
-  }
-  /**
-   * Check if a task is running
-   */
-  isTaskRunning(taskId) {
-    return this.runningTasks.has(taskId);
-  }
-  /**
-   * Get all running task IDs
-   */
-  getRunningTaskIds() {
-    return Array.from(this.runningTasks.keys());
+  getRunningTaskId() {
+    return this.runningTask?.taskId || null;
   }
   /**
    * Get running task output
    */
   getTaskOutput(taskId) {
-    return this.runningTasks.get(taskId)?.output;
+    if (this.runningTask?.taskId === taskId) {
+      return this.runningTask.output;
+    }
+    return void 0;
   }
   /**
-   * Build the prompt for a specific task
+   * Build the prompt for a task - simplified Ralph-style
    */
-  buildTaskPrompt(task, config, worktreeInfo) {
+  buildTaskPrompt(task, config) {
     const kanbanDir = join4(this.projectPath, KANBAN_DIR4);
     const prdPath = join4(kanbanDir, "prd.json");
     const progressPath = join4(kanbanDir, "progress.txt");
     const stepsText = task.steps.length > 0 ? `
 Verification steps:
 ${task.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}` : "";
-    const verifySteps = [];
+    const verifyCommands = [];
     if (config.project.typecheckCommand) {
-      verifySteps.push(`Run typecheck: ${config.project.typecheckCommand}`);
+      verifyCommands.push(config.project.typecheckCommand);
     }
     if (config.project.testCommand) {
-      verifySteps.push(`Run tests: ${config.project.testCommand}`);
+      verifyCommands.push(config.project.testCommand);
     }
-    const verifySection = verifySteps.length > 0 ? `3. Verify your work:
-${verifySteps.map((s) => `   - ${s}`).join("\n")}
+    const verifySection = verifyCommands.length > 0 ? `3. Run quality checks:
+${verifyCommands.map((cmd) => `   - ${cmd}`).join("\n")}
 
-` : "";
-    const worktreeSection = worktreeInfo ? `## ENVIRONMENT
-You are running in an isolated git worktree on branch "${worktreeInfo.branchName}".
-This is a fresh checkout - dependencies (node_modules, vendor, etc.) are NOT installed.
-Before running any build/test commands, install dependencies first (e.g., npm install, composer install, pip install).
-
-` : "";
+4.` : "3.";
     return `You are an AI coding agent. Complete the following task:
 
 ## TASK
@@ -825,48 +689,41 @@ Priority: ${task.priority}
 ${task.description}
 ${stepsText}
 
-${worktreeSection}## INSTRUCTIONS
-1. If dependencies are not installed, install them first.
+## INSTRUCTIONS
+
+1. Implement this task as described above.
 
-2. Implement this task as described above.
+2. Make sure your changes work correctly.
 
-${verifySection}${verifySteps.length > 0 ? "4" : "3"}. When complete, update the task in ${prdPath}:
+${verifySection} When complete, update the PRD file at ${prdPath}:
    - Find the task with id "${task.id}"
    - Set "passes": true
    - Set "status": "completed"
 
-${verifySteps.length > 0 ? "5" : "4"}. Document your work in ${progressPath}:
-   - What you implemented and files changed
-   - Key decisions made and why
-   - Gotchas, edge cases, or tricky parts discovered
-   - Useful patterns or approaches that worked well
-   - Anything a future agent should know about this area of the codebase
+${verifyCommands.length > 0 ? "5" : "4"}. Document your work in ${progressPath}:
+   - What you implemented
+   - Key decisions made
+   - Any gotchas or important notes for future work
 
-${verifySteps.length > 0 ? "6" : "5"}. Make a git commit with a descriptive message.
+${verifyCommands.length > 0 ? "6" : "5"}. Commit your changes with a descriptive message.
 
-Focus only on this task. When successfully complete, output: <promise>COMPLETE</promise>`;
+Focus only on this task. When done, output: <promise>COMPLETE</promise>`;
   }
   /**
-   * Run a specific task
+   * Run a task
    */
   async runTask(taskId) {
+    if (this.isRunning()) {
+      throw new Error("A task is already running. Wait for it to complete or cancel it first.");
+    }
     const config = getConfig(this.projectPath);
     const task = getTaskById(this.projectPath, taskId);
     if (!task) {
       throw new Error(`Task not found: ${taskId}`);
     }
-    if (this.isTaskRunning(taskId)) {
-      throw new Error(`Task already running: ${taskId}`);
-    }
-    const maxConcurrent = config.execution.maxConcurrent || 3;
-    if (this.getRunningCount() >= maxConcurrent) {
-      throw new Error(`Maximum concurrent tasks (${maxConcurrent}) reached`);
-    }
     updateTask(this.projectPath, taskId, { status: "in_progress" });
     const startedAt = /* @__PURE__ */ new Date();
-    const worktreeInfo = this.createWorktree(taskId);
-    const executionPath = worktreeInfo?.worktreePath || this.projectPath;
-    const prompt = this.buildTaskPrompt(task, config, worktreeInfo);
+    const prompt = this.buildTaskPrompt(task, config);
     const kanbanDir = join4(this.projectPath, KANBAN_DIR4);
     const promptFile = join4(kanbanDir, `prompt-${taskId}.txt`);
     writeFileSync4(promptFile, prompt);
@@ -882,48 +739,32 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     const commandDisplay = `${config.agent.command} ${args.join(" ")}`;
     const fullCommand = `${config.agent.command} ${args.join(" ")}`;
     console.log("[executor] Command:", fullCommand);
-    console.log("[executor] CWD:", executionPath);
-    if (worktreeInfo) {
-      console.log("[executor] Using worktree:", worktreeInfo.worktreePath);
-      console.log("[executor] Branch:", worktreeInfo.branchName);
-    }
+    console.log("[executor] CWD:", this.projectPath);
     const childProcess = spawn("bash", ["-c", fullCommand], {
-      cwd: executionPath,
+      cwd: this.projectPath,
       env: {
         ...process.env,
         TERM: "xterm-256color",
         FORCE_COLOR: "0",
-        // Disable colors to avoid escape codes
         NO_COLOR: "1"
-        // Standard way to disable colors
       },
       stdio: ["ignore", "pipe", "pipe"]
-      // Close stdin since we don't need interactive input
     });
-    const runningTask = {
+    this.runningTask = {
       taskId,
       process: childProcess,
       startedAt,
-      output: [],
-      worktreePath: worktreeInfo?.worktreePath,
-      branchName: worktreeInfo?.branchName
+      output: []
     };
-    this.runningTasks.set(taskId, runningTask);
     this.initLogFile(taskId);
     const logOutput = (line) => {
       this.appendToLog(taskId, line);
-      runningTask.output.push(line);
+      this.runningTask?.output.push(line);
       this.emit("task:output", { taskId, line, lineType: "stdout" });
     };
     this.emit("task:started", { taskId, timestamp: startedAt.toISOString() });
     logOutput(`[claude-kanban] Starting task: ${task.title}
 `);
-    if (worktreeInfo) {
-      logOutput(`[claude-kanban] Worktree: ${worktreeInfo.worktreePath}
-`);
-      logOutput(`[claude-kanban] Branch: ${worktreeInfo.branchName}
-`);
-    }
     logOutput(`[claude-kanban] Command: ${commandDisplay}
 `);
     logOutput(`[claude-kanban] Process spawned (PID: ${childProcess.pid})
@@ -968,9 +809,6 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       const text = data.toString();
       logOutput(`[stderr] ${text}`);
     });
-    childProcess.on("spawn", () => {
-      console.log("[executor] Process spawned successfully");
-    });
     childProcess.on("error", (error) => {
       console.log("[executor] Spawn error:", error.message);
       this.emit("task:output", { taskId, line: `[claude-kanban] Error: ${error.message}
@@ -979,9 +817,6 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
         unlinkSync(promptFile);
       } catch {
       }
-      if (worktreeInfo) {
-        this.removeWorktree(taskId);
-      }
       updateTask(this.projectPath, taskId, { status: "failed", passes: false });
       const endedAt = /* @__PURE__ */ new Date();
       addExecutionEntry(this.projectPath, taskId, {
@@ -992,7 +827,7 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
         error: error.message
       });
       this.emit("task:failed", { taskId, error: error.message });
-      this.runningTasks.delete(taskId);
+      this.runningTask = null;
     });
     childProcess.on("close", (code, signal) => {
       console.log("[executor] Process closed with code:", code, "signal:", signal);
@@ -1006,8 +841,8 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     });
     const timeoutMs = (config.execution.timeout || 30) * 60 * 1e3;
     setTimeout(() => {
-      if (this.isTaskRunning(taskId)) {
-        this.cancelTask(taskId, "Timeout exceeded");
+      if (this.runningTask?.taskId === taskId) {
+        this.cancelTask("Timeout exceeded");
       }
     }, timeoutMs);
   }
@@ -1015,23 +850,13 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
    * Handle task completion
    */
   handleTaskComplete(taskId, exitCode, startedAt) {
-    const runningTask = this.runningTasks.get(taskId);
-    if (!runningTask) return;
+    if (!this.runningTask || this.runningTask.taskId !== taskId) return;
     const endedAt = /* @__PURE__ */ new Date();
     const duration = endedAt.getTime() - startedAt.getTime();
-    const output = runningTask.output.join("");
+    const output = this.runningTask.output.join("");
     const isComplete = output.includes("<promise>COMPLETE</promise>");
     const task = getTaskById(this.projectPath, taskId);
     if (isComplete || exitCode === 0) {
-      if (runningTask.worktreePath && runningTask.branchName) {
-        const merged = this.mergeWorktreeBranch(taskId);
-        if (merged) {
-          console.log(`[executor] Successfully merged ${runningTask.branchName}`);
-        } else {
-          console.log(`[executor] Failed to merge ${runningTask.branchName}, branch preserved for manual merge`);
-        }
-        this.removeWorktree(taskId);
-      }
       updateTask(this.projectPath, taskId, {
         status: "completed",
         passes: true
@@ -1051,9 +876,6 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       this.emit("task:completed", { taskId, duration });
       this.afkTasksCompleted++;
     } else {
-      if (runningTask.worktreePath) {
-        this.removeWorktree(taskId);
-      }
       updateTask(this.projectPath, taskId, {
         status: "failed",
         passes: false
@@ -1075,39 +897,33 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       });
       this.emit("task:failed", { taskId, error });
     }
-    this.runningTasks.delete(taskId);
+    this.runningTask = null;
     if (this.afkMode) {
       this.continueAFKMode();
     }
   }
   /**
-   * Cancel a running task
+   * Cancel the running task
    */
-  cancelTask(taskId, reason = "Cancelled by user") {
-    const runningTask = this.runningTasks.get(taskId);
-    if (!runningTask) return false;
-    const startedAt = runningTask.startedAt;
+  cancelTask(reason = "Cancelled by user") {
+    if (!this.runningTask) return false;
+    const { taskId, process: childProcess, startedAt } = this.runningTask;
     const endedAt = /* @__PURE__ */ new Date();
     const duration = endedAt.getTime() - startedAt.getTime();
     const task = getTaskById(this.projectPath, taskId);
     try {
-      runningTask.process.kill("SIGTERM");
+      childProcess.kill("SIGTERM");
       setTimeout(() => {
         try {
-          if (!runningTask.process.killed) {
-            runningTask.process.kill("SIGKILL");
+          if (!childProcess.killed) {
+            childProcess.kill("SIGKILL");
           }
         } catch {
         }
       }, 2e3);
     } catch {
     }
-    if (runningTask.worktreePath) {
-      this.removeWorktree(taskId);
-    }
-    updateTask(this.projectPath, taskId, {
-      status: "ready"
-    });
+    updateTask(this.projectPath, taskId, { status: "ready" });
     addExecutionEntry(this.projectPath, taskId, {
       startedAt: startedAt.toISOString(),
       endedAt: endedAt.toISOString(),
@@ -1123,48 +939,46 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
       error: reason
     });
     this.emit("task:cancelled", { taskId });
-    this.runningTasks.delete(taskId);
+    this.runningTask = null;
     return true;
   }
   /**
-   * Start AFK mode
+   * Start AFK mode - run tasks sequentially until done
    */
-  startAFKMode(maxIterations, concurrent) {
+  startAFKMode(maxIterations) {
     if (this.afkMode) {
       throw new Error("AFK mode already running");
     }
+    if (this.isRunning()) {
+      throw new Error("Cannot start AFK mode while a task is running");
+    }
     this.afkMode = true;
     this.afkIteration = 0;
     this.afkMaxIterations = maxIterations;
     this.afkTasksCompleted = 0;
     this.emitAFKStatus();
-    this.continueAFKMode(concurrent);
+    this.continueAFKMode();
   }
   /**
-   * Continue AFK mode - pick up next tasks
+   * Continue AFK mode - pick next task
    */
-  continueAFKMode(concurrent = 1) {
+  continueAFKMode() {
     if (!this.afkMode) return;
     if (this.afkIteration >= this.afkMaxIterations) {
       this.stopAFKMode();
       return;
     }
-    const config = getConfig(this.projectPath);
-    const maxConcurrent = Math.min(concurrent, config.execution.maxConcurrent || 3);
-    while (this.getRunningCount() < maxConcurrent) {
-      const nextTask = getNextReadyTask(this.projectPath);
-      if (!nextTask) {
-        if (this.getRunningCount() === 0) {
-          this.stopAFKMode();
-        }
-        break;
-      }
-      this.afkIteration++;
-      this.runTask(nextTask.id).catch((error) => {
-        console.error("AFK task error:", error);
-      });
-      this.emitAFKStatus();
+    if (this.isRunning()) return;
+    const nextTask = getNextReadyTask(this.projectPath);
+    if (!nextTask) {
+      this.stopAFKMode();
+      return;
     }
+    this.afkIteration++;
+    this.runTask(nextTask.id).catch((error) => {
+      console.error("AFK task error:", error);
+    });
+    this.emitAFKStatus();
   }
   /**
    * Stop AFK mode
@@ -1196,18 +1010,15 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
     };
   }
   /**
-   * Cancel all running tasks
+   * Cancel running task and stop AFK mode
    */
   cancelAll() {
-    for (const [taskId, runningTask] of this.runningTasks.entries()) {
+    if (this.runningTask) {
       try {
-        runningTask.process.kill("SIGKILL");
+        this.runningTask.process.kill("SIGKILL");
       } catch {
       }
-      if (runningTask.worktreePath) {
-        this.removeWorktree(taskId);
-      }
-      this.runningTasks.delete(taskId);
+      this.runningTask = null;
     }
     this.stopAFKMode();
   }
@@ -1717,7 +1528,12 @@ async function createServer(projectPath, port) {
   });
   app.post("/api/tasks/:id/cancel", (req, res) => {
     try {
-      const cancelled = executor.cancelTask(req.params.id);
+      const runningId = executor.getRunningTaskId();
+      if (runningId !== req.params.id) {
+        res.status(404).json({ error: "Task not running" });
+        return;
+      }
+      const cancelled = executor.cancelTask();
       if (!cancelled) {
         res.status(404).json({ error: "Task not running" });
         return;
@@ -1819,8 +1635,8 @@ async function createServer(projectPath, port) {
   });
   app.post("/api/afk/start", (req, res) => {
     try {
-      const { maxIterations, concurrent } = req.body;
-      executor.startAFKMode(maxIterations || 10, concurrent || 1);
+      const { maxIterations } = req.body;
+      executor.startAFKMode(maxIterations || 10);
       res.json({ success: true, status: executor.getAFKStatus() });
     } catch (error) {
       res.status(400).json({ error: String(error) });
@@ -1844,8 +1660,8 @@ async function createServer(projectPath, port) {
   });
   app.get("/api/running", (_req, res) => {
     try {
-      const taskIds = executor.getRunningTaskIds();
-      res.json({ running: taskIds, count: taskIds.length });
+      const taskId = executor.getRunningTaskId();
+      res.json({ running: taskId ? [taskId] : [], count: taskId ? 1 : 0 });
     } catch (error) {
       res.status(500).json({ error: String(error) });
     }
@@ -1853,7 +1669,7 @@ async function createServer(projectPath, port) {
   app.get("/api/stats", (_req, res) => {
     try {
       const counts = getTaskCounts(projectPath);
-      const running = executor.getRunningCount();
+      const running = executor.isRunning() ? 1 : 0;
       const afk = executor.getAFKStatus();
       res.json({ counts, running, afk });
     } catch (error) {
@@ -1869,12 +1685,13 @@ async function createServer(projectPath, port) {
   });
   io.on("connection", (socket) => {
     console.log("Client connected");
-    const runningIds = executor.getRunningTaskIds();
+    const runningId = executor.getRunningTaskId();
+    const runningIds = runningId ? [runningId] : [];
     const taskLogs = {};
-    for (const taskId of runningIds) {
-      const logs = executor.getTaskLog(taskId);
+    if (runningId) {
+      const logs = executor.getTaskLog(runningId);
       if (logs) {
-        taskLogs[taskId] = logs;
+        taskLogs[runningId] = logs;
       }
     }
     socket.emit("init", {
@@ -1882,7 +1699,7 @@ async function createServer(projectPath, port) {
       running: runningIds,
       afk: executor.getAFKStatus(),
       taskLogs
-      // Include logs for running tasks
+      // Include logs for running task
     });
     socket.on("get-logs", (taskId) => {
       const logs = executor.getTaskLog(taskId);
@@ -2592,7 +2409,10 @@ socket.on('task:output', ({ taskId, line }) => {
 socket.on('task:completed', ({ taskId }) => {
   state.running = state.running.filter(id => id !== taskId);
   const task = state.tasks.find(t => t.id === taskId);
-  if (task) { task.status = 'completed'; task.passes = true; }
+  if (task) {
+    task.status = 'completed';
+    task.passes = true;
+  }
   showToast('Task completed: ' + (task?.title || taskId), 'success');
   render();
 });
@@ -2685,11 +2505,11 @@ async function generateTask(prompt) {
   }
 }
 
-async function startAFK(maxIterations, concurrent) {
+async function startAFK(maxIterations) {
   await fetch('/api/afk/start', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ maxIterations, concurrent })
+    body: JSON.stringify({ maxIterations })
   });
 }
 
@@ -3122,21 +2942,13 @@ function renderModal() {
             <button onclick="state.showModal = null; render();" class="btn btn-ghost p-1.5 text-canvas-500 hover:text-canvas-700">\u2715</button>
           </div>
           <div class="p-6">
-            <p class="text-sm text-canvas-600 mb-5">Run the agent in a loop, automatically picking up tasks from the "Ready" column until complete.</p>
+            <p class="text-sm text-canvas-600 mb-5">Run the agent in a loop, automatically picking up tasks from the "Ready" column one at a time until complete.</p>
             <div class="space-y-4">
               <div>
                 <label class="block text-sm font-medium text-canvas-700 mb-2">Maximum Iterations</label>
                 <input type="number" id="afk-iterations" value="10" min="1" max="100"
                        class="input w-full">
               </div>
-              <div>
-                <label class="block text-sm font-medium text-canvas-700 mb-2">Concurrent Tasks</label>
-                <select id="afk-concurrent" class="input w-full">
-                  <option value="1">1 (Sequential)</option>
-                  <option value="2">2</option>
-                  <option value="3">3 (Max)</option>
-                </select>
-              </div>
               <div class="bg-status-running/10 border border-status-running/20 rounded-lg p-3">
                 <p class="text-xs text-status-running">\u26A0\uFE0F You can close this tab - the agent will continue running. Check back later or watch the terminal output.</p>
               </div>
@@ -3235,7 +3047,7 @@ function renderSidePanel() {
       </div>
 
       <!-- Action Buttons -->
-      <div class="px-5 py-4 border-b border-canvas-200 flex gap-2 flex-shrink-0">
+      <div class="px-5 py-4 border-b border-canvas-200 flex flex-wrap gap-2 flex-shrink-0">
         \${task.status === 'draft' ? \`
           <button onclick="updateTask('\${task.id}', { status: 'ready' })" class="btn btn-primary px-4 py-2 text-sm">
             \u2192 Move to Ready
@@ -3445,8 +3257,7 @@ function applyTemplate(templateId) {
 
 function handleStartAFK() {
   const iterations = parseInt(document.getElementById('afk-iterations').value) || 10;
-  const concurrent = parseInt(document.getElementById('afk-concurrent').value) || 1;
-  startAFK(iterations, concurrent);
+  startAFK(iterations);
   state.showModal = null;
   render();
 }
@@ -3650,6 +3461,49 @@ async function findAvailablePort(startPort, maxAttempts = 10) {
 }
 
 // src/bin/cli.ts
+function isGitRepo(dir) {
+  return existsSync4(join6(dir, ".git"));
+}
+function hasGitRemote(dir) {
+  try {
+    const result = execSync("git remote -v", { cwd: dir, stdio: "pipe" }).toString();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function detectRemoteType(dir) {
+  try {
+    const result = execSync("git remote get-url origin", { cwd: dir, stdio: "pipe" }).toString().toLowerCase();
+    if (result.includes("github.com")) return "github";
+    if (result.includes("gitlab.com") || result.includes("gitlab")) return "gitlab";
+    if (result.includes("bitbucket.org") || result.includes("bitbucket")) return "bitbucket";
+    if (result.trim()) return "other";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function initializeGit(dir) {
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  try {
+    execSync("git add -A", { cwd: dir, stdio: "pipe" });
+    execSync('git commit -m "Initial commit"', { cwd: dir, stdio: "pipe" });
+  } catch {
+  }
+}
+async function promptYesNo(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith("y"));
+    });
+  });
+}
 var VERSION = "0.1.0";
 var banner = `
 ${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
@@ -3662,6 +3516,32 @@ async function main() {
   program.name("claude-kanban").description("Visual Kanban board for AI-powered development with Claude").version(VERSION).option("-p, --port <number>", "Port to run server on", "4242").option("-n, --no-open", "Do not auto-open browser").option("--init", "Re-initialize project files").option("--reset", "Reset all tasks (keeps config)").action(async (options) => {
     console.log(banner);
     const cwd = process.cwd();
+    if (!isGitRepo(cwd)) {
+      console.log(chalk.yellow("\n\u26A0 This directory is not a git repository."));
+      console.log(chalk.gray("Git is required for task isolation and parallel execution.\n"));
+      const shouldInit = await promptYesNo(chalk.white("Would you like to initialize git now? (y/n): "));
+      if (shouldInit) {
+        try {
+          console.log(chalk.gray("Initializing git repository..."));
+          initializeGit(cwd);
+          console.log(chalk.green("\u2713 Git repository initialized"));
+        } catch (error) {
+          console.error(chalk.red("Failed to initialize git:"), error);
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.red("\nGit is required to run Claude Kanban."));
+        console.log(chalk.gray('Please run "git init" manually and try again.'));
+        process.exit(1);
+      }
+    } else {
+      const remoteType = detectRemoteType(cwd);
+      if (remoteType) {
+        console.log(chalk.gray(`Git remote detected: ${remoteType}`));
+      } else if (!hasGitRemote(cwd)) {
+        console.log(chalk.gray("Git repository (local only, no remote)"));
+      }
+    }
     const initialized = await isProjectInitialized(cwd);
     if (!initialized || options.init) {
       console.log(chalk.yellow("Initializing project..."));