fix(agents): skip agent call for local-only merge, commit programmatically

when no push/pr is needed (local-only mode), the merge node now commits
changes in the worktree using programmatic git commands instead of
calling the agent executor. this eliminates the second cursor cli call
that hangs indefinitely on windows.

adds commitAll dep to merge node, wired via gitPrService.commitAll.
agent call 1 now only runs when push or openPr is requested.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: arielshad

packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts

@@ -241,6 +241,14 @@ export async function runWorker(args: WorkerArgs): Promise<void> {
         premergeBaseSha?: string
       ) => gitPrService.verifyMerge(cwd, featureBranch, baseBranch, premergeBaseSha),
       revParse: (cwd: string, ref: string) => gitPrService.revParse(cwd, ref),
+      commitAll: async (cwd: string, message: string) => {
+        try {
+          return await gitPrService.commitAll(cwd, message);
+        } catch {
+          // commitAll throws when there's nothing to commit — return undefined
+          return undefined;
+        }
+      },
       localMergeSquash: (
         cwd: string,
         featureBranch: string,

packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge/merge.node.ts

@@ -71,6 +71,11 @@ export interface MergeNodeDeps {
    * Resolve a branch ref to its current SHA.
    */
   revParse: (cwd: string, ref: string) => Promise<string>;
+  /**
+   * Stage all changes and commit in the given directory.
+   * Returns the commit hash, or undefined if there was nothing to commit.
+   */
+  commitAll: (cwd: string, message: string) => Promise<string | undefined>;
   gitPrService: IGitPrService;
   cleanupFeatureWorktreeUseCase: Pick<CleanupFeatureWorktreeUseCase, 'execute'>;
 }
@@ -159,77 +164,104 @@ export function createMergeNode(deps: MergeNodeDeps) {
 
       // --- Agent Call 1: Commit + Push + PR (skip on approval resume) ---
       if (!isResumeAfterInterrupt) {
-        if (!remoteAvailable) {
-          log.info('No git remote configured — skipping push and PR, will merge locally');
-        }
-
         const effectiveState = remoteAvailable ? state : { ...state, push: false, openPr: false };
+        const needsAgentCall = effectiveState.push || effectiveState.openPr;
 
-        log.info('Agent call 1: commit + push + PR');
-        const commitPushPrPrompt = buildCommitPushPrPrompt(
-          effectiveState,
-          branch,
-          baseBranch,
-          repoUrl
-        );
-        const commitResult = await retryExecute(executor, commitPushPrPrompt, options, {
-          logger: log,
-        });
-        totalInputTokens += commitResult.usage?.inputTokens ?? 0;
-        totalOutputTokens += commitResult.usage?.outputTokens ?? 0;
-
-        commitHash = parseCommitHash(commitResult.result) ?? state.commitHash;
-        messages.push(`[merge] Agent completed commit/push/PR operations`);
-
-        if (effectiveState.openPr) {
-          const prResult = parsePrUrl(commitResult.result);
-          if (prResult) {
-            prUrl = prResult.url;
-            prNumber = prResult.number;
-
-            // Cross-validate agent-parsed PR URL against authoritative source.
-            // The agent may hallucinate the repo URL or PR number, so we look up
-            // the real PR for this branch via the GitHub API.
-            try {
-              const prStatuses = await deps.gitPrService.listPrStatuses(cwd);
-              const matchingPr = prStatuses.find((pr) => pr.headRefName === branch);
-              if (matchingPr) {
-                prUrl = matchingPr.url;
-                prNumber = matchingPr.number;
-              }
-            } catch {
-              // gh CLI unavailable or API failure — fall back to agent-parsed URL
+        if (!needsAgentCall) {
+          // Local-only: commit programmatically in worktree, no agent needed.
+          // This avoids calling the agent executor just to run git commit,
+          // which is slow/unreliable on some platforms (e.g. cursor on Windows hangs).
+          log.info('Local-only mode — committing in worktree programmatically (no agent)');
+          const worktreeCwd = state.worktreePath ?? cwd;
+          try {
+            const msg = `feat: ${branch}`;
+            const hash = await deps.commitAll(worktreeCwd, msg);
+            if (hash) {
+              commitHash = hash;
+              log.info(`Committed changes in worktree: ${commitHash}`);
+              messages.push(`[merge] Programmatic commit: ${commitHash}`);
+            } else {
+              log.info('No changes to commit in worktree');
+              messages.push(`[merge] No changes to commit`);
             }
-
-            messages.push(`[merge] PR created: ${prUrl}`);
+          } catch (commitErr) {
+            const errMsg = commitErr instanceof Error ? commitErr.message : String(commitErr);
+            log.info(`Programmatic commit failed: ${errMsg} — falling back to agent`);
+            messages.push(`[merge] Programmatic commit failed, falling back to agent`);
+            // Fall through — needsAgentCall stays false so agent won't run either.
+            // The localMergeSquash will handle uncommitted changes via --squash.
           }
         }
 
-        // --- CI watch/fix loop (when push or openPr is enabled and CI watch is not disabled) ---
-        const ciWatchEnabled = getSettings().workflow?.ciWatchEnabled !== false;
-        if (ciWatchEnabled && (effectiveState.push || effectiveState.openPr)) {
-          const ciResult = await runCiWatchFixLoop(
-            {
-              executor,
-              gitPrService: deps.gitPrService,
-              featureRepository: deps.featureRepository,
-            },
-            {
-              cwd,
-              branch,
-              options,
-              feature,
-              prUrl,
-              prNumber,
-              existingAttempts: ciFixAttempts,
-              messages,
-              log,
-            }
+        if (needsAgentCall) {
+          if (!remoteAvailable) {
+            log.info('No git remote configured — skipping push and PR, will merge locally');
+          }
+
+          log.info('Agent call 1: commit + push + PR');
+          const commitPushPrPrompt = buildCommitPushPrPrompt(
+            effectiveState,
+            branch,
+            baseBranch,
+            repoUrl
           );
-          ciStatus = ciResult.ciStatus;
-          ciFixAttempts = ciResult.ciFixAttempts;
-          ciFixHistory = ciResult.ciFixHistory;
-          ciFixStatus = ciResult.ciFixStatus;
+          const commitResult = await retryExecute(executor, commitPushPrPrompt, options, {
+            logger: log,
+          });
+          totalInputTokens += commitResult.usage?.inputTokens ?? 0;
+          totalOutputTokens += commitResult.usage?.outputTokens ?? 0;
+
+          commitHash = parseCommitHash(commitResult.result) ?? state.commitHash;
+          messages.push(`[merge] Agent completed commit/push/PR operations`);
+
+          if (effectiveState.openPr) {
+            const prResult = parsePrUrl(commitResult.result);
+            if (prResult) {
+              prUrl = prResult.url;
+              prNumber = prResult.number;
+
+              // Cross-validate agent-parsed PR URL against authoritative source.
+              try {
+                const prStatuses = await deps.gitPrService.listPrStatuses(cwd);
+                const matchingPr = prStatuses.find((pr) => pr.headRefName === branch);
+                if (matchingPr) {
+                  prUrl = matchingPr.url;
+                  prNumber = matchingPr.number;
+                }
+              } catch {
+                // gh CLI unavailable or API failure — fall back to agent-parsed URL
+              }
+
+              messages.push(`[merge] PR created: ${prUrl}`);
+            }
+          }
+
+          // --- CI watch/fix loop (when push or openPr is enabled and CI watch is not disabled) ---
+          const ciWatchEnabled = getSettings().workflow?.ciWatchEnabled !== false;
+          if (ciWatchEnabled && (effectiveState.push || effectiveState.openPr)) {
+            const ciResult = await runCiWatchFixLoop(
+              {
+                executor,
+                gitPrService: deps.gitPrService,
+                featureRepository: deps.featureRepository,
+              },
+              {
+                cwd,
+                branch,
+                options,
+                feature,
+                prUrl,
+                prNumber,
+                existingAttempts: ciFixAttempts,
+                messages,
+                log,
+              }
+            );
+            ciStatus = ciResult.ciStatus;
+            ciFixAttempts = ciResult.ciFixAttempts;
+            ciFixHistory = ciResult.ciFixHistory;
+            ciFixStatus = ciResult.ciFixStatus;
+          }
         }
 
         // --- Persist lifecycle + PR data before approval gate ---

tests/integration/infrastructure/services/agents/graph-state-transitions/setup.ts

@@ -164,6 +164,7 @@ export function createStubMergeNodeDeps(featureId?: string): Omit<MergeNodeDeps,
     getDefaultBranch: vi.fn().mockResolvedValue('main'),
     verifyMerge: vi.fn().mockResolvedValue(true),
     revParse: vi.fn().mockResolvedValue('premerge-sha-mock'),
+    commitAll: vi.fn().mockResolvedValue('mock-commit-hash'),
     localMergeSquash: vi.fn().mockResolvedValue(undefined),
     featureRepository: createStatefulFeatureRepo(featureId),
     gitPrService: {

tests/integration/infrastructure/services/agents/merge-flow.test.ts

@@ -146,6 +146,7 @@ describe('Merge Flow (Graph-level)', () => {
         getDefaultBranch: vi.fn().mockResolvedValue('main'),
         verifyMerge: vi.fn().mockResolvedValue(true),
         revParse: vi.fn().mockResolvedValue('premerge-sha-mock'),
+        commitAll: vi.fn().mockResolvedValue('mock-commit-hash'),
         localMergeSquash: vi.fn().mockResolvedValue(undefined),
         featureRepository: featureRepo,
         gitPrService: createMockGitPrService(),

tests/integration/infrastructure/services/git/merge-step-real-git/setup.ts

@@ -248,6 +248,7 @@ export function buildDeps(opts: BuildDepsOptions = {}): BuiltDeps {
     featureRepository,
     verifyMerge: (cwd, fb, bb, pre) => gitPrService.verifyMerge(cwd, fb, bb, pre),
     revParse: (cwd, ref) => gitPrService.revParse(cwd, ref),
+    commitAll: async () => 'mock-commit-hash',
     localMergeSquash: (cwd, featureBranch, baseBranch, commitMessage, hasRemote) =>
       gitPrService.localMergeSquash(cwd, featureBranch, baseBranch, commitMessage, hasRemote),
     gitPrService,

tests/unit/infrastructure/services/agents/feature-agent/nodes/merge.node.ci-watch.test.ts

@@ -190,6 +190,7 @@ function baseDeps(overrides?: Partial<MergeNodeDeps>): MergeNodeDeps {
     featureRepository: createMockFeatureRepo(),
     verifyMerge: vi.fn().mockResolvedValue(true),
     revParse: vi.fn().mockResolvedValue('premerge-sha-mock'),
+    commitAll: vi.fn().mockResolvedValue('mock-commit-hash'),
     localMergeSquash: vi.fn().mockResolvedValue(undefined),
     gitPrService: createMockGitPrService(),
     cleanupFeatureWorktreeUseCase: { execute: vi.fn().mockResolvedValue(undefined) } as any,

tests/unit/infrastructure/services/agents/feature-agent/nodes/merge.node.test.ts

@@ -165,6 +165,7 @@ function baseDeps(overrides?: Partial<MergeNodeDeps>): MergeNodeDeps {
     featureRepository: createMockFeatureRepo(),
     verifyMerge: vi.fn().mockResolvedValue(true),
     revParse: vi.fn().mockResolvedValue('premerge-sha-abc'),
+    commitAll: vi.fn().mockResolvedValue('mock-commit-hash'),
     localMergeSquash: vi.fn().mockResolvedValue(undefined),
     gitPrService: {
       getCiStatus: vi.fn().mockResolvedValue({ status: 'success', runUrl: null }),