sequant 2.0.1 → 2.1.0

package/dist/src/lib/workflow/worktree-manager.js

@@ -166,7 +166,7 @@ export function checkWorktreeFreshness(worktreePath, verbose, baseBranch = "main
             unpushedResult.stdout.toString().trim().length > 0;
     }
     if (verbose && result.isStale) {
-        console.log(chalk.gray(`    📊 Worktree is ${result.commitsBehind} commits behind origin/${baseBranch}`));
+        console.log(chalk.gray(`    Worktree is ${result.commitsBehind} commits behind origin/${baseBranch}`));
     }
     return result;
 }
@@ -186,7 +186,7 @@ export function removeStaleWorktree(existingPath, branch, verbose) {
     const removeResult = spawnSync("git", ["worktree", "remove", "--force", existingPath], { stdio: "pipe" });
     if (removeResult.status !== 0) {
         const error = removeResult.stderr.toString();
-        console.log(chalk.yellow(`    ⚠️  Could not remove worktree: ${error}`));
+        console.log(chalk.yellow(`    !  Could not remove worktree: ${error}`));
         return false;
     }
     // Delete the branch so it can be recreated fresh
@@ -211,7 +211,7 @@ export function listWorktrees() {
     const lines = output.split("\n");
     const worktrees = [];
     let currentPath = "";
-    let currentBranch = "";
+    let currentBranch;
     for (const line of lines) {
         if (line.startsWith("worktree ")) {
             currentPath = line.substring(9);
@@ -223,7 +223,6 @@ export function listWorktrees() {
             const issue = issueMatch ? parseInt(issueMatch[1], 10) : null;
             worktrees.push({ path: currentPath, branch: currentBranch, issue });
             currentPath = "";
-            currentBranch = "";
         }
     }
     return worktrees;
@@ -339,18 +338,18 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
         if (freshness.isStale) {
             // AC-3: Handle stale worktrees - check for work in progress
             if (freshness.hasUncommittedChanges) {
-                console.log(chalk.yellow(`    ⚠️  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} but has uncommitted changes`));
+                console.log(chalk.yellow(`    !  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} but has uncommitted changes`));
                 console.log(chalk.yellow(`    ℹ️  Keeping existing worktree. Commit or stash changes, then re-run.`));
                 // Continue with existing worktree
             }
             else if (freshness.hasUnpushedCommits) {
-                console.log(chalk.yellow(`    ⚠️  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} but has unpushed commits`));
+                console.log(chalk.yellow(`    !  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} but has unpushed commits`));
                 console.log(chalk.yellow(`    ℹ️  Keeping existing worktree with WIP commits.`));
                 // Continue with existing worktree
             }
             else {
                 // Safe to recreate - no uncommitted/unpushed work
-                console.log(chalk.yellow(`    ⚠️  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} — recreating fresh`));
+                console.log(chalk.yellow(`    !  Worktree is ${freshness.commitsBehind} commits behind ${detectedBase} — recreating fresh`));
                 if (removeStaleWorktree(existingPath, branch, verbose)) {
                     existingPath = null; // Will fall through to create new worktree
                 }
@@ -359,12 +358,12 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
     }
     if (existingPath) {
         if (verbose) {
-            console.log(chalk.gray(`    📂 Reusing existing worktree: ${existingPath}`));
+            console.log(chalk.gray(`    Reusing existing worktree: ${existingPath}`));
         }
         // In chain mode, rebase existing worktree onto previous chain link
         if (chainMode && baseBranch) {
             if (verbose) {
-                console.log(chalk.gray(`    🔄 Rebasing existing worktree onto chain base (${baseBranch})...`));
+                console.log(chalk.gray(`    Rebasing existing worktree onto chain base (${baseBranch})...`));
             }
             const rebaseResult = spawnSync("git", ["-C", existingPath, "rebase", baseBranch], { stdio: "pipe" });
             if (rebaseResult.status !== 0) {
@@ -372,7 +371,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
                 // Check if it's a conflict
                 if (rebaseError.includes("CONFLICT") ||
                     rebaseError.includes("could not apply")) {
-                    console.log(chalk.yellow(`    ⚠️  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
+                    console.log(chalk.yellow(`    !  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
                     console.log(chalk.yellow(`    ℹ️  Branch ${branch} is not properly chained. Manual rebase may be required.`));
                     // Abort the rebase to restore branch state
                     spawnSync("git", ["-C", existingPath, "rebase", "--abort"], {
@@ -380,7 +379,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
                     });
                 }
                 else {
-                    console.log(chalk.yellow(`    ⚠️  Rebase failed: ${rebaseError.trim()}`));
+                    console.log(chalk.yellow(`    !  Rebase failed: ${rebaseError.trim()}`));
                     console.log(chalk.yellow(`    ℹ️  Continuing with branch in its original state.`));
                 }
                 return {
@@ -392,7 +391,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
                 };
             }
             if (verbose) {
-                console.log(chalk.green(`    ✅ Existing worktree rebased onto ${baseBranch}`));
+                console.log(chalk.green(`    ✔ Existing worktree rebased onto ${baseBranch}`));
             }
             return {
                 issue: issueNumber,
@@ -435,13 +434,13 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
     const branchToFetch = effectiveBase.replace(/^origin\//, "");
     if (!isLocalBranch) {
         if (verbose) {
-            console.log(chalk.gray(`    🔄 Fetching latest ${branchToFetch}...`));
+            console.log(chalk.gray(`    Fetching latest ${branchToFetch}...`));
         }
         const fetchResult = spawnSync("git", ["fetch", "origin", branchToFetch], {
             stdio: "pipe",
         });
         if (fetchResult.status !== 0 && verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not fetch origin/${branchToFetch}, using local state`));
+            console.log(chalk.yellow(`    !  Could not fetch origin/${branchToFetch}, using local state`));
         }
     }
     else if (verbose) {
@@ -477,7 +476,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
     let rebased = false;
     if (needsRebase) {
         if (verbose) {
-            console.log(chalk.gray(`    🔄 Rebasing existing branch onto previous chain link (${baseRef})...`));
+            console.log(chalk.gray(`    Rebasing existing branch onto previous chain link (${baseRef})...`));
         }
         const rebaseResult = spawnSync("git", ["-C", worktreePath, "rebase", baseRef], {
             stdio: "pipe",
@@ -487,7 +486,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
             // Check if it's a conflict
             if (rebaseError.includes("CONFLICT") ||
                 rebaseError.includes("could not apply")) {
-                console.log(chalk.yellow(`    ⚠️  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
+                console.log(chalk.yellow(`    !  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
                 console.log(chalk.yellow(`    ℹ️  Branch ${branch} is not properly chained. Manual rebase may be required.`));
                 // Abort the rebase to restore branch state
                 spawnSync("git", ["-C", worktreePath, "rebase", "--abort"], {
@@ -495,14 +494,14 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
                 });
             }
             else {
-                console.log(chalk.yellow(`    ⚠️  Rebase failed: ${rebaseError.trim()}`));
+                console.log(chalk.yellow(`    !  Rebase failed: ${rebaseError.trim()}`));
                 console.log(chalk.yellow(`    ℹ️  Continuing with branch in its original state.`));
             }
         }
         else {
             rebased = true;
             if (verbose) {
-                console.log(chalk.green(`    ✅ Branch rebased onto ${baseRef}`));
+                console.log(chalk.green(`    ✔ Branch rebased onto ${baseRef}`));
             }
         }
     }
@@ -525,7 +524,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
     const nodeModulesPath = path.join(worktreePath, "node_modules");
     if (!existsSync(nodeModulesPath)) {
         if (verbose) {
-            console.log(chalk.gray(`    📦 Installing dependencies...`));
+            console.log(chalk.gray(`    Installing dependencies...`));
         }
         // Use detected package manager or default to npm
         const pm = packageManager || "npm";
@@ -537,7 +536,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
         });
     }
     if (verbose) {
-        console.log(chalk.green(`    ✅ Worktree ready: ${worktreePath}`));
+        console.log(chalk.green(`    ✔ Worktree ready: ${worktreePath}`));
     }
     return {
         issue: issueNumber,
@@ -554,7 +553,7 @@ export async function ensureWorktree(issueNumber, title, verbose, packageManager
 export async function ensureWorktrees(issues, verbose, packageManager, baseBranch) {
     const worktrees = new Map();
     const baseDisplay = baseBranch || detectDefaultBranch(verbose);
-    console.log(chalk.blue(`\n  📂 Preparing worktrees from ${baseDisplay}...`));
+    console.log(chalk.blue(`\n  Preparing worktrees from ${baseDisplay}...`));
     for (const issue of issues) {
         const worktree = await ensureWorktree(issue.number, issue.title, verbose, packageManager, baseBranch, false);
         if (worktree) {
@@ -576,7 +575,7 @@ export async function ensureWorktrees(issues, verbose, packageManager, baseBranc
 export async function ensureWorktreesChain(issues, verbose, packageManager, baseBranch) {
     const worktrees = new Map();
     const baseDisplay = baseBranch || detectDefaultBranch(verbose);
-    console.log(chalk.blue(`\n  🔗 Preparing chained worktrees from ${baseDisplay}...`));
+    console.log(chalk.blue(`\n  Preparing chained worktrees from ${baseDisplay}...`));
     // First issue starts from the specified base branch (or main)
     let previousBranch = baseBranch;
     for (const issue of issues) {
@@ -622,7 +621,7 @@ export function createCheckpointCommit(worktreePath, issueNumber, verbose) {
     const statusResult = spawnSync("git", ["-C", worktreePath, "status", "--porcelain"], { stdio: "pipe" });
     if (statusResult.status !== 0) {
         if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not check git status for checkpoint`));
+            console.log(chalk.yellow(`    !  Could not check git status for checkpoint`));
         }
         return false;
     }
@@ -639,7 +638,7 @@ export function createCheckpointCommit(worktreePath, issueNumber, verbose) {
     });
     if (addResult.status !== 0) {
         if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not stage changes for checkpoint`));
+            console.log(chalk.yellow(`    !  Could not stage changes for checkpoint`));
         }
         return false;
     }
@@ -652,7 +651,7 @@ passed QA in chain mode. It serves as a recovery point if later issues fail.`;
     if (commitResult.status !== 0) {
         const error = commitResult.stderr.toString();
         if (verbose) {
-            console.log(chalk.yellow(`    ⚠️  Could not create checkpoint commit: ${error}`));
+            console.log(chalk.yellow(`    !  Could not create checkpoint commit: ${error}`));
         }
         return false;
     }
@@ -689,19 +688,19 @@ export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose
         if (result.status === 0 && result.stdout.toString().trim().length > 0) {
             lockfileChanged = true;
             if (verbose) {
-                console.log(chalk.gray(`    📦 Lockfile changed: ${lockfile}`));
+                console.log(chalk.gray(`    Lockfile changed: ${lockfile}`));
             }
             break;
         }
     }
     if (!lockfileChanged) {
         if (verbose) {
-            console.log(chalk.gray(`    📦 No lockfile changes detected`));
+            console.log(chalk.gray(`    No lockfile changes detected`));
         }
         return false;
     }
     // Re-run install to sync node_modules with updated lockfile
-    console.log(chalk.blue(`    📦 Reinstalling dependencies (lockfile changed)...`));
+    console.log(chalk.blue(`    Reinstalling dependencies (lockfile changed)...`));
     const pm = packageManager || "npm";
     const pmConfig = PM_CONFIG[pm];
     const [cmd, ...args] = pmConfig.installSilent.split(" ");
@@ -711,10 +710,10 @@ export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose
     });
     if (installResult.status !== 0) {
         const error = installResult.stderr.toString();
-        console.log(chalk.yellow(`    ⚠️  Dependency reinstall failed: ${error.trim()}`));
+        console.log(chalk.yellow(`    !  Dependency reinstall failed: ${error.trim()}`));
         return false;
     }
-    console.log(chalk.green(`    ✅ Dependencies reinstalled`));
+    console.log(chalk.green(`    ✔ Dependencies reinstalled`));
     return true;
 }
 /**
@@ -732,7 +731,7 @@ export function reinstallIfLockfileChanged(worktreePath, packageManager, verbose
 export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbose, baseBranch = "main") {
     const baseRef = `origin/${baseBranch}`;
     if (verbose) {
-        console.log(chalk.gray(`    🔄 Rebasing #${issueNumber} onto ${baseRef} before PR...`));
+        console.log(chalk.gray(`    Rebasing #${issueNumber} onto ${baseRef} before PR...`));
     }
     // Fetch latest base branch to ensure we're rebasing onto fresh state
     const fetchResult = spawnSync("git", ["-C", worktreePath, "fetch", "origin", baseBranch], {
@@ -740,7 +739,7 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
     });
     if (fetchResult.status !== 0) {
         const error = fetchResult.stderr.toString();
-        console.log(chalk.yellow(`    ⚠️  Could not fetch ${baseRef}: ${error.trim()}`));
+        console.log(chalk.yellow(`    !  Could not fetch ${baseRef}: ${error.trim()}`));
         // Continue anyway - might work with local state
     }
     // Perform the rebase
@@ -750,7 +749,7 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
         // Check if it's a conflict
         if (rebaseError.includes("CONFLICT") ||
             rebaseError.includes("could not apply")) {
-            console.log(chalk.yellow(`    ⚠️  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
+            console.log(chalk.yellow(`    !  Rebase conflict detected. Aborting rebase and keeping original branch state.`));
             console.log(chalk.yellow(`    ℹ️  PR will be created without rebase. Manual rebase may be required before merge.`));
             // Abort the rebase to restore branch state
             spawnSync("git", ["-C", worktreePath, "rebase", "--abort"], {
@@ -764,7 +763,7 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
             };
         }
         else {
-            console.log(chalk.yellow(`    ⚠️  Rebase failed: ${rebaseError.trim()}`));
+            console.log(chalk.yellow(`    !  Rebase failed: ${rebaseError.trim()}`));
             console.log(chalk.yellow(`    ℹ️  Continuing with branch in its original state.`));
             return {
                 performed: true,
@@ -774,7 +773,7 @@ export function rebaseBeforePR(worktreePath, issueNumber, packageManager, verbos
             };
         }
     }
-    console.log(chalk.green(`    ✅ Branch rebased onto ${baseRef}`));
+    console.log(chalk.green(`    ✔ Branch rebased onto ${baseRef}`));
     // Check if lockfile changed and reinstall if needed
     const reinstalled = reinstallIfLockfileChanged(worktreePath, packageManager, verbose);
     return {
@@ -819,7 +818,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     const pushResult = spawnSync("git", ["-C", worktreePath, "push", "-u", "origin", branch], { stdio: "pipe", timeout: 60000 });
     if (pushResult.status !== 0) {
         const pushError = pushResult.stderr?.toString().trim() ?? "Unknown error";
-        console.log(chalk.yellow(`    ⚠️  git push failed: ${pushError}`));
+        console.log(chalk.yellow(`    !  git push failed: ${pushError}`));
         return {
             attempted: true,
             success: false,
@@ -828,7 +827,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     }
     // Step 3: Create PR
     if (verbose) {
-        console.log(chalk.gray(`    📝 Creating PR for #${issueNumber}...`));
+        console.log(chalk.gray(`    Creating PR for #${issueNumber}...`));
     }
     const isBug = labels?.some((l) => /^bug/i.test(l));
     const prefix = isBug ? "fix" : "feat";
@@ -858,7 +857,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
                 };
             }
         }
-        console.log(chalk.yellow(`    ⚠️  PR creation failed: ${prError}`));
+        console.log(chalk.yellow(`    !  PR creation failed: ${prError}`));
         return {
             attempted: true,
             success: false,
@@ -871,7 +870,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     if (prUrlMatch) {
         const prNumber = parseInt(prUrlMatch[1], 10);
         const prUrl = prUrlMatch[0];
-        console.log(chalk.green(`    ✅ PR #${prNumber} created: ${prUrl}`));
+        console.log(chalk.green(`    ✔ PR #${prNumber} created: ${prUrl}`));
         return {
             attempted: true,
             success: true,
@@ -882,7 +881,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
     // Fallback: try gh pr view to get details
     const viewInfo = github.viewPRByBranchSync(branch, worktreePath);
     if (viewInfo) {
-        console.log(chalk.green(`    ✅ PR #${viewInfo.number} created: ${viewInfo.url}`));
+        console.log(chalk.green(`    ✔ PR #${viewInfo.number} created: ${viewInfo.url}`));
         return {
             attempted: true,
             success: true,
@@ -891,7 +890,7 @@ export function createPR(worktreePath, issueNumber, issueTitle, branch, verbose,
         };
     }
     // PR was created but we couldn't parse the URL
-    console.log(chalk.yellow(`    ⚠️  PR created but could not extract URL from output: ${prOutput}`));
+    console.log(chalk.yellow(`    !  PR created but could not extract URL from output: ${prOutput}`));
     return {
         attempted: true,
         success: true,

package/dist/src/lib/worktree-isolation.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Worktree isolation for parallel /exec agent groups.
+ *
+ * Provides sub-worktree creation, merge-back, and cleanup for
+ * parallel agent execution, eliminating file conflicts structurally.
+ *
+ * @see https://github.com/sequant-io/sequant/issues/485
+ */
+/** Result of creating a sub-worktree */
+export interface SubWorktreeInfo {
+    /** Absolute path to the sub-worktree */
+    path: string;
+    /** Branch name used for the sub-worktree */
+    branch: string;
+    /** Agent index within the parallel group */
+    agentIndex: number;
+}
+/** Result of merging a single sub-worktree back */
+export interface MergeResult {
+    /** Whether the merge succeeded */
+    success: boolean;
+    /** Branch that was merged */
+    branch: string;
+    /** Agent index */
+    agentIndex: number;
+    /** Files that conflicted (empty if success) */
+    conflictFiles: string[];
+    /** Error message if merge failed */
+    error?: string;
+}
+/** Aggregate result of merging all sub-worktrees */
+export interface MergeBackResult {
+    /** Number of agents that merged successfully */
+    merged: number;
+    /** Number of agents with conflicts */
+    conflicts: number;
+    /** Per-agent merge results */
+    results: MergeResult[];
+}
+/**
+ * Directory name for sub-worktrees inside the issue worktree.
+ * This directory is nested inside the issue worktree for locality.
+ */
+export declare const SUB_WORKTREE_DIR = ".exec-agents";
+/** Name of the worktree include file */
+export declare const WORKTREE_INCLUDE_FILE = ".worktreeinclude";
+/**
+ * Read the list of files to copy into sub-worktrees.
+ *
+ * Reads from .worktreeinclude if it exists (one path per line, # comments),
+ * otherwise returns the hardcoded default list.
+ */
+export declare function getIncludeFiles(worktreePath: string): string[];
+/**
+ * Generate a branch name for a sub-worktree agent.
+ *
+ * @param issueWorktreePath - Path to the issue worktree
+ * @param agentIndex - Zero-based agent index
+ * @returns Branch name like `exec-agent-485-0`
+ */
+export declare function agentBranchName(issueWorktreePath: string, agentIndex: number): string;
+/**
+ * Create a sub-worktree for a parallel agent.
+ *
+ * The sub-worktree is created inside the issue worktree at
+ * `.exec-agents/agent-<N>/` and branches from the issue branch HEAD.
+ *
+ * node_modules is symlinked from the issue worktree for speed.
+ * Environment files are copied per new-feature.sh convention.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ * @param agentIndex - Zero-based agent index
+ * @returns Sub-worktree info, or null if creation failed
+ */
+export declare function createSubWorktree(issueWorktreePath: string, agentIndex: number): SubWorktreeInfo | null;
+/**
+ * Merge a single sub-worktree's changes back into the issue worktree.
+ *
+ * Uses `git merge --no-ff` for built-in conflict detection.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ * @param subWorktree - Sub-worktree info
+ * @returns Merge result with conflict details if any
+ */
+export declare function mergeBackSubWorktree(issueWorktreePath: string, subWorktree: SubWorktreeInfo): MergeResult;
+/**
+ * Merge all sub-worktrees back into the issue worktree.
+ *
+ * Merges are attempted sequentially. If one conflicts, the merge is
+ * aborted and subsequent agents are still attempted. Non-conflicting
+ * changes are preserved in the issue worktree.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ * @param subWorktrees - Array of sub-worktree info
+ * @returns Aggregate merge result
+ */
+export declare function mergeAllSubWorktrees(issueWorktreePath: string, subWorktrees: SubWorktreeInfo[]): MergeBackResult;
+/**
+ * Remove a single sub-worktree and its branch.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ * @param subWorktree - Sub-worktree info to clean up
+ */
+export declare function cleanupSubWorktree(issueWorktreePath: string, subWorktree: SubWorktreeInfo): void;
+/**
+ * Clean up all sub-worktrees for an issue worktree.
+ *
+ * Handles both successful cleanup and orphaned worktrees from
+ * interrupted sessions.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ * @param subWorktrees - Known sub-worktrees to clean (if provided)
+ */
+export declare function cleanupAllSubWorktrees(issueWorktreePath: string, subWorktrees?: SubWorktreeInfo[]): void;
+/**
+ * Detect and clean up orphaned sub-worktrees from interrupted sessions.
+ *
+ * Scans the `.exec-agents/` directory for any remaining worktrees and
+ * removes them. Also prunes stale worktree entries from git.
+ *
+ * @param issueWorktreePath - Absolute path to the issue worktree
+ */
+export declare function cleanupOrphanedSubWorktrees(issueWorktreePath: string): void;
+/**
+ * Format merge-back results for logging.
+ *
+ * @param result - Aggregate merge result
+ * @returns Human-readable summary
+ */
+export declare function formatMergeResult(result: MergeBackResult): string;