@shepai/cli 1.40.1 → 1.41.0

package/dist/packages/core/src/domain/factories/spec-yaml-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec-yaml-parser.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/domain/factories/spec-yaml-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACd,MAAM,qBAAqB,CAAC;AAgF7B;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAI9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAInE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAIpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAI7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAIrE"}
+{"version":3,"file":"spec-yaml-parser.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/domain/factories/spec-yaml-parser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACd,MAAM,qBAAqB,CAAC;AAiF7B;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAI9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAInE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAIpE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAI7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAIrE"}

package/dist/packages/core/src/domain/factories/spec-yaml-parser.js

@@ -6,6 +6,7 @@
  * to the TypeScript types — no manual field-by-field extraction needed.
  */
 import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
 import yaml from 'js-yaml';
 import { readdirSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
@@ -19,6 +20,7 @@ function resolveSchemaDir() {
 }
 function createValidator() {
     const ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajv);
     const schemaDir = resolveSchemaDir();
     const files = readdirSync(schemaDir).filter((f) => f.endsWith('.yaml'));
     for (const file of files) {

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.d.ts

@@ -8,7 +8,7 @@ export { FeatureAgentAnnotation, type FeatureAgentState } from './state.js';
  */
 export interface FeatureAgentGraphDeps {
     executor: IAgentExecutor;
-    mergeNodeDeps: MergeNodeDeps;
+    mergeNodeDeps?: Omit<MergeNodeDeps, 'executor'>;
 }
 /**
  * Factory function that creates and compiles the feature-agent LangGraph.

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAOpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAS5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAyHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0EnC"}
+{"version":3,"file":"feature-agent-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AAOpG,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAS5E,OAAO,EAAE,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,cAAc,CAAC;IACzB,aAAa,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;CACjD;AAyHD;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,qBAAqB,GAAG,cAAc,EACtD,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwEnC"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-graph.js

@@ -134,9 +134,7 @@ function createPlanTasksValidator() {
  */
 export function createFeatureAgentGraph(depsOrExecutor, checkpointer) {
     // Support legacy signature: createFeatureAgentGraph(executor, checkpointer)
-    const deps = 'execute' in depsOrExecutor
-        ? { executor: depsOrExecutor, mergeNodeDeps: undefined }
-        : depsOrExecutor;
+    const deps = 'execute' in depsOrExecutor ? { executor: depsOrExecutor } : depsOrExecutor;
     const { executor } = deps;
     const graph = new StateGraph(FeatureAgentAnnotation)
         // --- Producer nodes ---
@@ -156,10 +154,6 @@ export function createFeatureAgentGraph(depsOrExecutor, checkpointer) {
         .addNode('repair_research', createRepairNode('research.yaml', executor))
         .addNode('repair_plan_tasks', createRepairNode(['plan.yaml', 'tasks.yaml'], executor))
         // --- Edges: linear flow with validation gates ---
-        // Interruptible nodes (requirements, plan) use conditional edges that
-        // check _needsReexecution to loop back on rejection. This ensures each
-        // re-execution is a fresh node invocation with a clean interrupt index,
-        // avoiding the stale interrupt replay bug with dual interrupt() calls.
         .addEdge(START, 'analyze')
         .addEdge('analyze', 'validate_spec_analyze')
         .addConditionalEdges('validate_spec_analyze', routeValidation('requirements', 'repair_spec_analyze'))
@@ -175,8 +169,12 @@ export function createFeatureAgentGraph(depsOrExecutor, checkpointer) {
         .addEdge('repair_plan_tasks', 'validate_plan_tasks');
     // --- Merge node: wired when deps are provided ---
     if (deps.mergeNodeDeps) {
+        const mergeNodeDeps = {
+            executor,
+            ...deps.mergeNodeDeps,
+        };
         graph
-            .addNode('merge', createMergeNode(deps.mergeNodeDeps))
+            .addNode('merge', createMergeNode(mergeNodeDeps))
             .addEdge('implement', 'merge')
             .addEdge('merge', END);
     }

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAqB1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAoD1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAkM/D"}
+{"version":3,"file":"feature-agent-worker.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.ts"],"names":[],"mappings":";AACA;;;;;;;;GAQG;AAEH,OAAO,kBAAkB,CAAC;AAoB1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAoD1D;AAgCD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAkM/D"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/feature-agent-worker.js

@@ -21,7 +21,6 @@ import { InitializeSettingsUseCase } from '../../../../application/use-cases/set
 import { setHeartbeatContext } from './heartbeat.js';
 import { setPhaseTimingContext, recordLifecycleEvent } from './phase-timing-context.js';
 import { setLifecycleContext } from './lifecycle-context.js';
-import { generatePrYaml } from './nodes/pr-yaml-generator.js';
 /**
  * Parse CLI arguments into a WorkerArgs object.
  * Throws if any required argument is missing.
@@ -128,8 +127,7 @@ export async function runWorker(args) {
     const graphDeps = {
         executor,
         mergeNodeDeps: {
-            gitPrService,
-            generatePrYaml,
+            getDiffSummary: (cwd, baseBranch) => gitPrService.getPrDiffSummary(cwd, baseBranch),
             featureRepository,
         },
     };

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge-output-parser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Merge Output Parser
+ *
+ * Extracts structured data (commit SHA, PR URL/number) from agent text output
+ * using regex patterns. Falls back gracefully to null when patterns don't match.
+ */
+export interface PrParseResult {
+    url: string;
+    number: number;
+}
+/**
+ * Extract the first commit SHA from agent output text.
+ * Looks for git commit output format `[branch SHA]` or `commit SHA`.
+ * Returns null if no SHA found.
+ */
+export declare function parseCommitHash(output: string): string | null;
+/**
+ * Extract the first GitHub PR URL and number from agent output text.
+ * Returns null if no PR URL found.
+ */
+export declare function parsePrUrl(output: string): PrParseResult | null;
+//# sourceMappingURL=merge-output-parser.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge-output-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-output-parser.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge-output-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI7D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAI/D"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge-output-parser.js

@@ -0,0 +1,32 @@
+/**
+ * Merge Output Parser
+ *
+ * Extracts structured data (commit SHA, PR URL/number) from agent text output
+ * using regex patterns. Falls back gracefully to null when patterns don't match.
+ */
+// Matches git commit output: [branch SHA] message
+// Also matches "Created commit SHA" or "commit SHA" patterns
+const COMMIT_SHA_RE = /\[[\w/.-]+\s+([0-9a-f]{7,40})\]|(?:commit\s+)([0-9a-f]{7,40})/i;
+// Matches GitHub PR URL: https://github.com/owner/repo/pull/123
+const PR_URL_RE = /(https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+))/;
+/**
+ * Extract the first commit SHA from agent output text.
+ * Looks for git commit output format `[branch SHA]` or `commit SHA`.
+ * Returns null if no SHA found.
+ */
+export function parseCommitHash(output) {
+    const match = output.match(COMMIT_SHA_RE);
+    if (!match)
+        return null;
+    return match[1] ?? match[2] ?? null;
+}
+/**
+ * Extract the first GitHub PR URL and number from agent output text.
+ * Returns null if no PR URL found.
+ */
+export function parsePrUrl(output) {
+    const match = output.match(PR_URL_RE);
+    if (!match)
+        return null;
+    return { url: match[1], number: parseInt(match[2], 10) };
+}

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

@@ -1,20 +1,19 @@
 /**
- * Merge Node — Post-Implementation Merge Flow
+ * Merge Node — Agent-Driven Post-Implementation Merge Flow
  *
- * Handles the complete merge workflow after implementation:
- * 1. Commit uncommitted changes and push
- * 2. Generate pr.yaml (always) and optionally create PR
- * 3. Optionally auto-merge (via PR or direct branch merge)
- * 4. Update feature lifecycle and clean up
+ * Handles the complete merge workflow after implementation using two agent calls:
+ * 1. Commit + push + create PR (via agent executor)
+ * 2. Merge/squash (via agent executor, after approval gate)
  *
  * Uses interrupt() for the merge approval gate when allowMerge=false.
  */
+import type { IAgentExecutor } from '../../../../../application/ports/output/agents/agent-executor.interface.js';
 import type { FeatureAgentState } from '../state.js';
-import type { IGitPrService } from '../../../../../application/ports/output/services/git-pr-service.interface.js';
 import type { IFeatureRepository } from '../../../../../application/ports/output/repositories/feature-repository.interface.js';
+import type { DiffSummary } from '../../../../../application/ports/output/services/git-pr-service.interface.js';
 export interface MergeNodeDeps {
-    gitPrService: IGitPrService;
-    generatePrYaml: (specDir: string, branch: string, baseBranch: string) => string;
+    executor: IAgentExecutor;
+    getDiffSummary: (cwd: string, baseBranch: string) => Promise<DiffSummary>;
     featureRepository: Pick<IFeatureRepository, 'findById' | 'update'>;
 }
 /**

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iEAAiE,CAAC;AACrG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yEAAyE,CAAC;AAWlH,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,aAAa,CAAC;IAC5B,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IAChF,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC;CACpE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,IAGnC,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAwJ7E"}
+{"version":3,"file":"merge.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yEAAyE,CAAC;AAClH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iEAAiE,CAAC;AAkBnG,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC1E,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC;CACpE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,IAGnC,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CA2H7E"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/merge.node.js

@@ -1,20 +1,20 @@
 /**
- * Merge Node — Post-Implementation Merge Flow
+ * Merge Node — Agent-Driven Post-Implementation Merge Flow
  *
- * Handles the complete merge workflow after implementation:
- * 1. Commit uncommitted changes and push
- * 2. Generate pr.yaml (always) and optionally create PR
- * 3. Optionally auto-merge (via PR or direct branch merge)
- * 4. Update feature lifecycle and clean up
+ * Handles the complete merge workflow after implementation using two agent calls:
+ * 1. Commit + push + create PR (via agent executor)
+ * 2. Merge/squash (via agent executor, after approval gate)
  *
  * Uses interrupt() for the merge approval gate when allowMerge=false.
  */
 import { interrupt, isGraphBubbleUp } from '@langchain/langgraph';
 import { SdlcLifecycle, PrStatus } from '../../../../../domain/generated/output.js';
-import { createNodeLogger, shouldInterrupt } from './node-helpers.js';
+import { createNodeLogger, shouldInterrupt, retryExecute, buildExecutorOptions, } from './node-helpers.js';
 import { reportNodeStart } from '../heartbeat.js';
 import { recordPhaseStart, recordPhaseEnd, recordApprovalWaitStart, } from '../phase-timing-context.js';
 import { updateNodeLifecycle } from '../lifecycle-context.js';
+import { buildCommitPushPrPrompt, buildMergeSquashPrompt } from './prompts/merge-prompts.js';
+import { parseCommitHash, parsePrUrl } from './merge-output-parser.js';
 /**
  * Factory that creates the merge node function.
  *
@@ -32,60 +32,39 @@ export function createMergeNode(deps) {
         // Record merge phase timing
         const mergeTimingId = await recordPhaseStart('merge');
         try {
-            const { gitPrService } = deps;
+            const { executor } = deps;
             const cwd = state.worktreePath;
             // Resolve branch name from feature
             const feature = await deps.featureRepository.findById(state.featureId);
             const branch = feature?.branch ?? `feat/${state.featureId}`;
             const baseBranch = 'main';
-            // --- Step 1: Commit and Push ---
-            let commitHash = state.commitHash;
-            const hasChanges = await gitPrService.hasUncommittedChanges(cwd);
-            if (hasChanges) {
-                log.info('Uncommitted changes detected, committing...');
-                commitHash = await gitPrService.commitAll(cwd, `feat: implementation complete for ${state.featureId}`);
-                messages.push(`[merge] Committed changes: ${commitHash}`);
-            }
-            else {
-                log.info('No uncommitted changes');
-                messages.push('[merge] No uncommitted changes to commit');
-            }
-            // Push is controlled by the push flag (--push, or implied by --pr)
-            const shouldPush = state.push || state.openPr;
-            if (shouldPush) {
-                log.info('Pushing to remote...');
-                await gitPrService.push(cwd, branch, true);
-                messages.push(`[merge] Pushed branch ${branch}`);
-            }
-            else {
-                log.info('Push skipped (--push not set)');
-                messages.push('[merge] Push skipped (use --push to push to remote)');
-            }
-            // --- Step 2: Generate pr.yaml (always) ---
-            log.info('Generating pr.yaml...');
-            const prYamlPath = deps.generatePrYaml(state.specDir, branch, baseBranch);
-            messages.push(`[merge] Generated pr.yaml at ${prYamlPath}`);
-            // --- Step 3: Create PR (if openPr=true and not already created) ---
+            const options = buildExecutorOptions(state);
+            // --- Agent Call 1: Commit + Push + PR ---
+            log.info('Agent call 1: commit + push + PR');
+            const commitPushPrPrompt = buildCommitPushPrPrompt(state, branch, baseBranch);
+            const commitResult = await retryExecute(executor, commitPushPrPrompt, options, {
+                logger: log,
+            });
+            // Parse structured data from agent output
+            const commitHash = parseCommitHash(commitResult.result) ?? state.commitHash;
+            messages.push(`[merge] Agent completed commit/push/PR operations`);
             let prUrl = state.prUrl;
             let prNumber = state.prNumber;
             const ciStatus = state.ciStatus;
-            if (state.openPr && !state.prUrl) {
-                log.info('Creating pull request...');
-                const prResult = await gitPrService.createPr(cwd, prYamlPath);
-                prUrl = prResult.url;
-                prNumber = prResult.number;
-                messages.push(`[merge] PR created: ${prUrl}`);
-                // CI watching disabled — let the user check CI status externally
-                log.info('Skipping CI watch (disabled)');
-                messages.push('[merge] CI watch skipped');
+            if (state.openPr) {
+                const prResult = parsePrUrl(commitResult.result);
+                if (prResult) {
+                    prUrl = prResult.url;
+                    prNumber = prResult.number;
+                    messages.push(`[merge] PR created: ${prUrl}`);
+                }
             }
-            // --- Step 4: Merge approval gate ---
+            // --- Merge approval gate ---
             if (shouldInterrupt('merge', state.approvalGates)) {
                 log.info('Interrupting for merge approval');
-                // Close timing before interrupt so the pre-approval work has a duration
                 await recordPhaseEnd(mergeTimingId, Date.now() - startTime);
                 await recordApprovalWaitStart(mergeTimingId);
-                const diffSummary = await gitPrService.getPrDiffSummary(cwd, baseBranch);
+                const diffSummary = await deps.getDiffSummary(cwd, baseBranch);
                 interrupt({
                     node: 'merge',
                     message: 'Merge approval required. Review the changes and approve to continue.',
@@ -94,23 +73,16 @@ export function createMergeNode(deps) {
                     prNumber,
                 });
             }
-            // --- Step 5: Auto-merge (if enabled) ---
+            // --- Agent Call 2: Merge (if enabled) ---
             let merged = false;
             if (state.approvalGates?.allowMerge) {
-                if (state.openPr && prNumber) {
-                    log.info(`Auto-merging PR #${prNumber}...`);
-                    await gitPrService.mergePr(cwd, prNumber, 'squash');
-                    messages.push(`[merge] PR #${prNumber} merged via squash`);
-                    merged = true;
-                }
-                else {
-                    log.info(`Auto-merging branch ${branch} into ${baseBranch}...`);
-                    await gitPrService.mergeBranch(cwd, branch, baseBranch);
-                    messages.push(`[merge] Branch ${branch} merged into ${baseBranch}`);
-                    merged = true;
-                }
+                log.info('Agent call 2: merge/squash');
+                const mergePrompt = buildMergeSquashPrompt({ ...state, prUrl, prNumber, commitHash }, branch, baseBranch);
+                await retryExecute(executor, mergePrompt, options, { logger: log });
+                messages.push(`[merge] Agent completed merge operation`);
+                merged = true;
             }
-            // --- Step 6: Update feature lifecycle ---
+            // --- Update feature lifecycle ---
             const newLifecycle = merged ? SdlcLifecycle.Maintain : SdlcLifecycle.Review;
             if (feature) {
                 await deps.featureRepository.update({
@@ -154,8 +126,6 @@ export function createMergeNode(deps) {
             // Record phase end even on failure so timing shows duration, not "running"
             await recordPhaseEnd(mergeTimingId, Date.now() - startTime);
             // Re-throw so LangGraph does NOT checkpoint this node as completed.
-            // This allows `feat resume` to retry the merge node instead of
-            // restarting the entire graph from scratch.
             throw err;
         }
     };

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/merge-prompts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Merge Node Prompt Builders
+ *
+ * Builds prompts for the two agent calls in the merge node:
+ * 1. buildCommitPushPrPrompt — commit (always), push (conditional), PR create (conditional)
+ * 2. buildMergeSquashPrompt — merge/squash PR or branch
+ */
+import type { FeatureAgentState } from '../../state.js';
+/**
+ * Build a prompt for the commit + push + PR agent call.
+ *
+ * The agent always commits. Push and PR creation are conditional based
+ * on state.push and state.openPr flags.
+ */
+export declare function buildCommitPushPrPrompt(state: FeatureAgentState, branch: string, baseBranch: string): string;
+/**
+ * Build a prompt for the merge/squash agent call.
+ *
+ * When a PR exists, uses `gh pr merge` (remote operation — no local merge needed).
+ * When no PR exists, performs a local merge in the ORIGINAL repo directory
+ * (not the worktree, which IS the feature branch).
+ */
+export declare function buildMergeSquashPrompt(state: FeatureAgentState, branch: string, baseBranch: string): string;
+//# sourceMappingURL=merge-prompts.d.ts.map

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/merge-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-prompts.d.ts","sourceRoot":"","sources":["../../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/merge-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,MAAM,CAwDR;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,MAAM,CAwDR"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/prompts/merge-prompts.js

@@ -0,0 +1,128 @@
+/**
+ * Merge Node Prompt Builders
+ *
+ * Builds prompts for the two agent calls in the merge node:
+ * 1. buildCommitPushPrPrompt — commit (always), push (conditional), PR create (conditional)
+ * 2. buildMergeSquashPrompt — merge/squash PR or branch
+ */
+import { readSpecFile } from '../node-helpers.js';
+/**
+ * Build a prompt for the commit + push + PR agent call.
+ *
+ * The agent always commits. Push and PR creation are conditional based
+ * on state.push and state.openPr flags.
+ */
+export function buildCommitPushPrPrompt(state, branch, baseBranch) {
+    const specContent = readSpecFile(state.specDir, 'spec.yaml');
+    const cwd = state.worktreePath || state.repositoryPath;
+    const shouldPush = state.push || state.openPr;
+    const steps = [];
+    // Step 1: Commit (always)
+    steps.push(`1. Review the current changes using \`git diff\` and \`git status\`
+2. Stage all changes with \`git add -A\`
+3. Write a conventional commit message based on the actual diff content
+   - Use the format: \`feat(<scope>): <description>\` or \`fix(<scope>): <description>\`
+   - The commit message should summarize what actually changed, not be generic
+   - Run \`git commit -m "<your message>"\``);
+    // Step 2: Push (conditional)
+    if (shouldPush) {
+        steps.push(`4. Push the branch to remote: \`git push -u origin ${branch}\``);
+    }
+    // Step 3: PR creation (conditional)
+    if (state.openPr) {
+        steps.push(`${shouldPush ? '5' : '4'}. Create a pull request:
+   - Run \`gh pr create --base ${baseBranch} --head ${branch} --title "<title>" --body "<body>"\`
+   - Write a descriptive PR title using conventional commit format
+   - Write a rich PR body that summarizes the changes using the spec context below
+   - After creating the PR, update \`${state.specDir}/feature.yaml\` to set the prUrl field with the PR URL`);
+    }
+    return `You are performing git operations in a feature worktree.
+
+## Feature Specification Context
+
+\`\`\`yaml
+${specContent}
+\`\`\`
+
+## Branch Information
+
+- Feature branch: \`${branch}\`
+- Base branch: \`${baseBranch}\`
+
+## Working Directory
+
+${cwd}
+
+## Instructions
+
+${steps.join('\n')}
+
+## Constraints
+
+- Write a meaningful conventional commit message derived from the actual diff — do NOT use generic messages
+- Do NOT modify any source code files — only perform git operations
+- Do NOT amend existing commits
+- If there are no changes to commit, skip the commit step and report that no changes were found`;
+}
+/**
+ * Build a prompt for the merge/squash agent call.
+ *
+ * When a PR exists, uses `gh pr merge` (remote operation — no local merge needed).
+ * When no PR exists, performs a local merge in the ORIGINAL repo directory
+ * (not the worktree, which IS the feature branch).
+ */
+export function buildMergeSquashPrompt(state, branch, baseBranch) {
+    if (state.prUrl && state.prNumber) {
+        // PR path: remote merge via GitHub CLI — no local merge needed
+        return `You are merging a pull request via the GitHub CLI.
+
+## PR to Merge
+
+- PR URL: ${state.prUrl}
+- PR Number: #${state.prNumber}
+
+## Instructions
+
+1. Merge the PR using squash merge: \`gh pr merge ${state.prNumber} --squash --delete-branch\`
+2. If merge conflicts are encountered, resolve them and retry
+3. If the merge fails, report the error clearly
+
+## Constraints
+
+- Use squash merge strategy to keep history clean
+- Report the merge result clearly`;
+    }
+    // Non-PR path: local merge in the ORIGINAL repo (not the worktree)
+    const originalRepo = state.repositoryPath;
+    return `You are performing a local merge in the original repository directory.
+
+IMPORTANT: You MUST run all git commands in the original repository directory, NOT in any worktree.
+
+## Branch to Merge
+
+- Feature branch: \`${branch}\`
+- Base branch: \`${baseBranch}\`
+
+## Working Directory
+
+${originalRepo}
+
+## Instructions
+
+1. Change to the original repository: \`cd ${originalRepo}\`
+2. Fetch latest: \`git fetch origin\`
+3. Checkout the base branch: \`git checkout ${baseBranch}\`
+4. Pull latest base: \`git pull origin ${baseBranch}\`
+5. Merge the feature branch: \`git merge --squash ${branch}\`
+6. If merge conflicts are encountered, resolve them manually and complete the merge
+7. Commit the squash merge with a descriptive conventional commit message
+8. Delete the feature branch after successful merge: \`git branch -d ${branch}\`
+
+## Constraints
+
+- Use squash merge strategy to keep history clean
+- All commands MUST run in \`${originalRepo}\` (the original repo), NOT in the worktree
+- If conflicts arise during merge, attempt to resolve them intelligently
+- Do NOT modify any source code beyond what is needed for conflict resolution
+- Report the merge result clearly`;
+}