@northflare/runner 0.0.28 → 0.0.30

package/dist/components/enhanced-repository-manager.js

@@ -19,17 +19,30 @@
 import { RepositoryManager } from './repository-manager.js';
 import path from "path";
 import fs from "fs/promises";
+import crypto from "crypto";
 import { simpleGit } from "simple-git";
 import { createScopedConsole } from '../utils/console.js';
+import { createLogger } from '../utils/logger.js';
 const console = createScopedConsole("repo");
+const logger = createLogger("EnhancedRepositoryManager", "repo");
 export class EnhancedRepositoryManager extends RepositoryManager {
     repoStates;
     stateFilePath;
+    legacyStateFilePath;
+    repoLocks;
+    taskWorktreesBasePath;
     constructor(runner) {
         super(runner);
         this.repoStates = new Map();
-        // this.repoBasePath is set by parent constructor, so we can use it now
-        this.stateFilePath = path.join(this.repoBasePath, "repository-state.json");
+        this.repoLocks = new Map();
+        const dataDir = runner.config_.dataDir;
+        const runnerId = runner.getRunnerId();
+        const stateFileName = runnerId
+            ? `repository-state-${runnerId}.json`
+            : "repository-state.json";
+        this.stateFilePath = path.join(dataDir, "git", stateFileName);
+        this.legacyStateFilePath = path.join(this.repoBasePath, "repository-state.json");
+        this.taskWorktreesBasePath = path.join(dataDir, "git", "worktrees");
         // Load persisted state on initialization
         this.restoreState().catch((err) => {
             console.error("Failed to restore repository state:", err);
@@ -42,9 +55,13 @@ export class EnhancedRepositoryManager extends RepositoryManager {
         // Handle local repository URLs
         if (repoUrl.startsWith("file://")) {
             const localPath = repoUrl.replace("file://", "");
-            const pathParts = localPath.split("/");
-            const repoName = pathParts[pathParts.length - 1] || "local";
-            return { key: `local__${repoName}`, owner: "local", repo: repoName };
+            const repoName = path.basename(localPath) || "local";
+            const digest = crypto
+                .createHash("sha1")
+                .update(localPath)
+                .digest("hex")
+                .slice(0, 12);
+            return { key: `local__${repoName}__${digest}`, owner: "local", repo: repoName };
         }
         // Extract owner and repo from URL
         const match = repoUrl.match(/github\.com[:/]([^/]+)\/([^/.]+)(\.git)?$/);
@@ -56,6 +73,41 @@ export class EnhancedRepositoryManager extends RepositoryManager {
         const key = `${owner}__${repo}`;
         return { key, owner, repo };
     }
+    parseRepoKey(repoKey) {
+        const parts = repoKey.split("__");
+        const owner = parts[0] || repoKey;
+        const repo = parts[1] || repoKey;
+        return { owner, repo };
+    }
+    findTaskStateEntry(taskId) {
+        for (const [repoKey, state] of this.repoStates) {
+            const repo = state.repositories[repoKey];
+            const taskState = repo?.worktrees?.[taskId];
+            if (repo && taskState) {
+                return { repoKey, repo, taskState };
+            }
+        }
+        return null;
+    }
+    async withRepoLock(repoKey, fn) {
+        const previous = this.repoLocks.get(repoKey) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const chained = previous.then(() => current);
+        this.repoLocks.set(repoKey, chained);
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            if (this.repoLocks.get(repoKey) === chained) {
+                this.repoLocks.delete(repoKey);
+            }
+        }
+    }
     /**
      * Ensure control repository exists
      */
@@ -64,7 +116,18 @@ export class EnhancedRepositoryManager extends RepositoryManager {
         const controlPath = path.join(this.repoBasePath, "repos", key, "control");
         // Check if control repository already exists
         try {
-            await fs.access(path.join(controlPath, ".git"));
+            // Support both bare repos (config/objects at root) and legacy non-bare repos (.git/)
+            const hasGitDir = await fs
+                .access(path.join(controlPath, ".git"))
+                .then(() => true)
+                .catch(() => false);
+            const hasBareLayout = await fs
+                .access(path.join(controlPath, "config"))
+                .then(() => fs.access(path.join(controlPath, "objects")).then(() => true))
+                .catch(() => false);
+            if (!hasGitDir && !hasBareLayout) {
+                throw new Error("missing");
+            }
             console.log(`Control repository already exists for ${key}`);
             // Update remote URL if token changed
             if (githubToken) {
@@ -83,9 +146,6 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             await this.ensureDirectory(path.dirname(controlPath));
             const authUrl = this.getAuthenticatedUrl(repoUrl, githubToken);
             await this.executeGit(["clone", "--bare", authUrl, controlPath]);
-            // Convert to regular repository for worktree support
-            const git = simpleGit(controlPath);
-            await git.raw(["config", "--bool", "core.bare", "false"]);
             console.log(`Successfully created control repository for ${key}`);
             return controlPath;
         }
@@ -121,51 +181,121 @@ export class EnhancedRepositoryManager extends RepositoryManager {
      * Create a task-specific worktree
      */
     async createTaskWorktree(taskId, workspaceId, repoUrl, baseBranch = "main", githubToken) {
-        // For local repositories, just return the path without creating worktrees
-        if (repoUrl.startsWith("file://")) {
-            const localPath = repoUrl.replace("file://", "");
-            console.log(`Using local repository for task ${taskId}: ${localPath}`);
-            // Verify the path exists
+        const { key, owner, repo } = this.getRepoKey(repoUrl);
+        // Reuse an existing worktree/branch for this task when possible
+        const existing = this.findTaskStateEntry(taskId);
+        if (existing && existing.repoKey !== "__local__" && existing.taskState.branch !== "local") {
+            const expectedWorktreePath = path.join(this.taskWorktreesBasePath, existing.repoKey, `task_${taskId}`);
+            const worktreePath = existing.taskState.worktreePath || expectedWorktreePath;
+            const shouldPersistMetadata = existing.taskState.workspaceId !== workspaceId ||
+                existing.taskState.baseBranch !== baseBranch;
+            if (shouldPersistMetadata) {
+                existing.taskState.workspaceId = workspaceId;
+                existing.taskState.baseBranch = baseBranch;
+                existing.taskState.updatedAt = new Date();
+                await this.updateTaskStateByTaskId(taskId, existing.taskState);
+            }
             try {
-                const stats = await fs.stat(localPath);
-                if (!stats.isDirectory()) {
-                    throw new Error(`Path is not a directory: ${localPath}`);
-                }
+                await fs.access(worktreePath);
+                return {
+                    taskId,
+                    worktreePath,
+                    branch: existing.taskState.branch,
+                    baseBranch: existing.taskState.baseBranch,
+                };
             }
-            catch (error) {
-                console.error(`Local repository path not found: ${localPath}`);
-                throw new Error(`Local repository path not found: ${localPath}`);
+            catch {
+                // Recreate missing worktree from the existing branch
+                const git = simpleGit(existing.repo.controlPath);
+                await this.ensureDirectory(path.dirname(worktreePath));
+                try {
+                    await git.raw(["worktree", "add", worktreePath, existing.taskState.branch]);
+                }
+                catch (error) {
+                    console.error(`Failed to recreate worktree for task ${taskId}:`, error);
+                    await this.cleanupDirectory(worktreePath);
+                    throw error;
+                }
+                const worktreeGit = simpleGit(worktreePath);
+                await worktreeGit.addConfig("user.name", "Northflare");
+                await worktreeGit.addConfig("user.email", "runner@northflare.ai");
+                existing.taskState.worktreePath = worktreePath;
+                existing.taskState.workspaceId = workspaceId;
+                existing.taskState.baseBranch = baseBranch;
+                existing.taskState.status = "active";
+                existing.taskState.updatedAt = new Date();
+                await this.updateTaskState(existing.repoKey, existing.taskState);
+                return {
+                    taskId,
+                    worktreePath,
+                    branch: existing.taskState.branch,
+                    baseBranch: existing.taskState.baseBranch,
+                };
             }
-            return {
-                taskId,
-                worktreePath: localPath,
-                branch: "local",
-                baseBranch: "local",
-            };
         }
-        const { key } = this.getRepoKey(repoUrl);
+        const isLocalRepo = repoUrl.startsWith("file://");
         // Ensure control repository exists
-        const controlPath = await this.ensureControlRepository(repoUrl, githubToken);
-        const worktreesPath = path.join(this.repoBasePath, "repos", key, "worktrees");
+        let controlPath;
+        if (isLocalRepo) {
+            controlPath = repoUrl.replace("file://", "");
+            // Verify local path exists and has a Git directory
+            const stats = await fs.stat(controlPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`Local repository path is not a directory: ${controlPath}`);
+            }
+            await fs.access(path.join(controlPath, ".git"));
+        }
+        else {
+            controlPath = await this.ensureControlRepository(repoUrl, githubToken);
+        }
+        const worktreesPath = path.join(this.taskWorktreesBasePath, key);
         const taskWorktreePath = path.join(worktreesPath, `task_${taskId}`);
         // Create unique branch name for the task
-        const timestamp = Date.now();
-        const shortTaskId = taskId.substring(0, 8);
-        const branchName = `task/${shortTaskId}-${timestamp}`;
+        const branchName = `task/${taskId}`;
         try {
             console.log(`Creating worktree for task ${taskId} on branch ${branchName}...`);
             // Create worktree directory
             await this.ensureDirectory(worktreesPath);
             // Add worktree with new branch based on baseBranch
             const git = simpleGit(controlPath);
-            await git.raw([
-                "worktree",
-                "add",
-                "-b",
-                branchName,
-                taskWorktreePath,
-                `origin/${baseBranch}`,
-            ]);
+            const baseRef = isLocalRepo ? baseBranch : `origin/${baseBranch}`;
+            let baseRefIsValid = await git
+                .raw(["rev-parse", "--verify", `${baseRef}^{commit}`])
+                .then(() => true)
+                .catch(() => false);
+            if (!baseRefIsValid) {
+                const hasAnyCommit = await git
+                    .raw(["rev-parse", "--verify", "HEAD^{commit}"])
+                    .then(() => true)
+                    .catch(() => false);
+                if (!hasAnyCommit) {
+                    await this.ensureInitialCommitOnBranch(controlPath, baseBranch);
+                    baseRefIsValid = await git
+                        .raw(["rev-parse", "--verify", `${baseRef}^{commit}`])
+                        .then(() => true)
+                        .catch(() => false);
+                }
+                if (!baseRefIsValid) {
+                    throw new Error(`Cannot create a task worktree for ${taskId}: base branch '${baseBranch}' is not a valid Git reference in ${controlPath}. Set Workspace → Settings → Git branch to an existing branch name and retry.`);
+                }
+            }
+            const branchExists = await git
+                .raw(["show-ref", "--verify", `refs/heads/${branchName}`])
+                .then(() => true)
+                .catch(() => false);
+            if (branchExists) {
+                await git.raw(["worktree", "add", taskWorktreePath, branchName]);
+            }
+            else {
+                await git.raw([
+                    "worktree",
+                    "add",
+                    "-b",
+                    branchName,
+                    taskWorktreePath,
+                    baseRef,
+                ]);
+            }
             // Configure the worktree
             const worktreeGit = simpleGit(taskWorktreePath);
             await worktreeGit.addConfig("user.name", "Northflare");
@@ -173,6 +303,7 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             // Create and persist state
             const state = {
                 taskId,
+                workspaceId,
                 branch: branchName,
                 baseBranch,
                 worktreePath: taskWorktreePath,
@@ -180,7 +311,7 @@ export class EnhancedRepositoryManager extends RepositoryManager {
                 createdAt: new Date(),
                 updatedAt: new Date(),
             };
-            await this.updateTaskState(key, state);
+            await this.updateTaskState(key, state, { owner, repo, controlPath });
             console.log(`Successfully created worktree for task ${taskId}`);
             return {
                 taskId,
@@ -196,25 +327,50 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             throw error;
         }
     }
+    async ensureInitialCommitOnBranch(repoPath, branchName) {
+        const git = simpleGit(repoPath);
+        await git.addConfig("user.name", "Northflare");
+        await git.addConfig("user.email", "runner@northflare.ai");
+        const hasAnyCommit = await git
+            .raw(["rev-parse", "--verify", "HEAD^{commit}"])
+            .then(() => true)
+            .catch(() => false);
+        if (hasAnyCommit)
+            return;
+        console.log(`Repository at ${repoPath} has no commits; creating an empty initial commit on '${branchName}'...`);
+        const isBareRepo = await git
+            .raw(["rev-parse", "--is-bare-repository"])
+            .then((output) => output.trim() === "true")
+            .catch(() => false);
+        if (isBareRepo) {
+            const emptyTreeHash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+            const commitHash = (await git.raw([
+                "commit-tree",
+                emptyTreeHash,
+                "-m",
+                "Initial commit",
+            ])).trim();
+            await git.raw(["update-ref", `refs/heads/${branchName}`, commitHash]);
+            await git.raw(["symbolic-ref", "HEAD", `refs/heads/${branchName}`]);
+            const remotes = await git.getRemotes(true);
+            const hasOrigin = remotes.some((remote) => remote.name === "origin");
+            void hasOrigin;
+        }
+        else {
+            await git.raw(["checkout", "--orphan", branchName]);
+            await git.raw(["commit", "--allow-empty", "-m", "Initial commit"]);
+        }
+    }
     /**
      * Remove a task worktree
      */
     async removeTaskWorktree(taskId, options = {}) {
-        // Find the task state across all repositories
-        let repoKey = null;
-        let taskState = null;
-        for (const [key, state] of this.repoStates) {
-            const repo = state.repositories[key];
-            if (repo?.worktrees[taskId]) {
-                repoKey = key;
-                taskState = repo.worktrees[taskId];
-                break;
-            }
-        }
-        if (!repoKey || !taskState) {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry) {
             console.log(`No worktree found for task ${taskId}`);
             return;
         }
+        const { repoKey, repo, taskState } = entry;
         // Handle local workspaces differently
         if (repoKey === "__local__") {
             // Just remove from state, don't touch the filesystem
@@ -227,13 +383,24 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             console.log(`Removed local task handle for task ${taskId}`);
             return;
         }
-        const { key } = this.getRepoKey(repoKey);
-        const controlPath = path.join(this.repoBasePath, "repos", key, "control");
+        const controlPath = repo.controlPath;
         try {
             console.log(`Removing worktree for task ${taskId}...`);
-            // Remove the worktree
             const git = simpleGit(controlPath);
-            await git.raw(["worktree", "remove", taskState.worktreePath, "--force"]);
+            // Remove the worktree (when present)
+            if (taskState.worktreePath) {
+                const worktreePath = taskState.worktreePath;
+                try {
+                    await fs.access(worktreePath);
+                    await git.raw(["worktree", "remove", worktreePath, "--force"]);
+                }
+                catch {
+                    // Worktree path already gone; continue so we can still delete the branch if needed
+                }
+                finally {
+                    await this.cleanupDirectory(worktreePath);
+                }
+            }
             // Delete the branch if not preserving
             if (!options.preserveBranch) {
                 try {
@@ -243,10 +410,19 @@ export class EnhancedRepositoryManager extends RepositoryManager {
                     console.warn(`Failed to delete branch ${taskState.branch}:`, error);
                 }
             }
-            // Remove from state
+            // Update state
             const repoState = this.repoStates.get(repoKey);
-            if (repoState?.repositories[key]?.worktrees) {
-                delete repoState.repositories[key].worktrees[taskId];
+            if (repoState?.repositories[repoKey]?.worktrees) {
+                if (options.preserveBranch) {
+                    repoState.repositories[repoKey].worktrees[taskId] = {
+                        ...taskState,
+                        worktreePath: "",
+                        updatedAt: new Date(),
+                    };
+                }
+                else {
+                    delete repoState.repositories[repoKey].worktrees[taskId];
+                }
             }
             await this.persistState();
             console.log(`Successfully removed worktree for task ${taskId}`);
@@ -303,9 +479,17 @@ export class EnhancedRepositoryManager extends RepositoryManager {
         const commitHash = result.commit;
         // Update task state
         taskState.lastCommit = commitHash;
+        taskState.commitCount = (taskState.commitCount ?? 0) + 1;
         taskState.updatedAt = new Date();
         await this.updateTaskStateByTaskId(taskId, taskState);
         console.log(`Created commit ${commitHash} for task ${taskId}`);
+        logger.info(`Committed task ${taskId} (${taskState.branch}) -> ${commitHash}`, {
+            taskId,
+            branch: taskState.branch,
+            baseBranch: taskState.baseBranch,
+            commit: commitHash,
+            worktreePath: taskState.worktreePath,
+        });
         return commitHash;
     }
     /**
@@ -344,19 +528,44 @@ export class EnhancedRepositoryManager extends RepositoryManager {
         }
         const git = simpleGit(taskState.worktreePath);
         try {
-            // Fetch latest changes
-            await git.fetch("origin", targetBranch);
-            // Perform rebase
-            await git.rebase([`origin/${targetBranch}`]);
+            const remotes = await git.getRemotes(true);
+            const hasOrigin = remotes.some((r) => r.name === "origin");
+            logger.info(`Rebasing task ${taskId} (${taskState.branch}) onto ${targetBranch}`, {
+                taskId,
+                branch: taskState.branch,
+                targetBranch,
+                hasOrigin,
+                worktreePath: taskState.worktreePath,
+            });
+            if (hasOrigin) {
+                // Fetch latest changes
+                await git.fetch("origin", targetBranch);
+                // Perform rebase
+                await git.rebase([`origin/${targetBranch}`]);
+            }
+            else {
+                await git.rebase([targetBranch]);
+            }
             // Update base branch in state
             taskState.baseBranch = targetBranch;
             taskState.updatedAt = new Date();
             await this.updateTaskStateByTaskId(taskId, taskState);
             console.log(`Successfully rebased task ${taskId} onto ${targetBranch}`);
+            logger.info(`Rebased task ${taskId} (${taskState.branch}) onto ${targetBranch}`, {
+                taskId,
+                branch: taskState.branch,
+                targetBranch,
+            });
             return { success: true };
         }
         catch (error) {
             console.error(`Rebase failed for task ${taskId}:`, error);
+            logger.error(`Rebase failed for task ${taskId} (${taskState.branch})`, {
+                taskId,
+                branch: taskState.branch,
+                targetBranch,
+                error: error instanceof Error ? error.message : String(error),
+            });
             // Check for conflicts
             const status = await git.status();
             if (status.conflicted.length > 0) {
@@ -385,22 +594,83 @@ export class EnhancedRepositoryManager extends RepositoryManager {
      * Merge a task branch into target branch
      */
     async mergeTask(taskId, targetBranch, mode = "no-ff") {
-        const taskState = await this.getTaskState(taskId);
-        if (!taskState) {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry) {
             throw new Error(`No worktree found for task ${taskId}`);
         }
+        const { repoKey, taskState } = entry;
         // Skip Git operations for local workspaces
         if (taskState.branch === "local") {
             console.log(`Skipping merge operation for local workspace task ${taskId}`);
             return { success: true, mergedCommit: "local-merge" }; // Return success for local workspaces
         }
-        const git = simpleGit(taskState.worktreePath);
+        return await this.withRepoLock(repoKey, async () => {
+            return this.mergeTaskUnlocked(entry, targetBranch, mode);
+        });
+    }
+    async mergeTaskUnlocked(entry, targetBranch, mode) {
+        const { repoKey, repo, taskState } = entry;
+        const isLocalRepo = repoKey.startsWith("local__");
+        const mergePath = await (async () => {
+            if (isLocalRepo)
+                return repo.controlPath;
+            if (!taskState.workspaceId) {
+                throw new Error(`Cannot merge task ${taskState.taskId}: missing workspaceId in task Git state`);
+            }
+            const worktreesPath = path.join(this.repoBasePath, "repos", repoKey, "worktrees");
+            const workspaceWorktreePath = path.join(worktreesPath, `workspace_${taskState.workspaceId}`);
+            const exists = await fs
+                .access(workspaceWorktreePath)
+                .then(() => true)
+                .catch(() => false);
+            if (exists)
+                return workspaceWorktreePath;
+            await this.ensureDirectory(worktreesPath);
+            const controlGit = simpleGit(repo.controlPath);
+            await controlGit.fetch("origin", targetBranch);
+            await controlGit.raw([
+                "worktree",
+                "add",
+                workspaceWorktreePath,
+                `origin/${targetBranch}`,
+            ]);
+            console.log(`Created merge worktree for workspace ${taskState.workspaceId} at ${workspaceWorktreePath}`);
+            return workspaceWorktreePath;
+        })();
+        const git = simpleGit(mergePath);
         try {
-            // Fetch latest changes
-            await git.fetch("origin", targetBranch);
-            // Checkout target branch
-            await git.checkout(targetBranch);
-            await git.pull("origin", targetBranch);
+            const remotes = await git.getRemotes(true);
+            const hasOrigin = remotes.some((r) => r.name === "origin");
+            logger.info(`Merging task ${taskState.taskId} (${taskState.branch}) into ${targetBranch}`, {
+                taskId: taskState.taskId,
+                taskBranch: taskState.branch,
+                targetBranch,
+                mergePath,
+                hasOrigin,
+                isLocalRepo,
+                mode,
+            });
+            if (hasOrigin) {
+                // Fetch latest changes and ensure a local targetBranch exists + is up-to-date
+                await git.fetch("origin", targetBranch);
+                const localBranches = await git.branchLocal();
+                const hasLocalTarget = localBranches.all.includes(targetBranch);
+                if (!hasLocalTarget) {
+                    await git.raw(["checkout", "-B", targetBranch, `origin/${targetBranch}`]);
+                }
+                else {
+                    await git.checkout(targetBranch);
+                    try {
+                        await git.merge(["--ff-only", `origin/${targetBranch}`]);
+                    }
+                    catch (error) {
+                        throw new Error(`Base branch ${targetBranch} has diverged from origin/${targetBranch}; cannot fast-forward`);
+                    }
+                }
+            }
+            else {
+                await git.checkout(targetBranch);
+            }
             // Perform merge based on mode
             let mergeArgs = [];
             switch (mode) {
@@ -414,34 +684,52 @@ export class EnhancedRepositoryManager extends RepositoryManager {
                     mergeArgs = ["--squash"];
                     break;
             }
-            const result = await git.merge([taskState.branch, ...mergeArgs]);
+            const result = await git.merge([...mergeArgs, taskState.branch]);
             // For squash merge, we need to commit
             if (mode === "squash") {
-                const commitResult = await git.commit(`Merge task ${taskId} (${taskState.branch})`);
+                const commitResult = await git.commit(`Merge task ${taskState.taskId} (${taskState.branch})`);
                 result.result = commitResult.commit;
             }
             // Update task state
             taskState.status = "merged";
             taskState.updatedAt = new Date();
-            await this.updateTaskStateByTaskId(taskId, taskState);
-            console.log(`Successfully merged task ${taskId} into ${targetBranch}`);
+            await this.updateTaskStateByTaskId(taskState.taskId, taskState);
+            console.log(`Successfully merged task ${taskState.taskId} into ${targetBranch}`);
+            logger.info(`Merged task ${taskState.taskId} (${taskState.branch}) into ${targetBranch}`, {
+                taskId: taskState.taskId,
+                taskBranch: taskState.branch,
+                targetBranch,
+                mergedCommit: result.result,
+            });
             return {
                 success: true,
                 mergedCommit: result.result,
             };
         }
         catch (error) {
-            console.error(`Merge failed for task ${taskId}:`, error);
+            console.error(`Merge failed for task ${taskState.taskId}:`, error);
+            logger.error(`Merge failed for task ${taskState.taskId} (${taskState.branch})`, {
+                taskId: taskState.taskId,
+                taskBranch: taskState.branch,
+                targetBranch,
+                mergePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
             // Check for conflicts
-            const status = await git.status();
-            if (status.conflicted.length > 0) {
-                taskState.status = "conflicted";
-                await this.updateTaskStateByTaskId(taskId, taskState);
-                return {
-                    success: false,
-                    conflicts: status.conflicted,
-                    error: "Merge resulted in conflicts",
-                };
+            try {
+                const status = await git.status();
+                if (status.conflicted.length > 0) {
+                    taskState.status = "conflicted";
+                    await this.updateTaskStateByTaskId(taskState.taskId, taskState);
+                    return {
+                        success: false,
+                        conflicts: status.conflicted,
+                        error: "Merge resulted in conflicts",
+                    };
+                }
+            }
+            catch {
+                // Ignore status errors (e.g. bare repositories)
             }
             return {
                 success: false,
@@ -449,23 +737,205 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             };
         }
     }
+    async getTaskRepoInfo(taskId) {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry)
+            return null;
+        return {
+            repoKey: entry.repoKey,
+            controlPath: entry.repo.controlPath,
+            worktreePath: entry.taskState.worktreePath,
+            branch: entry.taskState.branch,
+            baseBranch: entry.taskState.baseBranch,
+        };
+    }
     /**
-     * Get task Git state
+     * Fast-forward (or hard reset) the shared workspace worktree to a branch tip after a task merge.
+     * This keeps the "workspace" checkout in sync with concurrent task integrations.
+     *
+     * We only update existing workspace worktrees and only when they're clean to avoid
+     * clobbering any active non-concurrent task that might be using the workspace checkout.
      */
-    async getTaskState(taskId) {
-        for (const state of this.repoStates.values()) {
-            for (const repo of Object.values(state.repositories)) {
-                if (repo.worktrees[taskId]) {
-                    return repo.worktrees[taskId];
+    async syncWorkspaceWorktree(workspaceId, repoUrl, branch) {
+        if (!workspaceId || !repoUrl)
+            return;
+        // Local repos merge directly into the primary working tree (controlPath), nothing to sync.
+        if (repoUrl.startsWith("file://"))
+            return;
+        const { key } = this.getRepoKey(repoUrl);
+        const workspaceWorktreePath = path.join(this.repoBasePath, "repos", key, "worktrees", `workspace_${workspaceId}`);
+        const exists = await fs
+            .access(workspaceWorktreePath)
+            .then(() => true)
+            .catch(() => false);
+        await this.withRepoLock(key, async () => {
+            if (!exists) {
+                const controlPath = path.join(this.repoBasePath, "repos", key, "control");
+                const controlExists = await fs
+                    .access(controlPath)
+                    .then(() => true)
+                    .catch(() => false);
+                if (!controlExists) {
+                    console.warn(`Skipping workspace worktree sync for ${workspaceId}: control repo missing`, { controlPath, repoUrl });
+                    return;
                 }
+                await this.ensureDirectory(path.dirname(workspaceWorktreePath));
+                const controlGit = simpleGit(controlPath);
+                const remotes = await controlGit.getRemotes(true);
+                const hasOrigin = remotes.some((remote) => remote.name === "origin");
+                const checkoutRef = hasOrigin ? `origin/${branch}` : branch;
+                await controlGit.raw(["worktree", "add", workspaceWorktreePath, checkoutRef]);
+                console.log(`Created workspace worktree for ${workspaceId} at ${workspaceWorktreePath}`);
+            }
+            const git = simpleGit(workspaceWorktreePath);
+            const status = await git.status();
+            if (status.conflicted.length > 0 || !status.isClean()) {
+                console.warn(`Skipping workspace worktree sync for ${workspaceId}: worktree is not clean`, {
+                    path: workspaceWorktreePath,
+                    branch,
+                    conflicted: status.conflicted,
+                    fileCount: status.files.length,
+                });
+                return;
             }
+            const remotes = await git.getRemotes(true);
+            const hasOrigin = remotes.some((remote) => remote.name === "origin");
+            if (hasOrigin) {
+                await git.fetch("origin", branch);
+                await git.reset(["--hard", `origin/${branch}`]);
+            }
+            else {
+                await git.reset(["--hard", branch]);
+            }
+            await git.clean("f", ["-d"]);
+            console.log(`Synced workspace worktree for ${workspaceId} to ${branch} at ${workspaceWorktreePath}`);
+        });
+    }
+    async isTaskBranchMerged(taskId, targetBranch) {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry)
+            return false;
+        const { repo, taskState } = entry;
+        const git = simpleGit(repo.controlPath);
+        try {
+            // Ensure targetBranch exists locally (avoid erroring for repos that only have origin/<branch>)
+            const showRef = await git.raw([
+                "show-ref",
+                "--verify",
+                `refs/heads/${targetBranch}`,
+            ]);
+            if (!showRef?.trim())
+                return false;
+        }
+        catch {
+            return false;
+        }
+        try {
+            await git.raw([
+                "merge-base",
+                "--is-ancestor",
+                taskState.branch,
+                targetBranch,
+            ]);
+            return true;
+        }
+        catch {
+            return false;
         }
-        return null;
+    }
+    async pushBranch(taskId, branch) {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry)
+            return;
+        const git = simpleGit(entry.repo.controlPath);
+        const remotes = await git.getRemotes(true);
+        const hasOrigin = remotes.some((r) => r.name === "origin");
+        if (!hasOrigin)
+            return;
+        await git.push("origin", branch);
+    }
+    async integrateTask(taskId, targetBranch, mode = "no-ff") {
+        const entry = this.findTaskStateEntry(taskId);
+        if (!entry) {
+            return {
+                success: false,
+                phase: "merge",
+                error: `No worktree found for task ${taskId}`,
+                conflictWorkdir: "",
+            };
+        }
+        const { repoKey, repo, taskState } = entry;
+        const isLocalRepo = repoKey.startsWith("local__");
+        const mergeWorkdir = isLocalRepo
+            ? repo.controlPath
+            : taskState.workspaceId
+                ? path.join(this.repoBasePath, "repos", repoKey, "worktrees", `workspace_${taskState.workspaceId}`)
+                : taskState.worktreePath;
+        logger.info(`Integrating task ${taskId} (${taskState.branch}) into ${targetBranch}`, {
+            taskId,
+            taskBranch: taskState.branch,
+            targetBranch,
+            mode,
+            isLocalRepo,
+            controlPath: repo.controlPath,
+            worktreePath: taskState.worktreePath,
+        });
+        return await this.withRepoLock(repoKey, async () => {
+            const rebaseResult = await this.rebaseTask(taskId, targetBranch);
+            if (!rebaseResult.success) {
+                logger.warn(`Task ${taskId} rebase failed`, {
+                    taskId,
+                    phase: "rebase",
+                    targetBranch,
+                    conflicts: rebaseResult.conflicts ?? [],
+                    error: rebaseResult.error,
+                });
+                return {
+                    success: false,
+                    phase: "rebase",
+                    conflicts: rebaseResult.conflicts ?? [],
+                    error: rebaseResult.error,
+                    conflictWorkdir: taskState.worktreePath,
+                };
+            }
+            const mergeResult = await this.mergeTaskUnlocked(entry, targetBranch, mode);
+            if (!mergeResult.success) {
+                logger.warn(`Task ${taskId} merge failed`, {
+                    taskId,
+                    phase: "merge",
+                    targetBranch,
+                    conflicts: mergeResult.conflicts ?? [],
+                    error: mergeResult.error,
+                });
+                return {
+                    success: false,
+                    phase: "merge",
+                    conflicts: mergeResult.conflicts ?? [],
+                    error: mergeResult.error,
+                    conflictWorkdir: mergeWorkdir,
+                };
+            }
+            logger.info(`Integrated task ${taskId} into ${targetBranch}`, {
+                taskId,
+                targetBranch,
+                mergedCommit: mergeResult.mergedCommit,
+            });
+            return {
+                success: true,
+                mergedCommit: mergeResult.mergedCommit,
+            };
+        });
+    }
+    /**
+     * Get task Git state
+     */
+    async getTaskState(taskId) {
+        return this.findTaskStateEntry(taskId)?.taskState ?? null;
     }
     /**
      * Update task state
      */
-    async updateTaskState(repoKey, state) {
+    async updateTaskState(repoKey, state, repoInfo) {
         if (!this.repoStates.has(repoKey)) {
             this.repoStates.set(repoKey, {
                 repositories: {},
@@ -482,8 +952,16 @@ export class EnhancedRepositoryManager extends RepositoryManager {
                     worktrees: {},
                 };
             }
+            else if (repoInfo) {
+                repoState.repositories[repoKey] = {
+                    owner: repoInfo.owner,
+                    repo: repoInfo.repo,
+                    controlPath: repoInfo.controlPath,
+                    worktrees: {},
+                };
+            }
             else {
-                const { owner, repo } = this.getRepoKey(repoKey);
+                const { owner, repo } = this.parseRepoKey(repoKey);
                 repoState.repositories[repoKey] = {
                     owner,
                     repo,
@@ -492,6 +970,10 @@ export class EnhancedRepositoryManager extends RepositoryManager {
                 };
             }
         }
+        else if (repoInfo?.controlPath) {
+            // Ensure we persist the latest controlPath (important for local repos)
+            repoState.repositories[repoKey].controlPath = repoInfo.controlPath;
+        }
         repoState.repositories[repoKey].worktrees[state.taskId] = state;
         await this.persistState();
     }
@@ -518,6 +1000,7 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             for (const [key, value] of this.repoStates) {
                 stateData[key] = value;
             }
+            await this.ensureDirectory(path.dirname(this.stateFilePath));
             await fs.writeFile(this.stateFilePath, JSON.stringify(stateData, null, 2));
             console.log("Persisted repository state");
         }
@@ -529,6 +1012,7 @@ export class EnhancedRepositoryManager extends RepositoryManager {
      * Restore state from disk
      */
     async restoreState() {
+        await this.migrateLegacyStateFileIfNeeded();
         try {
             const data = await fs.readFile(this.stateFilePath, "utf-8");
             const stateData = JSON.parse(data);
@@ -552,6 +1036,23 @@ export class EnhancedRepositoryManager extends RepositoryManager {
             // If file doesn't exist, that's okay - we'll start fresh
         }
     }
+    async migrateLegacyStateFileIfNeeded() {
+        const hasNewStateFile = await fs
+            .access(this.stateFilePath)
+            .then(() => true)
+            .catch(() => false);
+        if (hasNewStateFile)
+            return;
+        const hasLegacyStateFile = await fs
+            .access(this.legacyStateFilePath)
+            .then(() => true)
+            .catch(() => false);
+        if (!hasLegacyStateFile)
+            return;
+        await this.ensureDirectory(path.dirname(this.stateFilePath));
+        await fs.rename(this.legacyStateFilePath, this.stateFilePath);
+        console.log(`Moved legacy repository state file to runner data directory: ${this.stateFilePath}`);
+    }
     /**
      * Override parent's checkoutRepository to use worktrees for backward compatibility
      */