autopilot-code 0.0.5 → 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,8 @@ 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.
 
@@ -117,13 +121,10 @@ 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

@@ -14,6 +14,8 @@ const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.j
 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)
@@ -107,6 +109,150 @@ async function collectSourceFolders() {
     }
     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();
@@ -232,4 +378,34 @@ program
         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.5",
+  "version": "0.0.6",
   "private": false,
   "description": "Repo-issue–driven autopilot runner",
   "license": "MIT",

package/scripts/run_autopilot.py

@@ -76,6 +76,13 @@ class RepoConfig:
     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:
@@ -89,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"],
@@ -104,6 +126,13 @@ def load_config(repo_root: Path) -> RepoConfig | None:
         ),
         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,
     )
 
 
@@ -184,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
 
@@ -216,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,
@@ -226,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):
@@ -321,37 +363,50 @@ def run_cycle(
             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 dry_run:
-            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"]),
-                ]
+        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
 

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",
@@ -11,5 +13,9 @@
   "maxParallel": 2,
   "ignoreIssueLabels": ["autopilot:backlog"],
   "branchPrefix": "autopilot/",
-  "allowedBaseBranch": "main"
+  "allowedBaseBranch": "main",
+  "autoResolveConflicts": true,
+  "conflictResolutionMaxAttempts": 3,
+  "autoFixChecks": true,
+  "autoFixChecksMaxAttempts": 3
 }