autopilot-code 0.0.4 → 0.0.6

package/.autopilot/autopilot.json

@@ -2,14 +2,29 @@
   "enabled": true,
   "repo": "bakkensoftware/autopilot",
   "agent": "opencode",
+  "allowedMergeUsers": [
+    "kellyelton"
+  ],
   "issueLabels": {
-    "queue": ["autopilot:todo"],
+    "queue": [
+      "autopilot:todo"
+    ],
     "blocked": "autopilot:blocked",
     "inProgress": "autopilot:in-progress",
     "done": "autopilot:done"
   },
-  "priorityLabels": ["p0", "p1", "p2"],
+  "priorityLabels": [
+    "p0",
+    "p1",
+    "p2"
+  ],
+  "minPriority": null,
+  "ignoreIssueLabels": [
+    "autopilot:backlog"
+  ],
   "maxParallel": 1,
   "branchPrefix": "autopilot/",
-  "allowedBaseBranch": "main"
+  "allowedBaseBranch": "main",
+  "autoResolveConflicts": true,
+  "conflictResolutionMaxAttempts": 3
 }

package/README.md

@@ -22,6 +22,8 @@ Example:
   "enabled": true,
   "repo": "bakkensoftware/autopilot",
   "agent": "opencode",
+  "autoMerge": false,
+  "allowedMergeUsers": ["github-username"],
   "issueLabels": {
     "queue": ["autopilot:todo"],
     "blocked": "autopilot:blocked",
@@ -39,6 +41,9 @@ Example:
 Notes:
 - `repo` must be the GitHub `owner/name`.
 - `agent` (optional, default `"none"`): set to `"opencode"` to enable OpenCode integration after claiming issues.
+- `autoMerge` (optional, default `false`): if `true`, autopilot will automatically merge PRs after they are created.
+- `allowedMergeUsers` (required when `autoMerge=true`): list of GitHub usernames allowed to auto-merge. The runner verifies the authenticated GitHub user is in this list before merging.
+- `ignoreIssueLabels` (optional, default `["autopilot:backlog"]`): issues with any of these labels will be ignored by the runner.
 - `heartbeatMaxAgeSecs` controls how long an in-progress issue can go without a heartbeat before it's considered stale.
 
 ## Workflow (labels)
@@ -86,7 +91,11 @@ On each loop:
 ## Running locally
 ### Python runner
 ```bash
+# Run a single scan/claim/act cycle
 python3 scripts/run_autopilot.py --root /mnt/f/Source
+
+# Run in foreground loop mode (dev-friendly)
+python3 scripts/run_autopilot.py --root /mnt/f/Source --interval-seconds 60
 ```
 
 ### Node CLI wrapper
@@ -104,16 +113,18 @@ node dist/cli.js scan --root /mnt/f/Source
 
 # claim exactly one issue + comment
 node dist/cli.js run-once --root /mnt/f/Source
+
+# run service in foreground mode (dev-friendly)
+node dist/cli.js service --foreground --interval-seconds 60 --root /mnt/f/Source
 ```
 
+The foreground service mode runs continuously with the specified interval and logs to stdout. Press Ctrl+C to shut down cleanly.
+
 ## Roadmap
-- Spawn a coding agent (Claude Code / OpenCode) in a worktree per issue
-- Create PRs linked to issues; wait for checks to go green
-- Merge PRs automatically when mergeable + checks pass
+- ~~Spawn a coding agent (Claude Code / OpenCode) in a worktree per issue~~ (done)
+- ~~Create PRs linked to issues; wait for checks to go green~~ (done)
+- ~~Merge PRs automatically when mergeable + checks pass~~ (done)
 - Close issues + apply `autopilot:done`
-- Richer durable state:
-  - PR number / branch name / last heartbeat comment
-  - “blocked reason” codified
 
 ## Config template
 See `templates/autopilot.json`.

package/dist/cli.js

@@ -6,7 +6,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = require("node:readline");
+const repoRoot = node_path_1.default.resolve(__dirname, "..");
+const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(repoRoot, "package.json"), "utf8"));
+const version = packageJson.version;
+const GLOBAL_CONFIG_DIR = node_path_1.default.join(process.env.HOME || "", ".config", "autopilot");
+const GLOBAL_CONFIG_FILE = node_path_1.default.join(GLOBAL_CONFIG_DIR, "config.json");
+const SYSTEM_DIR = "/etc/systemd/system";
+const USER_DIR = node_path_1.default.join(process.env.HOME || "", ".config", "systemd", "user");
 function run(cmd, args) {
     const res = (0, node_child_process_1.spawnSync)(cmd, args, { stdio: "inherit" });
     if (res.error)
@@ -22,16 +31,270 @@ function check(cmd, args, label) {
     }
     if (typeof res.status === "number" && res.status !== 0) {
         console.error(`\n${label}: returned exit code ${res.status}`);
-        process.exit(res.status);
+        process.exit(1);
     }
 }
-const repoRoot = node_path_1.default.resolve(__dirname, "..");
+function loadGlobalConfig() {
+    if (!(0, node_fs_1.existsSync)(GLOBAL_CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const data = (0, node_fs_1.readFileSync)(GLOBAL_CONFIG_FILE, "utf8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+function saveGlobalConfig(config) {
+    (0, node_fs_1.mkdirSync)(GLOBAL_CONFIG_DIR, { recursive: true });
+    (0, node_fs_1.writeFileSync)(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function isGitRepo(dirPath) {
+    return (0, node_fs_1.existsSync)(node_path_1.default.join(dirPath, ".git"));
+}
+function prompt(question) {
+    const rl = (0, node_readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function validatePath(pathStr) {
+    const resolvedPath = node_path_1.default.resolve(pathStr);
+    if (!(0, node_fs_1.existsSync)(resolvedPath)) {
+        return { valid: false, error: `Path does not exist: ${pathStr}` };
+    }
+    if (!isGitRepo(resolvedPath)) {
+        return { valid: true, isGit: false };
+    }
+    return { valid: true, isGit: true };
+}
+async function collectSourceFolders() {
+    const folders = [];
+    console.log("\n📁 Source Folder Selection");
+    console.log("Enter one or more directories containing git repos to scan.");
+    console.log("Leave empty when done.\n");
+    while (true) {
+        const input = await prompt(`Source folder #${folders.length + 1} (or press Enter to finish): `);
+        if (input === "") {
+            if (folders.length === 0) {
+                console.log("At least one source folder is required.");
+                continue;
+            }
+            break;
+        }
+        const validation = validatePath(input);
+        if (!validation.valid) {
+            console.error(`❌ ${validation.error}`);
+            continue;
+        }
+        const resolvedPath = node_path_1.default.resolve(input);
+        if (folders.includes(resolvedPath)) {
+            console.log("⚠️  This folder is already in the list.");
+            continue;
+        }
+        if (validation.isGit) {
+            console.log(`✅ Added git repo: ${resolvedPath}`);
+        }
+        else {
+            console.log(`✅ Added folder: ${resolvedPath} (will scan for git repos recursively)`);
+        }
+        folders.push(resolvedPath);
+    }
+    return folders;
+}
+function isRoot() {
+    return process.getuid?.() === 0;
+}
+function getSystemdPaths() {
+    const useSystem = isRoot();
+    const unitPath = useSystem ? node_path_1.default.join(SYSTEM_DIR, "autopilot.service") : node_path_1.default.join(USER_DIR, "autopilot.service");
+    const logPath = node_path_1.default.join(GLOBAL_CONFIG_DIR, "autopilot.log");
+    return { unitPath, logPath, useSystem };
+}
+function generateSystemdUnit(logPath, intervalSeconds) {
+    const execPath = process.execPath;
+    const args = [
+        "service",
+        "--foreground",
+        "--interval-seconds", intervalSeconds,
+    ];
+    const user = process.env.USER || "root";
+    return `[Unit]
+Description=Autopilot automated issue runner
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${execPath} ${args.join(" ")}
+Restart=always
+RestartSec=10
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=autopilot
+${isRoot() ? `User=${user}` : ""}
+Environment="NODE_ENV=production"
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+function systemctl(cmd, args, check = false) {
+    const cmdArgs = [cmd, ...args];
+    const result = (0, node_child_process_1.spawnSync)("systemctl", cmdArgs, { stdio: "inherit" });
+    if (result.error) {
+        console.error(`Failed to run systemctl: ${result.error.message}`);
+        return false;
+    }
+    if (result.status !== 0) {
+        if (!check) {
+            console.error(`systemctl ${cmd} failed with exit code ${result.status}`);
+        }
+        return false;
+    }
+    return true;
+}
+function installSystemdService() {
+    const { unitPath, logPath, useSystem } = getSystemdPaths();
+    const intervalSeconds = "60";
+    if (!(0, node_fs_1.existsSync)(GLOBAL_CONFIG_FILE)) {
+        console.error("Configuration not found. Run 'autopilot init' first.");
+        process.exit(1);
+    }
+    if (!systemctl("--version", [], true)) {
+        console.error("systemd is not available on this system.");
+        process.exit(1);
+    }
+    const unitDir = node_path_1.default.dirname(unitPath);
+    if (!(0, node_fs_1.existsSync)(unitDir)) {
+        (0, node_fs_1.mkdirSync)(unitDir, { recursive: true });
+    }
+    const unitContent = generateSystemdUnit(logPath, intervalSeconds);
+    (0, node_fs_1.writeFileSync)(unitPath, unitContent, { mode: 0o644 });
+    console.log(`Systemd unit file created at: ${unitPath}`);
+    const daemonReloadArgs = useSystem ? [] : ["--user"];
+    if (!systemctl("daemon-reload", daemonReloadArgs)) {
+        process.exit(1);
+    }
+    if (!systemctl("enable", ["autopilot.service", ...daemonReloadArgs])) {
+        process.exit(1);
+    }
+    if (!systemctl("start", ["autopilot.service", ...daemonReloadArgs])) {
+        process.exit(1);
+    }
+    console.log("✅ Autopilot service installed, enabled and started.");
+    console.log(`\nUse: journalctl ${useSystem ? "" : "--user "} -u autopilot -f`);
+}
+function uninstallSystemdService() {
+    const { unitPath, useSystem } = getSystemdPaths();
+    if (!(0, node_fs_1.existsSync)(unitPath)) {
+        console.log("Service not installed.");
+        return;
+    }
+    const daemonReloadArgs = useSystem ? [] : ["--user"];
+    if (!systemctl("stop", ["autopilot.service", ...daemonReloadArgs], true)) {
+        console.log("Service not running, continuing...");
+    }
+    if (!systemctl("disable", ["autopilot.service", ...daemonReloadArgs], true)) {
+        console.log("Service not enabled, continuing...");
+    }
+    const { spawnSync } = require("node:child_process");
+    const { unlinkSync } = require("node:fs");
+    try {
+        unlinkSync(unitPath);
+        console.log(`Removed unit file: ${unitPath}`);
+    }
+    catch (err) {
+        console.error(`Failed to remove unit file: ${err.message}`);
+    }
+    if (!systemctl("daemon-reload", daemonReloadArgs)) {
+        process.exit(1);
+    }
+    console.log("✅ Autopilot service uninstalled.");
+}
+function startSystemdService() {
+    const { unitPath, useSystem } = getSystemdPaths();
+    if (!(0, node_fs_1.existsSync)(unitPath)) {
+        console.error("Service not installed. Run 'autopilot install' first.");
+        process.exit(1);
+    }
+    const daemonReloadArgs = useSystem ? [] : ["--user"];
+    if (!systemctl("start", ["autopilot.service", ...daemonReloadArgs])) {
+        process.exit(1);
+    }
+    console.log("✅ Autopilot service started.");
+}
+function stopSystemdService() {
+    const { unitPath, useSystem } = getSystemdPaths();
+    if (!(0, node_fs_1.existsSync)(unitPath)) {
+        console.error("Service not installed. Run 'autopilot install' first.");
+        process.exit(1);
+    }
+    const daemonReloadArgs = useSystem ? [] : ["--user"];
+    if (!systemctl("stop", ["autopilot.service", ...daemonReloadArgs], true)) {
+        console.log("Service not running or already stopped.");
+        return;
+    }
+    console.log("✅ Autopilot service stopped.");
+}
+function statusSystemdService() {
+    const { unitPath, useSystem } = getSystemdPaths();
+    if (!(0, node_fs_1.existsSync)(unitPath)) {
+        console.log("Service not installed. Run 'autopilot install' first.");
+        return;
+    }
+    const daemonReloadArgs = useSystem ? [] : ["--user"];
+    const { spawnSync } = require("node:child_process");
+    spawnSync("systemctl", ["status", "autopilot.service", ...daemonReloadArgs], { stdio: "inherit" });
+}
+async function initCommand() {
+    console.log("🚀 Autopilot Setup\n");
+    const existingConfig = loadGlobalConfig();
+    if (existingConfig && existingConfig.sourceFolders.length > 0) {
+        console.log("Existing configuration found:");
+        console.log("Current source folders:");
+        existingConfig.sourceFolders.forEach((folder, idx) => {
+            const isGit = isGitRepo(folder);
+            console.log(`  ${idx + 1}. ${folder}${isGit ? " (git repo)" : ""}`);
+        });
+        console.log();
+        const overwrite = await prompt("Do you want to replace this configuration? (y/N): ");
+        if (overwrite.toLowerCase() !== "y") {
+            console.log("Configuration unchanged.");
+            return;
+        }
+    }
+    const sourceFolders = await collectSourceFolders();
+    const config = {
+        sourceFolders,
+    };
+    saveGlobalConfig(config);
+    console.log("\n✅ Configuration saved to:", GLOBAL_CONFIG_FILE);
+    console.log("\nYou can now run:");
+    console.log("  autopilot scan      # Scan repos without claiming issues");
+    console.log("  autopilot run-once  # Claim and work on one issue");
+}
 const runnerPath = node_path_1.default.join(repoRoot, "scripts", "run_autopilot.py");
 const program = new commander_1.Command();
 program
     .name("autopilot")
     .description("Repo-issue–driven autopilot runner (CLI wrapper)")
-    .version("0.0.0");
+    .version(version);
+program
+    .command("init")
+    .description("Initialize autopilot configuration (select source folders)")
+    .action(() => {
+    initCommand().catch((err) => {
+        console.error("Error:", err);
+        process.exit(1);
+    });
+});
 program
     .command("doctor")
     .description("Check local prerequisites (gh auth, python3)")
@@ -44,15 +307,105 @@ program
 program
     .command("scan")
     .description("Discover autopilot-enabled repos + show next issue candidate (dry-run)")
-    .requiredOption("--root <path>", "Root folder that contains git repos")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
     .action((opts) => {
-    run("python3", [runnerPath, "--root", opts.root, "--dry-run"]);
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    args.push("--dry-run");
+    run("python3", args);
 });
 program
     .command("run-once")
     .description("Claim exactly one issue and post a progress comment")
-    .requiredOption("--root <path>", "Root folder that contains git repos")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
     .action((opts) => {
-    run("python3", [runnerPath, "--root", opts.root]);
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    run("python3", args);
+});
+program
+    .command("service")
+    .description("Run the autopilot service (foreground mode with loop)")
+    .option("--foreground", "Run in foreground mode (log to stdout)")
+    .option("--interval-seconds <number>", "Interval between cycles in seconds", "60")
+    .option("--root <paths...>", "Root folder(s) that contain git repos (space-separated)")
+    .option("--max-depth <number>", "Maximum depth for recursive repo discovery", "5")
+    .action((opts) => {
+    let rootPaths = opts.root;
+    if (!rootPaths || rootPaths.length === 0) {
+        const config = loadGlobalConfig();
+        if (!config || config.sourceFolders.length === 0) {
+            console.error("No source folders configured. Run 'autopilot init' first.");
+            process.exit(1);
+        }
+        rootPaths = config.sourceFolders;
+    }
+    const args = [runnerPath, "--root", ...rootPaths];
+    if (opts.maxDepth)
+        args.push("--max-depth", opts.maxDepth);
+    if (opts.foreground) {
+        const interval = opts.intervalSeconds || "60";
+        args.push("--interval-seconds", interval);
+        console.log(`Starting autopilot service in foreground mode (interval: ${interval}s)`);
+        console.log("Press Ctrl+C to shut down cleanly\n");
+        run("python3", args);
+    }
+    else {
+        console.error("Only --foreground mode is supported currently.");
+        console.error("For background service mode, use systemd integration (coming soon).");
+        process.exit(1);
+    }
+});
+program
+    .command("install")
+    .description("Install and enable autopilot as a systemd service")
+    .action(() => {
+    installSystemdService();
+});
+program
+    .command("uninstall")
+    .description("Uninstall and disable autopilot systemd service")
+    .action(() => {
+    uninstallSystemdService();
+});
+program
+    .command("start")
+    .description("Start the autopilot systemd service")
+    .action(() => {
+    startSystemdService();
+});
+program
+    .command("stop")
+    .description("Stop the autopilot systemd service")
+    .action(() => {
+    stopSystemdService();
+});
+program
+    .command("status")
+    .description("Show the status of the autopilot systemd service")
+    .action(() => {
+    statusSystemdService();
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autopilot-code",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/run_autopilot.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import signal
 import subprocess
 import sys
 import time
@@ -27,12 +28,37 @@ from typing import Any
 STATE_DIR = ".autopilot"
 STATE_FILE = "state.json"
 DEFAULT_HEARTBEAT_MAX_AGE_SECS = 60 * 60  # 1h
+DEFAULT_MAX_DEPTH = 5
+IGNORED_DIRS = {
+    "node_modules",
+    ".venv",
+    "venv",
+    ".env",
+    "env",
+    ".git",
+    ".idea",
+    ".vscode",
+    "dist",
+    "build",
+    "target",
+    "bin",
+    "obj",
+    "__pycache__",
+}
 
 
 def sh(cmd: list[str], cwd: Path | None = None, check: bool = True) -> str:
-    p = subprocess.run(cmd, cwd=str(cwd) if cwd else None, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    p = subprocess.run(
+        cmd,
+        cwd=str(cwd) if cwd else None,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
     if check and p.returncode != 0:
-        raise RuntimeError(f"command failed ({p.returncode}): {' '.join(cmd)}\n{p.stdout}")
+        raise RuntimeError(
+            f"command failed ({p.returncode}): {' '.join(cmd)}\n{p.stdout}"
+        )
     return p.stdout
 
 
@@ -49,6 +75,14 @@ class RepoConfig:
     max_parallel: int
     heartbeat_max_age_secs: int
     agent: str
+    ignore_issue_labels: list[str]
+    min_priority: str | None
+    auto_merge: bool
+    allowed_merge_users: list[str]
+    auto_resolve_conflicts: bool
+    conflict_resolution_max_attempts: int
+    auto_fix_checks: bool
+    auto_fix_checks_max_attempts: int
 
 
 def load_config(repo_root: Path) -> RepoConfig | None:
@@ -62,6 +96,21 @@ def load_config(repo_root: Path) -> RepoConfig | None:
     labels = data.get("issueLabels", {})
     queue = labels.get("queue", ["autopilot:todo"])
 
+    auto_merge = data.get("autoMerge", True)
+    allowed_merge_users = list(data.get("allowedMergeUsers", []))
+
+    if auto_merge and not allowed_merge_users:
+        raise RuntimeError(
+            "autoMerge is enabled but allowedMergeUsers list is empty or missing. "
+            "Please specify at least one allowed GitHub username."
+        )
+
+    auto_resolve_conflicts = data.get("autoResolveConflicts", True)
+    conflict_resolution_max_attempts = int(data.get("conflictResolutionMaxAttempts", 3))
+
+    auto_fix_checks = data.get("autoFixChecks", True)
+    auto_fix_checks_max_attempts = int(data.get("autoFixChecksMaxAttempts", 3))
+
     return RepoConfig(
         root=repo_root,
         repo=data["repo"],
@@ -72,26 +121,67 @@ def load_config(repo_root: Path) -> RepoConfig | None:
         label_done=labels.get("done", "autopilot:done"),
         priority_labels=data.get("priorityLabels", ["p0", "p1", "p2"]),
         max_parallel=int(data.get("maxParallel", 2)),
-        heartbeat_max_age_secs=int(data.get("heartbeatMaxAgeSecs", DEFAULT_HEARTBEAT_MAX_AGE_SECS)),
+        heartbeat_max_age_secs=int(
+            data.get("heartbeatMaxAgeSecs", DEFAULT_HEARTBEAT_MAX_AGE_SECS)
+        ),
         agent=data.get("agent", "none"),
+        ignore_issue_labels=list(data.get("ignoreIssueLabels", ["autopilot:backlog"])),
+        min_priority=data.get("minPriority"),
+        auto_merge=auto_merge,
+        allowed_merge_users=allowed_merge_users,
+        auto_resolve_conflicts=auto_resolve_conflicts,
+        conflict_resolution_max_attempts=conflict_resolution_max_attempts,
+        auto_fix_checks=auto_fix_checks,
+        auto_fix_checks_max_attempts=auto_fix_checks_max_attempts,
     )
 
 
-def discover_repos(root: Path) -> list[RepoConfig]:
+def discover_repos(root: Path, max_depth: int = DEFAULT_MAX_DEPTH) -> list[RepoConfig]:
     out: list[RepoConfig] = []
-    for child in root.iterdir():
-        if not child.is_dir():
-            continue
-        if (child / ".git").exists() and (child / ".autopilot" / "autopilot.json").exists():
-            cfg = load_config(child)
-            if cfg:
-                out.append(cfg)
+    _discover_repos_recursive(root, 0, max_depth, out)
     return out
 
 
+def _discover_repos_recursive(
+    current_dir: Path, current_depth: int, max_depth: int, out: list[RepoConfig]
+) -> None:
+    if current_depth > max_depth:
+        return
+
+    # Check if current directory is a git repo with autopilot config
+    if (current_dir / ".git").exists() and (
+        current_dir / ".autopilot" / "autopilot.json"
+    ).exists():
+        cfg = load_config(current_dir)
+        if cfg:
+            out.append(cfg)
+        return
+
+    # Recursively search subdirectories (depth-first)
+    try:
+        for child in sorted(current_dir.iterdir(), key=lambda p: p.name.lower()):
+            if not child.is_dir():
+                continue
+            if child.name in IGNORED_DIRS:
+                continue
+            _discover_repos_recursive(child, current_depth + 1, max_depth, out)
+    except PermissionError:
+        pass
+    except OSError:
+        pass
+
+
 def list_candidate_issues(cfg: RepoConfig, limit: int = 10) -> list[dict[str, Any]]:
+    """List candidate issues in the queue.
+
+    We exclude issues containing cfg.ignore_issue_labels (e.g. autopilot:backlog).
+    """
+
     # Sort by created date asc; prioritize p0/p1/p2 by label presence.
     q = " ".join([f"label:{l}" for l in cfg.queue_labels])
+    excludes = " ".join([f"-label:{l}" for l in cfg.ignore_issue_labels if l])
+    search = f"is:open {q} {excludes}".strip()
+
     cmd = [
         "gh",
         "issue",
@@ -101,13 +191,21 @@ def list_candidate_issues(cfg: RepoConfig, limit: int = 10) -> list[dict[str, An
         "--limit",
         str(limit),
         "--search",
-        f"is:open {q}",
+        search,
         "--json",
         "number,title,labels,updatedAt,createdAt,url",
     ]
     raw = sh(cmd)
     issues = json.loads(raw)
 
+    # Defense in depth in case GitHub search syntax changes.
+    ignore_set = set(cfg.ignore_issue_labels)
+    issues = [
+        it
+        for it in issues
+        if not ({l["name"] for l in it.get("labels", [])} & ignore_set)
+    ]
+
     def pri_rank(it: dict[str, Any]) -> int:
         labs = {l["name"] for l in it.get("labels", [])}
         for i, p in enumerate(cfg.priority_labels):
@@ -115,6 +213,11 @@ def list_candidate_issues(cfg: RepoConfig, limit: int = 10) -> list[dict[str, An
                 return i
         return 999
 
+    # Filter by minPriority if set
+    if cfg.min_priority and cfg.min_priority in cfg.priority_labels:
+        cutoff = cfg.priority_labels.index(cfg.min_priority)
+        issues = [it for it in issues if pri_rank(it) <= cutoff]
+
     issues.sort(key=lambda x: (pri_rank(x), x.get("createdAt", "")))
     return issues
 
@@ -147,7 +250,9 @@ def touch_heartbeat(cfg: RepoConfig, issue_number: int) -> None:
     """
     state = load_state(cfg.root)
     now = int(time.time())
-    state["activeIssue"] = {
+    if "activeIssues" not in state:
+        state["activeIssues"] = {}
+    state["activeIssues"][str(issue_number)] = {
         "number": issue_number,
         "updatedAt": now,
         "repo": cfg.repo,
@@ -157,7 +262,13 @@ def touch_heartbeat(cfg: RepoConfig, issue_number: int) -> None:
 
 def is_heartbeat_fresh(cfg: RepoConfig, issue_number: int) -> bool:
     state = load_state(cfg.root)
-    active = state.get("activeIssue")
+    active_issues = state.get("activeIssues", {})
+    if not isinstance(active_issues, dict):
+        return False
+    issue_key = str(issue_number)
+    if issue_key not in active_issues:
+        return False
+    active = active_issues[issue_key]
     if not isinstance(active, dict):
         return False
     if int(active.get("number", -1)) != int(issue_number):
@@ -234,58 +345,157 @@ def maybe_mark_blocked(cfg: RepoConfig, issue: dict[str, Any]) -> None:
     )
 
 
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--root", default="/mnt/f/Source")
-    ap.add_argument("--max-parallel", type=int, default=2)
-    ap.add_argument("--dry-run", action="store_true")
-    args = ap.parse_args()
+def run_cycle(
+    all_configs: list[RepoConfig],
+    dry_run: bool = False,
+) -> int:
+    """Run a single scan/claim/act cycle.
 
-    root = Path(args.root)
-    configs = discover_repos(root)
-    if not configs:
-        print("No autopilot-enabled repos found.")
-        return 0
+    Returns the number of issues claimed.
+    """
+    claimed_count = 0
 
-    for cfg in configs:
+    for cfg in all_configs:
         # 1) First, check any in-progress issues and mark blocked if stale.
         inprog = list_in_progress_issues(cfg)
         for it in inprog:
             # This is conservative: only mark blocked if we have no fresh local heartbeat.
-            if not args.dry_run:
+            if not dry_run:
                 maybe_mark_blocked(cfg, it)
 
-        # 2) If nothing is currently in progress, claim one from the queue.
-        # (We only support one active issue per repo in this MVP.)
-        if inprog:
+        # 2) Count active issues with fresh heartbeats from local state
+        state = load_state(cfg.root)
+        active_issues = state.get("activeIssues", {})
+        fresh_count = 0
+        if isinstance(active_issues, dict):
+            for issue_num_str, issue_data in active_issues.items():
+                if isinstance(issue_data, dict):
+                    issue_num = int(issue_data.get("number", -1))
+                    if is_heartbeat_fresh(cfg, issue_num):
+                        fresh_count += 1
+
+        # 3) Determine how many new issues we can claim (respect maxParallel)
+        max_to_claim = cfg.max_parallel - fresh_count
+        if max_to_claim <= 0:
             continue
 
+        # 4) Claim new issues from the queue (respecting priority labels)
         issues = list_candidate_issues(cfg)
         if not issues:
             continue
 
-        issue = issues[0]
-        msg = (
-            f"Autopilot claimed this issue at {time.strftime('%Y-%m-%d %H:%M:%S %Z')}.\n\n"
-            "Next: implement fix and open PR.\n\n"
-            "(Durable tracking: this repo will maintain `.autopilot/state.json` as a heartbeat; "
-            "the runner does not inspect processes.)"
-        )
-        print(f"[{cfg.repo}] next issue: #{issue['number']} {issue['title']}")
-        if args.dry_run:
-            continue
-        claim_issue(cfg, issue, msg)
-
-        # If agent==opencode, delegate to bash script
-        if cfg.agent == "opencode":
-            sh(
-                [
-                    "/home/kellye/clawd/repos/autopilot/scripts/run_opencode_issue.sh",
-                    str(cfg.root),
-                    str(issue["number"]),
-                ]
+        for issue in issues[:max_to_claim]:
+            msg = (
+                f"Autopilot claimed this issue at {time.strftime('%Y-%m-%d %H:%M:%S %Z')}.\n\n"
+                "Next: implement fix and open PR.\n\n"
+                "(Durable tracking: this repo will maintain `.autopilot/state.json` as a heartbeat; "
+                "the runner does not inspect processes.)"
             )
+            print(f"[{cfg.repo}] next issue: #{issue['number']} {issue['title']}")
+            if dry_run:
+                claimed_count += 1
+                continue
+            claim_issue(cfg, issue, msg)
+            claimed_count += 1
+
+            # If agent==opencode, delegate to bash script
+            if cfg.agent == "opencode":
+                sh(
+                    [
+                        "/home/kellye/clawd/repos/autopilot/scripts/run_opencode_issue.sh",
+                        str(cfg.root),
+                        str(issue["number"]),
+                    ]
+                )
+
+    return claimed_count
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--root",
+        nargs="+",
+        default=["/mnt/f/Source"],
+        help="One or more root folders to scan for git repos (space-separated)",
+    )
+    ap.add_argument("--max-parallel", type=int, default=2)
+    ap.add_argument(
+        "--max-depth",
+        type=int,
+        default=DEFAULT_MAX_DEPTH,
+        help=f"Maximum depth for recursive repo discovery (default: {DEFAULT_MAX_DEPTH})",
+    )
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument(
+        "--interval-seconds",
+        type=int,
+        default=None,
+        help="Run in loop mode with this interval between cycles (for foreground service mode)",
+    )
+    args = ap.parse_args()
+
+    all_configs: list[RepoConfig] = []
+    for root_str in args.root:
+        root = Path(root_str).resolve()
+        if not root.exists():
+            print(f"Warning: root path {root} does not exist, skipping")
+            continue
+        if not root.is_dir():
+            print(f"Warning: root path {root} is not a directory, skipping")
+            continue
+        configs = discover_repos(root, max_depth=args.max_depth)
+        all_configs.extend(configs)
+
+    if not all_configs:
+        print("No autopilot-enabled repos found.")
+        return 0
+
+    print(f"Found {len(all_configs)} autopilot-enabled repo(s)")
+    for cfg in all_configs:
+        print(f"  - {cfg.repo} at {cfg.root}")
+
+    # Loop mode (for foreground service)
+    if args.interval_seconds is not None:
+        shutdown_requested = False
+
+        def signal_handler(signum: int, frame: Any) -> None:
+            nonlocal shutdown_requested
+            print("\nShutdown requested (Ctrl+C), finishing current cycle...")
+            shutdown_requested = True
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        print(f"Running in foreground mode with {args.interval_seconds}s interval")
+        print("Press Ctrl+C to shut down cleanly\n")
+
+        cycle_num = 0
+        while not shutdown_requested:
+            cycle_num += 1
+            timestamp = time.strftime("%Y-%m-%d %H:%M:%S %Z")
+            print(f"\n=== Cycle {cycle_num} at {timestamp} ===")
+
+            try:
+                claimed = run_cycle(all_configs, dry_run=args.dry_run)
+                if claimed == 0:
+                    print("No issues claimed in this cycle")
+                else:
+                    print(f"Claimed {claimed} issue(s) in this cycle")
+            except Exception as e:
+                print(f"Error in cycle {cycle_num}: {e}")
+
+            if shutdown_requested:
+                break
+
+            print(f"Sleeping for {args.interval_seconds}s...")
+            time.sleep(args.interval_seconds)
+
+        print("\nShutdown complete")
+        return 0
 
+    # Single-shot mode (run-once)
+    run_cycle(all_configs, dry_run=args.dry_run)
     return 0
 
 

package/scripts/run_opencode_issue.sh

@@ -11,11 +11,23 @@ fi
 
 cd "$REPO_DIR"
 
-# Read repo name from config (prefer jq, fallback to python3)
+# Read config (prefer jq, fallback to python3)
 if command -v jq >/dev/null 2>&1; then
   REPO=$(jq -r '.repo' < .autopilot/autopilot.json)
+  AUTO_MERGE=$(jq -r '.autoMerge // true' < .autopilot/autopilot.json)
+  AUTO_RESOLVE_CONFLICTS=$(jq -r '.autoResolveConflicts // true' < .autopilot/autopilot.json)
+  CONFLICT_RESOLUTION_MAX_ATTEMPTS=$(jq -r '.conflictResolutionMaxAttempts // 3' < .autopilot/autopilot.json)
+  AUTO_FIX_CHECKS=$(jq -r '.autoFixChecks // true' < .autopilot/autopilot.json)
+  AUTO_FIX_CHECKS_MAX_ATTEMPTS=$(jq -r '.autoFixChecksMaxAttempts // 3' < .autopilot/autopilot.json)
+  ALLOWED_USERS=$(jq -r '.allowedMergeUsers[]' < .autopilot/autopilot.json 2>/dev/null || true)
 else
   REPO=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["repo"])')
+  AUTO_MERGE=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoMerge", True))')
+  AUTO_RESOLVE_CONFLICTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoResolveConflicts", True))')
+  CONFLICT_RESOLUTION_MAX_ATTEMPTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("conflictResolutionMaxAttempts", 3))')
+  AUTO_FIX_CHECKS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoFixChecks", True))')
+  AUTO_FIX_CHECKS_MAX_ATTEMPTS=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json")).get("autoFixChecksMaxAttempts", 3))')
+  ALLOWED_USERS=$(python3 -c 'import json,sys; users=json.load(open(".autopilot/autopilot.json")).get("allowedMergeUsers", []); print("\n".join(users))' 2>/dev/null || true)
 fi
 
 WORKTREE="/tmp/autopilot-issue-$ISSUE_NUMBER"
@@ -83,4 +95,283 @@ if [[ -n "$PR_URL" ]]; then
   gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "Autopilot opened PR: $PR_URL" || true
 fi
 
+# 8.5. Handle merge conflicts if auto-resolve is enabled
+if [[ "$AUTO_RESOLVE_CONFLICTS" == "true" ]] && [[ -n "$PR_URL" ]]; then
+  echo "[run_opencode_issue.sh] Checking for merge conflicts..."
+  
+  # Get PR merge status
+  MERGE_STATUS=$(gh pr view --repo "$REPO" --head "$BRANCH" --json mergeable,mergeStateStatus --jq '{mergeable, mergeStateStatus}' 2>/dev/null || echo '{"mergeable":"UNKNOWN"}')
+  
+  if command -v jq >/dev/null 2>&1; then
+    IS_CONFLICTING=$(echo "$MERGE_STATUS" | jq -r 'if .mergeable == "CONFLICTING" or .mergeStateStatus == "DIRTY" then "true" else "false" end')
+  else
+    IS_CONFLICTING=$(python3 -c 'import json,sys; d=json.load(sys.stdin); print("true" if d.get("mergeable") == "CONFLICTING" or d.get("mergeStateStatus") == "DIRTY" else "false")' <<<"$MERGE_STATUS")
+  fi
+  
+  if [[ "$IS_CONFLICTING" == "true" ]]; then
+    echo "[run_opencode_issue.sh] PR has merge conflicts. Attempting auto-resolution..."
+    
+    RESOLVE_ATTEMPT=0
+    MAX_ATTEMPTS=$((CONFLICT_RESOLUTION_MAX_ATTEMPTS + 0))
+    
+    while [[ $RESOLVE_ATTEMPT -lt $MAX_ATTEMPTS ]]; do
+      RESOLVE_ATTEMPT=$((RESOLVE_ATTEMPT + 1))
+      echo "[run_opencode_issue.sh] Conflict resolution attempt $RESOLVE_ATTEMPT/$MAX_ATTEMPTS"
+      
+      # Fetch latest main
+      echo "[run_opencode_issue.sh] Fetching latest main..."
+      git fetch origin main || true
+      
+      # Checkout branch and try to rebase
+      echo "[run_opencode_issue.sh] Rebasing branch onto main..."
+      cd "$WORKTREE"
+      if git rebase origin/main; then
+        echo "[run_opencode_issue.sh] Rebase successful."
+        
+        # Push rebased changes
+        git push -f origin "$BRANCH" || true
+        
+        # Check if conflicts are resolved
+        MERGE_STATUS=$(gh pr view --repo "$REPO" --head "$BRANCH" --json mergeable,mergeStateStatus --jq '{mergeable, mergeStateStatus}' 2>/dev/null || echo '{"mergeable":"UNKNOWN"}')
+        
+        if command -v jq >/dev/null 2>&1; then
+          IS_CONFLICTING=$(echo "$MERGE_STATUS" | jq -r 'if .mergeable == "CONFLICTING" or .mergeStateStatus == "DIRTY" then "true" else "false" end')
+        else
+          IS_CONFLICTING=$(python3 -c 'import json,sys; d=json.load(sys.stdin); print("true" if d.get("mergeable") == "CONFLICTING" or d.get("mergeStateStatus") == "DIRTY" else "false")' <<<"$MERGE_STATUS")
+        fi
+        
+        if [[ "$IS_CONFLICTING" == "false" ]]; then
+          echo "[run_opencode_issue.sh] Conflicts resolved successfully."
+          gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "✅ Autopilot successfully resolved merge conflicts." || true
+          break
+        fi
+      else
+        # Rebase failed - there are conflicts to resolve
+        echo "[run_opencode_issue.sh] Rebase encountered conflicts. Attempting resolution with agent..."
+        
+        # Abort the rebase to get back to a clean state
+        git rebase --abort 2>/dev/null || true
+        
+        # Try merging main instead (may be easier to resolve)
+        if git merge origin/main; then
+          echo "[run_opencode_issue.sh] Merge successful."
+          git push -f origin "$BRANCH" || true
+          
+          # Check if conflicts are resolved
+          MERGE_STATUS=$(gh pr view --repo "$REPO" --head "$BRANCH" --json mergeable,mergeStateStatus --jq '{mergeable, mergeStateStatus}' 2>/dev/null || echo '{"mergeable":"UNKNOWN"}')
+          
+          if command -v jq >/dev/null 2>&1; then
+            IS_CONFLICTING=$(echo "$MERGE_STATUS" | jq -r 'if .mergeable == "CONFLICTING" or .mergeStateStatus == "DIRTY" then "true" else "false" end')
+          else
+            IS_CONFLICTING=$(python3 -c 'import json,sys; d=json.load(sys.stdin); print("true" if d.get("mergeable") == "CONFLICTING" or d.get("mergeStateStatus") == "DIRTY" else "false")' <<<"$MERGE_STATUS")
+          fi
+          
+          if [[ "$IS_CONFLICTING" == "false" ]]; then
+            echo "[run_opencode_issue.sh] Conflicts resolved successfully."
+            gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "✅ Autopilot successfully resolved merge conflicts." || true
+            break
+          fi
+        else
+          # Merge also has conflicts - abort and try to resolve with agent
+          git merge --abort 2>/dev/null || true
+          
+          echo "[run_opencode_issue.sh] Attempting to resolve conflicts with opencode agent..."
+          
+          # Use opencode to resolve conflicts
+          CONFLICT_PROMPT="This PR has merge conflicts. Please resolve them by examining the conflicted files and making the necessary edits to resolve the conflicts. Follow these steps:
+1. Run 'git status' to see all conflicted files
+2. For each conflicted file, examine the conflict markers (<<<<<<<, =======, >>>>>>>)
+3. Resolve the conflicts by choosing the appropriate code
+4. Stage the resolved files with 'git add <file>'
+5. Commit the resolved files if needed
+6. The goal is to make the branch mergeable with main
+
+After resolving all conflicts, report the files that were resolved."
+          
+          if opencode run "$CONFLICT_PROMPT"; then
+            # Check if there are still conflicts
+            if [[ -z "$(git diff --name-only --diff-filter=U)" ]]; then
+              echo "[run_opencode_issue.sh] Conflicts resolved by agent."
+              
+              # Complete the merge or rebase
+              git add -A
+              
+              # If we were in the middle of a merge, complete it
+              if [[ -f ".git/MERGE_HEAD" ]]; then
+                git commit --no-edit || true
+              fi
+              
+              # Push resolved changes
+              git push -f origin "$BRANCH" || true
+              
+              # Check if conflicts are resolved
+              MERGE_STATUS=$(gh pr view --repo "$REPO" --head "$BRANCH" --json mergeable,mergeStateStatus --jq '{mergeable, mergeStateStatus}' 2>/dev/null || echo '{"mergeable":"UNKNOWN"}')
+              
+              if command -v jq >/dev/null 2>&1; then
+                IS_CONFLICTING=$(echo "$MERGE_STATUS" | jq -r 'if .mergeable == "CONFLICTING" or .mergeStateStatus == "DIRTY" then "true" else "false" end')
+              else
+                IS_CONFLICTING=$(python3 -c 'import json,sys; d=json.load(sys.stdin); print("true" if d.get("mergeable") == "CONFLICTING" or d.get("mergeStateStatus") == "DIRTY" else "false")' <<<"$MERGE_STATUS")
+              fi
+              
+              if [[ "$IS_CONFLICTING" == "false" ]]; then
+                echo "[run_opencode_issue.sh] Conflicts resolved successfully."
+                gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "✅ Autopilot successfully resolved merge conflicts." || true
+                break
+              fi
+            fi
+          fi
+        fi
+      fi
+      
+      # If we're here, resolution failed and we should try again
+      echo "[run_opencode_issue.sh] Conflict resolution attempt $RESOLVE_ATTEMPT failed."
+      
+      if [[ $RESOLVE_ATTEMPT -ge $MAX_ATTEMPTS ]]; then
+        echo "[run_opencode_issue.sh] Failed to resolve conflicts after $MAX_ATTEMPTS attempts."
+        
+        # Mark issue as blocked
+        if command -v jq >/dev/null 2>&1; then
+          LABEL_BLOCKED=$(jq -r '.issueLabels.blocked' < .autopilot/autopilot.json)
+        else
+          LABEL_BLOCKED=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["issueLabels"]["blocked"])')
+        fi
+        
+        BLOCKED_MSG="❌ Autopilot failed to resolve merge conflicts after $MAX_ATTEMPTS attempts.\n\nThe PR will remain open but autopilot has stopped attempting to resolve conflicts.\n\nTo resolve manually:\n1. Checkout the branch: \`git checkout $BRANCH\`\n2. Fetch and rebase main: \`git fetch origin main && git rebase origin/main\`\n3. Resolve conflicts as needed\n4. Push resolved changes: \`git push -f origin $BRANCH\`\n\nOnce resolved, autopilot can attempt to merge the PR."
+        
+        gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$BLOCKED_MSG" || true
+        gh issue edit "$ISSUE_NUMBER" --repo "$REPO" --add-label "$LABEL_BLOCKED" || true
+        
+        exit 1
+      fi
+      
+      # Wait a bit before next attempt
+      sleep 5
+    done
+  fi
+fi
+
+# 9. Auto-merge if enabled and user is allowed
+if [[ "$AUTO_MERGE" == "true" ]] && [[ -n "$PR_URL" ]]; then
+  # Get authenticated GitHub user
+  AUTH_USER=$(gh api user --jq .login)
+
+  # Check if user is in allowed list
+  USER_ALLOWED=false
+  if [[ -n "$ALLOWED_USERS" ]]; then
+    while IFS= read -r user; do
+      if [[ "$AUTH_USER" == "$user" ]]; then
+        USER_ALLOWED=true
+        break
+      fi
+    done <<< "$ALLOWED_USERS"
+  fi
+
+  if [[ "$USER_ALLOWED" == "true" ]]; then
+    echo "[run_opencode_issue.sh] Auto-merge enabled. Waiting for PR checks to pass..."
+    
+    # Initialize auto-fix attempt counter
+    FIX_ATTEMPT=0
+    
+    # Poll PR checks until they pass or fail
+    MAX_POLL_ATTEMPTS=60
+    POLL_INTERVAL=30
+    POLL_ATTEMPT=0
+    
+    while [[ $POLL_ATTEMPT -lt $MAX_POLL_ATTEMPTS ]]; do
+      POLL_ATTEMPT=$((POLL_ATTEMPT + 1))
+      
+      # Get PR check status
+      CHECK_STATUS=$(gh pr view --repo "$REPO" --head "$BRANCH" --json mergeable,mergeStateStatus,statusCheckRollup --jq '.statusCheckRollup | map(.conclusion) | if any(. == "FAILURE") then "FAILED" elif any(. == "PENDING") or any(. == "QUEUED") then "PENDING" else "PASSED" end' 2>/dev/null || echo "PENDING")
+      
+      echo "[run_opencode_issue.sh] Poll attempt $POLL_ATTEMPT/$MAX_POLL_ATTEMPTS: Check status = $CHECK_STATUS"
+      
+      if [[ "$CHECK_STATUS" == "PASSED" ]]; then
+        echo "[run_opencode_issue.sh] All checks passed. Proceeding with merge..."
+        break
+      elif [[ "$CHECK_STATUS" == "FAILED" ]]; then
+        echo "[run_opencode_issue.sh] PR checks failed."
+        
+        # Check if auto-fix is enabled
+        if [[ "$AUTO_FIX_CHECKS" == "true" ]] && [[ $FIX_ATTEMPT -lt $AUTO_FIX_CHECKS_MAX_ATTEMPTS ]]; then
+          FIX_ATTEMPT=$((FIX_ATTEMPT + 1))
+          echo "[run_opencode_issue.sh] Auto-fix enabled. Attempting to fix failing checks ($FIX_ATTEMPT/$AUTO_FIX_CHECKS_MAX_ATTEMPTS)..."
+          
+          # Fetch failed check details and logs
+          CHECK_RUNS_JSON=$(gh api "repos/$REPO/commits/$(git rev-parse HEAD)/check-runs" --jq '.check_runs[] | select(.conclusion == "FAILURE") | {name: .name, conclusion: .conclusion, details_url: .details_url, output: {title: .output.title, summary: .output.summary, text: .output.text}}' 2>/dev/null || echo "[]")
+          
+          # Build failure context
+          FAILURE_CONTEXT="The following CI checks failed:\n"
+          
+          # Add failure details to context
+          if [[ -n "$CHECK_RUNS_JSON" ]]; then
+            FAILURE_CONTEXT+="$CHECK_RUNS_JSON\n"
+          fi
+          
+          # Generate repair prompt
+          REPAIR_PROMPT="The PR checks have failed. Please analyze the CI failures and fix the issues.\n\n$FAILURE_CONTEXT\n\nWork rules:\n- Examine the failed checks and identify the root cause\n- Make the necessary code changes to fix the failures\n- Commit with message: \"autopilot: fix CI check failures (attempt $FIX_ATTEMPT/$AUTO_FIX_CHECKS_MAX_ATTEMPTS)\"\n- Push your changes to the branch $BRANCH\n- Focus only on fixing the CI failures, do not make unrelated changes"
+          
+          echo "[run_opencode_issue.sh] Running opencode agent to fix CI failures..."
+          
+          # Run opencode to fix the issue
+          cd "$WORKTREE"
+          if opencode run "$REPAIR_PROMPT"; then
+            # Commit any changes
+            if [[ -n "$(git status --porcelain)" ]]; then
+              git add -A
+              git commit -m "autopilot: fix CI check failures (attempt $FIX_ATTEMPT/$AUTO_FIX_CHECKS_MAX_ATTEMPTS)"
+              echo "[run_opencode_issue.sh] Committed fixes for CI failures."
+              
+              # Push changes
+              git push origin "$BRANCH"
+              echo "[run_opencode_issue.sh] Pushed fixes for CI failures."
+              
+              # Reset poll counter to re-check CI status
+              POLL_ATTEMPT=0
+              
+              # Wait a moment for checks to start
+              sleep 10
+              
+              # Continue polling
+              continue
+            else
+              echo "[run_opencode_issue.sh] No changes made by opencode agent."
+            fi
+          else
+            echo "[run_opencode_issue.sh] Opencode agent failed to fix CI issues."
+          fi
+          
+          # If we're here, auto-fix failed or made no changes
+          gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "⚠️ Autopilot attempted to fix CI failures (attempt $FIX_ATTEMPT/$AUTO_FIX_CHECKS_MAX_ATTEMPTS) but was unable to resolve all issues." || true
+        fi
+        
+        # If auto-fix is disabled or max attempts reached, fail
+        if [[ "$FIX_ATTEMPT" -ge "$AUTO_FIX_CHECKS_MAX_ATTEMPTS" ]]; then
+          FAILED_MSG="❌ Autopilot cannot auto-merge PR: checks failed after $AUTO_FIX_CHECKS_MAX_ATTEMPTS auto-fix attempts.\n\nPR will remain open for review."
+        else
+          FAILED_MSG="❌ Autopilot cannot auto-merge PR: checks failed (auto-fix disabled).\n\nPR will remain open for review."
+        fi
+        gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$FAILED_MSG" || true
+        exit 1
+      fi
+      
+      # Wait before next poll
+      if [[ $POLL_ATTEMPT -lt $MAX_POLL_ATTEMPTS ]]; then
+        echo "[run_opencode_issue.sh] Waiting ${POLL_INTERVAL}s before next check..."
+        sleep "$POLL_INTERVAL"
+      fi
+    done
+  else
+    BLOCKED_MSG="❌ Autopilot cannot auto-merge PR: authenticated user '$AUTH_USER' is not in the allowedMergeUsers list."
+    gh issue comment "$ISSUE_NUMBER" --repo "$REPO" --body "$BLOCKED_MSG" || true
+    
+    # Mark issue as blocked
+    if command -v jq >/dev/null 2>&1; then
+      LABEL_BLOCKED=$(jq -r '.issueLabels.blocked' < .autopilot/autopilot.json)
+    else
+      LABEL_BLOCKED=$(python3 -c 'import json; print(json.load(open(".autopilot/autopilot.json"))["issueLabels"]["blocked"])')
+    fi
+    gh issue edit "$ISSUE_NUMBER" --repo "$REPO" --add-label "$LABEL_BLOCKED" || true
+  fi
+fi
+
 echo "[run_opencode_issue.sh] Done: $PR_URL"

package/templates/autopilot.json

@@ -1,6 +1,8 @@
 {
   "enabled": true,
   "repo": "bakkensoftware/TicketToolbox",
+  "agent": "opencode",
+  "allowedMergeUsers": ["github-username"],
   "issueLabels": {
     "queue": ["autopilot:todo"],
     "blocked": "autopilot:blocked",
@@ -9,6 +11,11 @@
   },
   "priorityLabels": ["p0", "p1", "p2"],
   "maxParallel": 2,
+  "ignoreIssueLabels": ["autopilot:backlog"],
   "branchPrefix": "autopilot/",
-  "allowedBaseBranch": "main"
+  "allowedBaseBranch": "main",
+  "autoResolveConflicts": true,
+  "conflictResolutionMaxAttempts": 3,
+  "autoFixChecks": true,
+  "autoFixChecksMaxAttempts": 3
 }