sequant 2.1.2 → 2.3.0

package/dist/src/lib/workflow/phase-executor.js

@@ -8,7 +8,7 @@
  * is agent-agnostic.
  */
 import chalk from "chalk";
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 import { readAgentsMd } from "../agents-md.js";
 import { getDriver } from "./drivers/index.js";
 import { classifyError } from "./error-classifier.js";
@@ -92,6 +92,50 @@ const ISOLATED_PHASES = [
  */
 const COLD_START_THRESHOLD_SECONDS = 60;
 const COLD_START_MAX_RETRIES = 2;
+/**
+ * Leading + trailing throttle. Fires the wrapped callback immediately on the
+ * first call, drops subsequent calls that arrive inside `intervalMs` but
+ * remembers the latest payload, and fires one final "trailing" call with that
+ * latest payload after the window closes. Used to bridge the agent driver's
+ * fine-grained `onOutput` stream (#543) to the TUI's `nowLine` without
+ * either burning the 10 Hz snapshot budget on every chunk or losing the last
+ * useful chunk before the agent goes idle.
+ *
+ * `cancel()` clears the pending timer + payload — call after the consuming
+ * phase finishes so a residual trailing fire doesn't outlive its phase
+ * context. (The orchestrator's stale-phase guard catches it anyway, but
+ * cleanup avoids holding even a no-op timer.)
+ *
+ * @internal Exported for testing only.
+ */
+export function createThrottledReporter(fn, intervalMs) {
+    let timer = null;
+    let pending = null;
+    const report = (text) => {
+        if (timer) {
+            // Inside the throttle window — stash the latest payload for the
+            // trailing fire and drop this call.
+            pending = text;
+            return;
+        }
+        fn(text);
+        timer = setTimeout(() => {
+            const trailing = pending;
+            pending = null;
+            timer = null;
+            if (trailing !== null)
+                report(trailing);
+        }, intervalMs);
+        timer.unref?.();
+    };
+    const cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        pending = null;
+    };
+    return { report, cancel };
+}
 /**
  * Spec-specific retry configuration.
  * Spec failures have a higher failure rate (~8.6%) than other phases due to
@@ -218,6 +262,188 @@ export function formatDuration(seconds) {
     const secs = seconds % 60;
     return `${mins}m ${secs.toFixed(0)}s`;
 }
+/**
+ * Resolve the base ref the zero-diff guard should compare against for
+ * this worktree.
+ *
+ * Reads `branch.<current>.sequantBase` — written by `scripts/new-feature.sh`
+ * when a worktree is created with `--base <branch>`. Returns `origin/<base>`
+ * (prepending `origin/` only when the recorded value does not already
+ * reference a remote). Falls back to `"origin/main"` on missing config,
+ * missing branch, or any git error — preserves the pre-#537 behavior
+ * for worktrees that predate this change or are managed outside
+ * `new-feature.sh`.
+ *
+ * Uses `execFileSync` (not `execSync`) so argv is passed directly to
+ * `execve` without shell interpretation — the recorded value originates
+ * from the user-supplied `--base` CLI flag, and shell-interpolating it
+ * would open a shell-injection vector. With `execFileSync`, a malicious
+ * value is at worst treated as an invalid revspec by git (triggering
+ * the fail-open path), never executed as shell.
+ *
+ * @internal Exported for testing only.
+ */
+export function resolveBaseRef(cwd) {
+    const fallback = "origin/main";
+    let branch;
+    try {
+        branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd,
+            stdio: "pipe",
+        })
+            .toString()
+            .trim();
+    }
+    catch {
+        return fallback;
+    }
+    // Guard against multi-line output (paranoid — should never happen) and
+    // the detached-HEAD case where we have no recorded base to look up.
+    if (!branch || branch === "HEAD" || branch.includes("\n"))
+        return fallback;
+    let recorded;
+    try {
+        recorded = execFileSync("git", ["config", "--get", `branch.${branch}.sequantBase`], { cwd, stdio: "pipe" })
+            .toString()
+            .trim();
+    }
+    catch {
+        return fallback;
+    }
+    if (!recorded || recorded.includes("\n"))
+        return fallback;
+    return recorded.startsWith("origin/") ? recorded : `origin/${recorded}`;
+}
+/**
+ * Check whether the exec phase produced any changes in the worktree.
+ * Returns true if HEAD has commits unique to it relative to the resolved
+ * base ref (see {@link resolveBaseRef}) OR uncommitted work is present.
+ *
+ * Uses `git rev-list --count <base>..HEAD` (commits reachable from HEAD
+ * but not the base) instead of `git diff <base>..HEAD`, because the
+ * two-dot diff also fires in reverse when the base has advanced past HEAD
+ * — on stale branches that would falsely report "has commits" even when the
+ * exec phase produced nothing, reintroducing the bug #534 is fixing.
+ *
+ * The base ref defaults to `origin/main` but is overridden to the worktree's
+ * recorded base (see #537) so zero-diff execs are still detected on
+ * custom-base worktrees (e.g. those created with `--base feature/epic`).
+ *
+ * Fails open (returns true) on git errors — a missing origin ref is better
+ * diagnosed as a real zero-diff run than as a false phase failure.
+ *
+ * @internal Exported for testing only.
+ */
+export function hasExecChanges(cwd) {
+    const baseRef = resolveBaseRef(cwd);
+    let commitsAhead;
+    try {
+        const count = execFileSync("git", ["rev-list", "--count", `${baseRef}..HEAD`], { cwd, stdio: "pipe" })
+            .toString()
+            .trim();
+        commitsAhead = Number.parseInt(count, 10) > 0;
+    }
+    catch {
+        return true;
+    }
+    if (commitsAhead)
+        return true;
+    try {
+        const porcelain = execFileSync("git", ["status", "--porcelain"], {
+            cwd,
+            stdio: "pipe",
+        })
+            .toString()
+            .trim();
+        return porcelain.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Map a successful AgentPhaseResult to a PhaseResult, applying phase-specific
+ * guards that catch agent sessions which returned success without producing
+ * usable work (#534):
+ *
+ * - `qa`: fails when no parseable verdict is found (empty or malformed output).
+ * - `exec`: fails when no commits and no uncommitted changes exist.
+ *
+ * @internal Exported for testing only.
+ */
+export function mapAgentSuccessToPhaseResult(phase, agentResult, durationSeconds, cwd) {
+    const tails = {
+        stderrTail: agentResult.stderrTail,
+        stdoutTail: agentResult.stdoutTail,
+        exitCode: agentResult.exitCode,
+    };
+    if (phase === "qa") {
+        const verdict = agentResult.output
+            ? parseQaVerdict(agentResult.output)
+            : null;
+        const summary = agentResult.output
+            ? (parseQaSummary(agentResult.output) ?? undefined)
+            : undefined;
+        if (verdict &&
+            verdict !== "READY_FOR_MERGE" &&
+            verdict !== "NEEDS_VERIFICATION") {
+            return {
+                phase,
+                success: false,
+                durationSeconds,
+                error: `QA verdict: ${verdict}`,
+                sessionId: agentResult.sessionId,
+                output: agentResult.output,
+                verdict,
+                summary,
+                ...tails,
+            };
+        }
+        if (!verdict) {
+            // #534: a null verdict (empty or unparseable output) is not success.
+            return {
+                phase,
+                success: false,
+                durationSeconds,
+                error: "QA completed without a parseable verdict",
+                sessionId: agentResult.sessionId,
+                output: agentResult.output,
+                summary,
+                ...tails,
+            };
+        }
+        return {
+            phase,
+            success: true,
+            durationSeconds,
+            sessionId: agentResult.sessionId,
+            output: agentResult.output,
+            verdict,
+            summary,
+            ...tails,
+        };
+    }
+    if (phase === "exec" && !hasExecChanges(cwd)) {
+        // #534: an exec phase that produced nothing is not success.
+        return {
+            phase,
+            success: false,
+            durationSeconds,
+            error: "exec produced no changes (no commits, no uncommitted work)",
+            sessionId: agentResult.sessionId,
+            output: agentResult.output,
+            ...tails,
+        };
+    }
+    return {
+        phase,
+        success: true,
+        durationSeconds,
+        sessionId: agentResult.sessionId,
+        output: agentResult.output,
+        ...tails,
+    };
+}
 /**
  * Get the prompt for a phase with the issue number substituted.
  * Selects self-contained prompts for non-Claude agents.
@@ -335,11 +561,44 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
     if (config.isolateParallel) {
         env.SEQUANT_ISOLATE_PARALLEL = "true";
     }
+    // Activate interactive relay (#383) unless explicitly disabled.
+    // `relay-check.sh` (sourced from post-tool.sh) reads this env var on every
+    // tool call. Disabled by default in non-interactive scenarios — controlled
+    // via `settings.run.relay` (true by default).
+    if (config.relayEnabled) {
+        env.SEQUANT_RELAY = "true";
+        try {
+            const { resolveBundledFramePath } = await import("../relay/activation.js");
+            const framePath = resolveBundledFramePath();
+            if (framePath)
+                env.SEQUANT_RELAY_FRAME = framePath;
+        }
+        catch {
+            /* relay module unavailable — fall back to bash's search heuristic. */
+        }
+    }
     // Track whether we're actively streaming verbose output
     // Pausing spinner once per streaming session prevents truncation from rapid pause/resume cycles
     // (Issue #283: ora's stop() clears the current line, which can truncate output when
     // pause/resume is called for every chunk in rapid succession)
     let verboseStreamingActive = false;
+    // Activity ping throttle (#543): the agent driver streams text in many small
+    // chunks; the TUI only polls at 10 Hz. Coalesce to ≤2 calls per ~100ms
+    // window (leading + trailing) so we don't burn the poll budget on snapshot
+    // churn but still surface the latest chunk before the agent goes idle.
+    const ACTIVITY_THROTTLE_MS = 100;
+    const onActivity = config.onActivity;
+    const throttle = onActivity
+        ? createThrottledReporter((text) => {
+            try {
+                onActivity(text);
+            }
+            catch {
+                // Activity reporting must never disrupt the run.
+            }
+        }, ACTIVITY_THROTTLE_MS)
+        : undefined;
+    const reportActivity = throttle ? throttle.report : undefined;
     // Safety: never resume a session when worktree isolation is active.
     // Even if THIS phase doesn't use the worktree, a previous phase may have
     // created the session there. Resuming from a different cwd crashes the SDK
@@ -356,13 +615,16 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
         mcp: config.mcp,
         sessionId: canResume ? sessionId : undefined,
         files,
-        onOutput: config.verbose
+        onOutput: config.verbose || reportActivity
             ? (text) => {
-                if (!verboseStreamingActive) {
-                    spinner?.pause();
-                    verboseStreamingActive = true;
+                if (config.verbose) {
+                    if (!verboseStreamingActive) {
+                        spinner?.pause();
+                        verboseStreamingActive = true;
+                    }
+                    process.stdout.write(chalk.gray(text));
                 }
-                process.stdout.write(chalk.gray(text));
+                reportActivity?.(text);
             }
             : undefined,
         onStderr: config.verbose
@@ -380,6 +642,10 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
         aiderSettings: config.aiderSettings,
     });
     const agentResult = await driver.executePhase(prompt, agentConfig);
+    // Cancel any pending trailing activity fire — phase is done; the
+    // orchestrator's stale-phase guard would no-op a late call anyway, but
+    // clearing the timer is cheaper than letting it elapse.
+    throttle?.cancel();
     // Resume spinner after execution completes (if we paused it)
     if (verboseStreamingActive) {
         spinner?.resume();
@@ -390,52 +656,8 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
         shutdownManager.removeAbortController(abortController);
     }
     const durationSeconds = (Date.now() - startTime) / 1000;
-    // Map AgentPhaseResult to PhaseResult
-    const tails = {
-        stderrTail: agentResult.stderrTail,
-        stdoutTail: agentResult.stdoutTail,
-        exitCode: agentResult.exitCode,
-    };
     if (agentResult.success) {
-        // For QA phase, check the verdict to determine actual success
-        // Agent "success" just means the execution completed — we need to parse the verdict
-        if (phase === "qa" && agentResult.output) {
-            const verdict = parseQaVerdict(agentResult.output);
-            const summary = parseQaSummary(agentResult.output) ?? undefined;
-            if (verdict &&
-                verdict !== "READY_FOR_MERGE" &&
-                verdict !== "NEEDS_VERIFICATION") {
-                return {
-                    phase,
-                    success: false,
-                    durationSeconds,
-                    error: `QA verdict: ${verdict}`,
-                    sessionId: agentResult.sessionId,
-                    output: agentResult.output,
-                    verdict,
-                    summary,
-                    ...tails,
-                };
-            }
-            return {
-                phase,
-                success: true,
-                durationSeconds,
-                sessionId: agentResult.sessionId,
-                output: agentResult.output,
-                verdict: verdict ?? undefined,
-                summary,
-                ...tails,
-            };
-        }
-        return {
-            phase,
-            success: true,
-            durationSeconds,
-            sessionId: agentResult.sessionId,
-            output: agentResult.output,
-            ...tails,
-        };
+        return mapAgentSuccessToPhaseResult(phase, agentResult, durationSeconds, cwd);
     }
     return {
         phase,
@@ -443,7 +665,9 @@ async function executePhase(issueNumber, phase, config, sessionId, worktreePath,
         durationSeconds,
         error: agentResult.error,
         sessionId: agentResult.sessionId,
-        ...tails,
+        stderrTail: agentResult.stderrTail,
+        stdoutTail: agentResult.stdoutTail,
+        exitCode: agentResult.exitCode,
     };
 }
 /**

package/dist/src/lib/workflow/phase-mapper.d.ts

@@ -14,17 +14,18 @@ import type { Phase } from "./types.js";
  */
 interface PhaseMapperOptions {
     testgen?: boolean;
+    securityReview?: boolean;
 }
 /**
  * UI-related labels that trigger automatic test phase
  */
 export declare const UI_LABELS: string[];
 /**
- * Bug-related labels that skip spec phase
+ * Bug-related labels (used by downstream metadata consumers)
  */
 export declare const BUG_LABELS: string[];
 /**
- * Documentation labels that skip spec phase
+ * Documentation labels (used for issueType propagation and downstream metadata)
  */
 export declare const DOCS_LABELS: string[];
 /**

package/dist/src/lib/workflow/phase-mapper.js

@@ -12,11 +12,11 @@
  */
 export const UI_LABELS = ["ui", "frontend", "admin", "web", "browser"];
 /**
- * Bug-related labels that skip spec phase
+ * Bug-related labels (used by downstream metadata consumers)
  */
 export const BUG_LABELS = ["bug", "fix", "hotfix", "patch"];
 /**
- * Documentation labels that skip spec phase
+ * Documentation labels (used for issueType propagation and downstream metadata)
  */
 export const DOCS_LABELS = ["docs", "documentation", "readme"];
 /**
@@ -38,30 +38,19 @@ export const SECURITY_LABELS = [
  */
 export function detectPhasesFromLabels(labels) {
     const lowerLabels = labels.map((l) => l.toLowerCase());
-    // Check for bug/fix labels → exec → qa (skip spec)
-    const isBugFix = lowerLabels.some((label) => BUG_LABELS.some((bugLabel) => label === bugLabel));
-    // Check for docs labels → exec → qa (skip spec)
-    const isDocs = lowerLabels.some((label) => DOCS_LABELS.some((docsLabel) => label === docsLabel));
     // Check for UI labels → add test phase
     const isUI = lowerLabels.some((label) => UI_LABELS.some((uiLabel) => label === uiLabel));
     // Check for complex labels → enable quality loop
     const isComplex = lowerLabels.some((label) => COMPLEX_LABELS.some((complexLabel) => label === complexLabel));
     // Check for security labels → add security-review phase
     const isSecurity = lowerLabels.some((label) => SECURITY_LABELS.some((secLabel) => label === secLabel));
-    // Build phase list
-    let phases;
-    if (isBugFix || isDocs) {
-        // Simple workflow: exec → qa
-        phases = ["exec", "qa"];
-    }
-    else if (isUI) {
-        // UI workflow: spec → exec → test → qa
-        phases = ["spec", "exec", "test", "qa"];
-    }
-    else {
-        // Standard workflow: spec → exec → qa
-        phases = ["spec", "exec", "qa"];
-    }
+    // Build phase list — spec is always included by default (#533).
+    // Bug/docs labels no longer short-circuit spec; downstream consumers
+    // (e.g. `issueType: "docs"` propagation) still use DOCS_LABELS for
+    // metadata purposes, not for phase selection.
+    const phases = isUI
+        ? ["spec", "exec", "test", "qa"]
+        : ["spec", "exec", "qa"];
     // Add security-review phase after spec if security labels detected
     if (isSecurity && phases.includes("spec")) {
         const specIndex = phases.indexOf("spec");
@@ -132,6 +121,14 @@ export function determinePhasesForIssue(basePhases, labels, options) {
             phases.splice(specIndex + 1, 0, "testgen");
         }
     }
+    // Add security-review phase after spec if requested.
+    // Idempotent vs label-based auto-detection in detectPhasesFromLabels.
+    if (options.securityReview && phases.includes("spec")) {
+        const specIndex = phases.indexOf("spec");
+        if (!phases.includes("security-review")) {
+            phases.splice(specIndex + 1, 0, "security-review");
+        }
+    }
     // Auto-detect UI issues and add test phase
     if (hasUILabels(labels) && !phases.includes("test")) {
         // Add test phase before qa if present, otherwise at the end

package/dist/src/lib/workflow/platforms/github.d.ts

@@ -94,7 +94,7 @@ export declare class GitHubProvider implements PlatformProvider {
      * Create a PR via `gh pr create` CLI, returning raw result.
      * Used by worktree-manager.ts which needs access to stdout for URL extraction.
      */
-    createPRCliSync(title: string, body: string, head: string, cwd?: string): CreatePRCliResult;
+    createPRCliSync(title: string, body: string, head: string, cwd?: string, base?: string): CreatePRCliResult;
     /**
      * Batch fetch issue and PR status in a single GraphQL call.
      * Returns a map keyed by issue/PR number.

package/dist/src/lib/workflow/platforms/github.js

@@ -137,8 +137,25 @@ export class GitHubProvider {
      * Create a PR via `gh pr create` CLI, returning raw result.
      * Used by worktree-manager.ts which needs access to stdout for URL extraction.
      */
-    createPRCliSync(title, body, head, cwd) {
-        const result = spawnSync("gh", ["pr", "create", "--title", title, "--body", body, "--head", head], { stdio: "pipe", cwd, timeout: 30000 });
+    createPRCliSync(title, body, head, cwd, base) {
+        const args = [
+            "pr",
+            "create",
+            "--title",
+            title,
+            "--body",
+            body,
+            "--head",
+            head,
+        ];
+        if (base) {
+            args.push("--base", base);
+        }
+        const result = spawnSync("gh", args, {
+            stdio: "pipe",
+            cwd,
+            timeout: 30000,
+        });
         return {
             stdout: result.stdout?.toString() ?? "",
             stderr: result.stderr?.toString() ?? "",
@@ -415,7 +432,7 @@ export class GitHubProvider {
         });
     }
     async createPR(opts) {
-        const result = this.createPRCliSync(opts.title, opts.body, opts.head);
+        const result = this.createPRCliSync(opts.title, opts.body, opts.head, undefined, opts.base);
         if (result.exitCode !== 0) {
             const error = result.stderr.trim() || "Unknown error";
             throw new Error(`gh pr create failed: ${error}`);

package/dist/src/lib/workflow/pr-status.d.ts

@@ -28,16 +28,32 @@ export declare function checkPRMergeStatus(prNumber: number): PRMergeStatus;
 /**
  * Check if a branch has been merged into a base branch using git
  *
+ * "Merged" here means the branch was the source of an actual merge commit on
+ * the base branch — i.e., the branch tip appears as a non-first parent of some
+ * merge commit reachable from baseBranch. This deliberately excludes the case
+ * where the branch tip is just an ancestor of baseBranch with no commits ever
+ * added (e.g., a worktree branch created from main that was abandoned before
+ * any commits were made). Those branches are reachable from main but were
+ * never merged in any meaningful sense; the older `git branch --merged` check
+ * misclassified them as merged and caused subsequent runs to skip the still-
+ * open issue.
+ *
+ * Squash-merged branches do not satisfy this check (their tip is not on main
+ * after squash) — callers that need to detect squash merges should rely on
+ * commit-message detection (see {@link isIssueMergedIntoMain}'s `--grep` path)
+ * or a PR API check.
+ *
  * @param branchName - The branch name to check (e.g., "feature/33-some-title")
  * @param baseBranch - The base branch to check against (default: "main")
- * @returns true if the branch is merged into the base branch, false otherwise
+ * @returns true if a merge commit on baseBranch records branchName's tip as a
+ *   non-first parent, false otherwise
  */
 export declare function isBranchMergedIntoMain(branchName: string, baseBranch?: string): boolean;
 /**
  * Check if a feature branch for an issue is merged into a base branch
  *
  * Tries multiple detection methods:
- * 1. Check if branch exists and is merged via `git branch --merged <baseBranch>`
+ * 1. Find `feature/<N>-*` branches with `git branch -a` and check via {@link isBranchMergedIntoMain}
  * 2. Check for merge commits mentioning the issue
  *
  * @param issueNumber - The issue number to check

package/dist/src/lib/workflow/pr-status.js

@@ -31,22 +31,54 @@ export function checkPRMergeStatus(prNumber) {
 /**
  * Check if a branch has been merged into a base branch using git
  *
+ * "Merged" here means the branch was the source of an actual merge commit on
+ * the base branch — i.e., the branch tip appears as a non-first parent of some
+ * merge commit reachable from baseBranch. This deliberately excludes the case
+ * where the branch tip is just an ancestor of baseBranch with no commits ever
+ * added (e.g., a worktree branch created from main that was abandoned before
+ * any commits were made). Those branches are reachable from main but were
+ * never merged in any meaningful sense; the older `git branch --merged` check
+ * misclassified them as merged and caused subsequent runs to skip the still-
+ * open issue.
+ *
+ * Squash-merged branches do not satisfy this check (their tip is not on main
+ * after squash) — callers that need to detect squash merges should rely on
+ * commit-message detection (see {@link isIssueMergedIntoMain}'s `--grep` path)
+ * or a PR API check.
+ *
  * @param branchName - The branch name to check (e.g., "feature/33-some-title")
  * @param baseBranch - The base branch to check against (default: "main")
- * @returns true if the branch is merged into the base branch, false otherwise
+ * @returns true if a merge commit on baseBranch records branchName's tip as a
+ *   non-first parent, false otherwise
  */
 export function isBranchMergedIntoMain(branchName, baseBranch = "main") {
     try {
-        // Get branches merged into the base branch
-        const result = spawnSync("git", ["branch", "--merged", baseBranch], {
+        // Resolve the branch tip SHA. If the branch can't be resolved (deleted,
+        // typo'd, etc.), it can't be "merged" by any definition.
+        const tipResult = spawnSync("git", ["rev-parse", branchName], {
             stdio: "pipe",
             timeout: 10000,
         });
-        if (result.status === 0 && result.stdout) {
-            const mergedBranches = result.stdout.toString();
-            // Check if our branch is in the list (handle both local and remote refs)
-            return (mergedBranches.includes(branchName) ||
-                mergedBranches.includes(`remotes/origin/${branchName}`));
+        if (tipResult.status !== 0)
+            return false;
+        const branchTip = tipResult.stdout.toString().trim();
+        if (!branchTip)
+            return false;
+        // Walk recent merge commits on baseBranch and check whether any records
+        // the branch tip as a non-first parent. The first parent of a merge
+        // commit is the prior tip of baseBranch; non-first parents are the
+        // sources being merged in.
+        const mergesResult = spawnSync("git", ["rev-list", "--merges", "--parents", "-200", baseBranch], { stdio: "pipe", timeout: 10000 });
+        if (mergesResult.status === 0 && mergesResult.stdout) {
+            const lines = mergesResult.stdout.toString().trim().split("\n");
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                const parts = line.split(" ");
+                if (parts.length > 2 && parts.slice(2).includes(branchTip)) {
+                    return true;
+                }
+            }
         }
     }
     catch {
@@ -58,7 +90,7 @@ export function isBranchMergedIntoMain(branchName, baseBranch = "main") {
  * Check if a feature branch for an issue is merged into a base branch
  *
  * Tries multiple detection methods:
- * 1. Check if branch exists and is merged via `git branch --merged <baseBranch>`
+ * 1. Find `feature/<N>-*` branches with `git branch -a` and check via {@link isBranchMergedIntoMain}
  * 2. Check for merge commits mentioning the issue
  *
  * @param issueNumber - The issue number to check