diff --git a/common/src/main/java/com/ntropy/common/domain/LoanDisbursementKeywords.java b/common/src/main/java/com/ntropy/common/domain/LoanDisbursementKeywords.java
new file mode 100644
index 00000000..046b4366
--- /dev/null
+++ b/common/src/main/java/com/ntropy/common/domain/LoanDisbursementKeywords.java
@@ -0,0 +1,43 @@
+package com.ntropy.common.domain;
+
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * LOAN 거래구분명에서 대출금 지급(신규·실행·증액) 거래를 판정하는 단일 규칙입니다.
+ * account-service의 월간 소비 집계·금융 납입 예정 조회(SQL)와 ai-service의
+ * 일간 소비 분류 배치(Java)가 이 키워드 목록과 판정 의미를 함께 사용합니다.
+ *
+ * 판정 의미는 "공백 정규화 후 부분 문자열 포함"입니다. "실행"이 "대출실행"의
+ * 부분 문자열이므로 "대출실행"은 목록에서 제외해도 판정 결과가 같습니다.
+ */
+public final class LoanDisbursementKeywords {
+
+    public static final List<String> KEYWORDS = List.of(
+            "신규",
+            "실행",
+            "증액"
+    );
+
+    private LoanDisbursementKeywords() {
+    }
+
+    /**
+     * loanTransactionTypeName이 대출금 지급 거래를 나타내는 키워드를 포함하는지 판정합니다.
+     * null/빈 문자열은 제외 사유가 없는 것으로 보고 false(정상 상환 후보)를 반환합니다.
+     */
+    public static boolean matches(String loanTransactionTypeName) {
+        String normalized = normalize(loanTransactionTypeName);
+        return KEYWORDS.stream().anyMatch(normalized::contains);
+    }
+
+    private static String normalize(String value) {
+        if (value == null) {
+            return "";
+        }
+
+        return value
+                .replaceAll("\\s+", "")
+                .toUpperCase(Locale.ROOT);
+    }
+}
diff --git a/common/src/test/java/com/ntropy/common/domain/LoanDisbursementKeywordsTest.java b/common/src/test/java/com/ntropy/common/domain/LoanDisbursementKeywordsTest.java
new file mode 100644
index 00000000..a6a7eb4e
--- /dev/null
+++ b/common/src/test/java/com/ntropy/common/domain/LoanDisbursementKeywordsTest.java
@@ -0,0 +1,79 @@
+package com.ntropy.common.domain;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class LoanDisbursementKeywordsTest {
+
+    @Test
+    void keywordListIsNeverEmpty() {
+        assertFalse(
+                LoanDisbursementKeywords.KEYWORDS.isEmpty(),
+                "MyBatis <foreach>가 빈 목록으로는 유효한 조건을 생성하지 못하므로 " +
+                        "목록이 비어 있으면 안 됩니다"
+        );
+    }
+
+    @Test
+    void nullIsNotDisbursement() {
+        assertFalse(LoanDisbursementKeywords.matches(null));
+    }
+
+    @Test
+    void blankIsNotDisbursement() {
+        assertFalse(LoanDisbursementKeywords.matches(""));
+        assertFalse(LoanDisbursementKeywords.matches("   "));
+    }
+
+    @Test
+    void normalRepaymentIsNotDisbursement() {
+        assertFalse(LoanDisbursementKeywords.matches("정상상환"));
+    }
+
+    @Test
+    void newLoanIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("신규"));
+    }
+
+    @Test
+    void executionIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("실행"));
+    }
+
+    @Test
+    void increaseIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("증액"));
+    }
+
+    @Test
+    void loanExecutionIsDisbursementBecauseItContainsExecution() {
+        assertTrue(LoanDisbursementKeywords.matches("대출실행"));
+    }
+
+    @Test
+    void loanExecutionWithInternalSpaceIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("대출 실행"));
+    }
+
+    @Test
+    void newLoanWithInternalSpaceIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("신 규"));
+    }
+
+    @Test
+    void executionWithInternalSpaceIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("실 행"));
+    }
+
+    @Test
+    void increaseWithInternalSpaceIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("증 액"));
+    }
+
+    @Test
+    void keywordInMiddleOfStringIsDisbursement() {
+        assertTrue(LoanDisbursementKeywords.matches("2026년 신규 대출 실행분"));
+    }
+}
diff --git a/services/account-service/src/main/java/com/ntropy/account/mapper/FinancialCommitmentMapper.java b/services/account-service/src/main/java/com/ntropy/account/mapper/FinancialCommitmentMapper.java
index 0ca2e810..2cdce597 100644
--- a/services/account-service/src/main/java/com/ntropy/account/mapper/FinancialCommitmentMapper.java
+++ b/services/account-service/src/main/java/com/ntropy/account/mapper/FinancialCommitmentMapper.java
@@ -16,7 +16,14 @@ public interface FinancialCommitmentMapper {
 
     List<SavingCommitmentCandidateRow> findSavingCommitmentCandidates(@Param("userId") Long userId);
 
-    List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(@Param("userId") Long userId);
+    /**
+     * loanDisbursementKeywords는 LOAN 신규·실행·증액(대출금 지급) 판정에 사용되며,
+     * 호출 측은 com.ntropy.common.domain.LoanDisbursementKeywords.KEYWORDS를 전달해야 합니다.
+     */
+    List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(
+            @Param("userId") Long userId,
+            @Param("loanDisbursementKeywords") List<String> loanDisbursementKeywords
+    );
 
     List<InsuranceOutflowRow> findInsuranceOutflowCandidates(
             @Param("userId") Long userId,
diff --git a/services/account-service/src/main/java/com/ntropy/account/mapper/MonthlyExpenseMapper.java b/services/account-service/src/main/java/com/ntropy/account/mapper/MonthlyExpenseMapper.java
index d3bf0eaa..51410ae1 100644
--- a/services/account-service/src/main/java/com/ntropy/account/mapper/MonthlyExpenseMapper.java
+++ b/services/account-service/src/main/java/com/ntropy/account/mapper/MonthlyExpenseMapper.java
@@ -16,11 +16,14 @@ public interface MonthlyExpenseMapper {
 
     /**
      * 특정 기간의 총소비 금액을 조회합니다.
+     * loanDisbursementKeywords는 LOAN 신규·실행·증액(대출금 지급) 판정에 사용되며,
+     * 호출 측은 com.ntropy.common.domain.LoanDisbursementKeywords.KEYWORDS를 전달해야 합니다.
      */
     Long findTotalExpense(
             @Param("userId") Long userId,
             @Param("startDate") LocalDate startDate,
-            @Param("endDate") LocalDate endDate
+            @Param("endDate") LocalDate endDate,
+            @Param("loanDisbursementKeywords") List<String> loanDisbursementKeywords
     );
 
     /**
@@ -29,7 +32,8 @@ Long findTotalExpense(
     List<CategoryExpenseAmount> findCategoryExpenses(
             @Param("userId") Long userId,
             @Param("startDate") LocalDate startDate,
-            @Param("endDate") LocalDate endDate
+            @Param("endDate") LocalDate endDate,
+            @Param("loanDisbursementKeywords") List<String> loanDisbursementKeywords
     );
 
     /**
@@ -38,6 +42,7 @@ List<CategoryExpenseAmount> findCategoryExpenses(
     Long findFixedExpense(
             @Param("userId") Long userId,
             @Param("startDate") LocalDate startDate,
-            @Param("endDate") LocalDate endDate
+            @Param("endDate") LocalDate endDate,
+            @Param("loanDisbursementKeywords") List<String> loanDisbursementKeywords
     );
 }
\ No newline at end of file
diff --git a/services/account-service/src/main/java/com/ntropy/account/service/FinancialCommitmentService.java b/services/account-service/src/main/java/com/ntropy/account/service/FinancialCommitmentService.java
index b460e519..31794291 100644
--- a/services/account-service/src/main/java/com/ntropy/account/service/FinancialCommitmentService.java
+++ b/services/account-service/src/main/java/com/ntropy/account/service/FinancialCommitmentService.java
@@ -20,6 +20,7 @@
 import com.ntropy.account.mapper.projection.InsuranceOutflowRow;
 import com.ntropy.account.mapper.projection.LoanCommitmentCandidateRow;
 import com.ntropy.account.mapper.projection.SavingCommitmentCandidateRow;
+import com.ntropy.common.domain.LoanDisbursementKeywords;
 import com.ntropy.common.dto.account.FinancialCommitmentSummary;
 import com.ntropy.common.exception.ServiceException;
 
@@ -87,7 +88,8 @@ private List<FinancialCommitmentSummary> buildSavingCommitments(Long userId, Loc
 
     private List<FinancialCommitmentSummary> buildLoanCommitments(Long userId, LocalDate fromDate, LocalDate toDate) {
         List<FinancialCommitmentSummary> result = new ArrayList<>();
-        for (LoanCommitmentCandidateRow row : financialCommitmentMapper.findLoanCommitmentCandidates(userId)) {
+        for (LoanCommitmentCandidateRow row : financialCommitmentMapper.findLoanCommitmentCandidates(
+                userId, LoanDisbursementKeywords.KEYWORDS)) {
             if (!withinRangeOrUnknown(row.getNextPaymentDate(), fromDate, toDate)) {
                 continue;
             }
diff --git a/services/account-service/src/main/java/com/ntropy/account/service/MonthlyExpenseService.java b/services/account-service/src/main/java/com/ntropy/account/service/MonthlyExpenseService.java
index d2f62746..6bfd3d5e 100644
--- a/services/account-service/src/main/java/com/ntropy/account/service/MonthlyExpenseService.java
+++ b/services/account-service/src/main/java/com/ntropy/account/service/MonthlyExpenseService.java
@@ -10,6 +10,7 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import com.ntropy.account.mapper.MonthlyExpenseMapper;
+import com.ntropy.common.domain.LoanDisbursementKeywords;
 import com.ntropy.common.dto.account.CategoryExpenseAmount;
 import com.ntropy.common.dto.account.MonthlyExpenseSummary;
 
@@ -58,21 +59,24 @@ public MonthlyExpenseSummary findMonthlyExpense(
                 monthlyExpenseMapper.findTotalExpense(
                         userId,
                         startDate,
-                        endDate
+                        endDate,
+                        LoanDisbursementKeywords.KEYWORDS
                 );
 
         Long fixedExpense =
                 monthlyExpenseMapper.findFixedExpense(
                         userId,
                         startDate,
-                        endDate
+                        endDate,
+                        LoanDisbursementKeywords.KEYWORDS
                 );
 
         List<CategoryExpenseAmount> rows =
                 monthlyExpenseMapper.findCategoryExpenses(
                         userId,
                         startDate,
-                        endDate
+                        endDate,
+                        LoanDisbursementKeywords.KEYWORDS
                 );
 
         Map<String, Long> categoryExpenses =
diff --git a/services/account-service/src/main/resources/mapper/account/FinancialCommitmentMapper.xml b/services/account-service/src/main/resources/mapper/account/FinancialCommitmentMapper.xml
index 04a8ae45..75a3b16b 100644
--- a/services/account-service/src/main/resources/mapper/account/FinancialCommitmentMapper.xml
+++ b/services/account-service/src/main/resources/mapper/account/FinancialCommitmentMapper.xml
@@ -30,10 +30,24 @@
           AND account_row.deposit_type_code = '12'
     </select>
 
+    <!--
+        LOAN 신규·실행·증액(대출금 지급) 거래를 제외한다. MonthlyExpenseMapper의
+        상환 후보 판정과 동일하게 common 모듈 LoanDisbursementKeywords와 키워드 목록을
+        공유하며, 판정 의미는 "공백 정규화 후 부분 문자열 포함"이다. 거래구분명이 NULL이면
+        COALESCE로 빈 문자열이 되어 어떤 키워드와도 매치되지 않으므로 후보로 인정된다.
+    -->
+    <sql id="loanDisbursementExclusion">
+        <foreach collection="loanDisbursementKeywords" item="keyword" separator=" AND ">
+            REGEXP_REPLACE(
+                COALESCE(loan_row.loan_transaction_type_name, ''),
+                '[[:space:]]+',
+                ''
+            ) NOT LIKE CONCAT('%', #{keyword}, '%')
+        </foreach>
+    </sql>
+
     <!--
         대출 계좌(deposit_type_code=40, account_group=LOAN)와, 있다면 가장 최근 "정상 상환" LOAN 거래 1건을 함께 반환한다.
-        신규·실행·대출실행·증액 거래는 정상 상환 후보에서 제외한다(부분 문자열 포함 기준).
-        거래구분명이 null/blank이면 제외 사유가 없는 것으로 보고 후보로 인정한다.
     -->
     <select id="findLoanCommitmentCandidates"
             resultType="com.ntropy.account.mapper.projection.LoanCommitmentCandidateRow">
@@ -52,15 +66,7 @@
                                WHERE loan_row.account_id = account_row.account_id
                                  AND loan_row.transaction_category = 'LOAN'
                                  AND loan_row.out_amount > 0
-                                 AND (
-                                       loan_row.loan_transaction_type_name IS NULL
-                                       OR (
-                                           loan_row.loan_transaction_type_name NOT LIKE '%신규%'
-                                           AND loan_row.loan_transaction_type_name NOT LIKE '%실행%'
-                                           AND loan_row.loan_transaction_type_name NOT LIKE '%대출실행%'
-                                           AND loan_row.loan_transaction_type_name NOT LIKE '%증액%'
-                                           )
-                                   )
+                                 AND (<include refid="loanDisbursementExclusion"/>)
                                ORDER BY loan_row.tran_date DESC,
                                         loan_row.tran_time DESC,
                                         loan_row.account_transaction_id DESC
diff --git a/services/account-service/src/main/resources/mapper/account/MonthlyExpenseMapper.xml b/services/account-service/src/main/resources/mapper/account/MonthlyExpenseMapper.xml
index cf12d7c2..92a6eb71 100644
--- a/services/account-service/src/main/resources/mapper/account/MonthlyExpenseMapper.xml
+++ b/services/account-service/src/main/resources/mapper/account/MonthlyExpenseMapper.xml
@@ -6,76 +6,109 @@
 <mapper namespace="com.ntropy.account.mapper.MonthlyExpenseMapper">
 
     <!--
-        이슈 #143: LOAN 거래는 원금을 소비에서 제외하고 이자만 반영한다.
-        LOAN은 FinancialDataQueryMapper.classificationTargetFilter에서 항상 AI 분류 대상 밖이라
-        TXN_ANALYSIS 행이 생기지 않는다 - 그래서 TXN_ANALYSIS를 거치지 않고 이 쿼리가
-        ACCOUNT_TRANSACTION.loan_interest_amount에서 직접, AI 분류 결과와 무관하게 결정적으로 계산한다.
-        out_amount·loan_principal_amount와의 합계가 실제로 일치하는지는 보지 않는다(원천 신뢰).
-        loan_interest_amount가 NULL이거나 음수이면 0으로 취급해 총상환액이 그대로 새어 들어가거나
-        음수가 총소비를 깎는 것을 막는다. 실제 포함 대상은 loanInterestConsumptionFilter에서
-        양수 이자가 있는 정상 상환 거래로 한 번 더 제한한다.
+        이슈 #143/#148/#169: 일간 분류 대상인 LOAN(out_amount > 0)·
+        INSTALLMENT(in_amount > 0)는 매일 02:00 배치(#148,
+        ai-service TransactionPreClassificationService)가 정상 처리하면 TXN_ANALYSIS 행이 생긴다
+        (LOAN 정상상환/INSTALLMENT는 TRUE/FINANCE/FIXED, LOAN 지급은 FALSE/NULL/NULL).
+        하지만 이 월간 집계 쿼리는 그 값을 참조하지 않고 ACCOUNT_TRANSACTION에서
+        직접 재계산한다. 이유는 "TXN_ANALYSIS 행이 없어서"가 아니라 다음 정책 때문이다.
+
+          1. 배치 실행 여부·성공 여부와 무관하게 진단 조회·확정에서도 즉시 결정적으로
+             계산할 수 있어야 한다(배치 전/실패 시에도 값이 새거나 누락되면 안 된다).
+          2. LOAN 원금은 소비에서 제외하고 loan_interest_amount만 반영해야 하는데,
+             이 원금/이자 분리는 TXN_ANALYSIS에 없는 정보라 어차피 원본 컬럼이 필요하다.
+          3. INSTALLMENT는 적립액이 in_amount에 들어오므로 일반 out_amount 합산 규칙을
+             그대로 쓰면 항상 0원으로 집계된다(#169에서 발견, INSTALLMENT 전용 분기 추가).
+
+        LOAN 신규·실행·증액(대출금 지급) 판정 키워드는 common 모듈의
+        LoanDisbursementKeywords와 단일 소스를 공유하며, 호출 측이
+        loanDisbursementKeywords 파라미터로 전달한다(FinancialCommitmentMapper의
+        상환 후보 판정과도 동일 목록을 쓴다).
+
+        loan_interest_amount가 NULL이거나 음수이면 0으로 취급해 총상환액이 그대로
+        새어 들어가거나 음수가 총소비를 깎는 것을 막는다. out_amount와
+        loan_principal_amount+loan_interest_amount 합이 실제로 일치하는지는 보지
+        않는다(원천 신뢰, 불일치는 이 쿼리의 관심사가 아니다).
     -->
     <sql id="loanAwareAmount">
         CASE
             WHEN transaction_row.transaction_category = 'LOAN'
                 THEN GREATEST(COALESCE(transaction_row.loan_interest_amount, 0), 0)
+            WHEN transaction_row.transaction_category = 'INSTALLMENT'
+                THEN GREATEST(COALESCE(transaction_row.in_amount, 0), 0)
             ELSE transaction_row.out_amount
         END
     </sql>
 
-    <!-- 카테고리별 집계 전용: LOAN 이자는 AI가 분류하지 않으므로 category를 'FINANCE'로 고정한다. -->
+    <!--
+        카테고리별 집계 전용: LOAN 이자·INSTALLMENT 적립액은 TXN_ANALYSIS.category와
+        무관하게 항상 'FINANCE'로 고정한다(#169 요약표 참고).
+    -->
     <sql id="loanAwareCategory">
         CASE
-            WHEN transaction_row.transaction_category = 'LOAN' THEN 'FINANCE'
+            WHEN transaction_row.transaction_category IN ('LOAN', 'INSTALLMENT') THEN 'FINANCE'
             ELSE analysis_row.category
         END
     </sql>
 
     <!--
-        LOAN 소비 집계 대상은 양수 이자가 있는 정상 상환 거래로 한정한다.
-        FinancialCommitmentMapper의 상환 후보 규칙과 동일하게 신규·실행·대출실행·증액 거래를 제외한다.
-        거래구분명이 NULL/빈 문자열이면 제외 사유가 없는 것으로 보고 상환 후보로 인정한다.
+        LOAN 신규·실행·증액(대출금 지급) 거래를 제외한다. 판정 의미는
+        "공백 정규화 후 부분 문자열 포함"이며, LoanDisbursementKeywords와 동일하다.
+        loan_transaction_type_name이 NULL이면 COALESCE로 빈 문자열이 되어 어떤
+        키워드와도 매치되지 않으므로 별도 NULL 분기 없이 상환 후보로 인정된다.
     -->
+    <sql id="loanDisbursementExclusion">
+        <foreach collection="loanDisbursementKeywords" item="keyword" separator=" AND ">
+            REGEXP_REPLACE(
+                COALESCE(transaction_row.loan_transaction_type_name, ''),
+                '[[:space:]]+',
+                ''
+            ) NOT LIKE CONCAT('%', #{keyword}, '%')
+        </foreach>
+    </sql>
+
+    <!-- LOAN 소비 집계 대상은 양수 이자가 있는 정상 상환(비지급) 거래로 한정한다. -->
     <sql id="loanInterestConsumptionFilter">
         transaction_row.transaction_category = 'LOAN'
         AND transaction_row.out_amount &gt; 0
         AND transaction_row.loan_interest_amount &gt; 0
-        AND (
-            transaction_row.loan_transaction_type_name IS NULL
-            OR (
-                transaction_row.loan_transaction_type_name NOT LIKE '%신규%'
-                AND transaction_row.loan_transaction_type_name NOT LIKE '%실행%'
-                AND transaction_row.loan_transaction_type_name NOT LIKE '%대출실행%'
-                AND transaction_row.loan_transaction_type_name NOT LIKE '%증액%'
-            )
-        )
+        AND (<include refid="loanDisbursementExclusion"/>)
+    </sql>
+
+    <!-- INSTALLMENT 소비 집계 대상은 양수 적립액이 들어온 거래로 한정한다. -->
+    <sql id="installmentConsumptionFilter">
+        transaction_row.transaction_category = 'INSTALLMENT'
+        AND transaction_row.in_amount &gt; 0
     </sql>
 
     <!--
-        총소비·카테고리별 소비 포함 대상: LOAN은 TXN_ANALYSIS 유무와 무관하게
-        loanInterestConsumptionFilter를 만족하는 상환 거래만 포함한다. 그 외 거래는 기존과 동일하게
-        is_consumption = TRUE인 것만 포함하되, LOAN이 분류 행을 통해 우회하지 못하게 거래 유형을 분리한다.
+        총소비·카테고리별 소비 포함 대상: LOAN·INSTALLMENT는 TXN_ANALYSIS 유무와 무관하게
+        각자의 결정적 필터를 만족하는 거래만 포함한다. 그 외 거래는 기존과 동일하게
+        is_consumption = TRUE인 것만 포함하되, LOAN·INSTALLMENT가 분류 행을 통해
+        중복·우회 집계되지 않도록 거래 유형을 명시적으로 분리한다.
     -->
     <sql id="consumptionFilter">
         (
             (<include refid="loanInterestConsumptionFilter"/>)
+            OR (<include refid="installmentConsumptionFilter"/>)
             OR (
-                transaction_row.transaction_category &lt;&gt; 'LOAN'
+                transaction_row.transaction_category NOT IN ('LOAN', 'INSTALLMENT')
                 AND analysis_row.is_consumption = TRUE
             )
         )
     </sql>
 
     <!--
-        고정지출 포함 대상: loanInterestConsumptionFilter를 만족하는 대출 원리금 상환은
-        예정된 반복 상환이므로 이자분을 고정지출로도 집계한다.
-        그 외 거래는 기존과 동일하게 is_consumption = TRUE AND expense_type = 'FIXED'만 포함한다.
+        고정지출 포함 대상: 정상 상환 LOAN 이자와 INSTALLMENT 적립액은 예정된 반복
+        지출이므로 고정지출로도 집계한다. 그 외 거래는 기존과 동일하게
+        is_consumption = TRUE AND expense_type = 'FIXED'만 포함한다.
     -->
     <sql id="fixedConsumptionFilter">
         (
             (<include refid="loanInterestConsumptionFilter"/>)
+            OR (<include refid="installmentConsumptionFilter"/>)
             OR (
-                transaction_row.transaction_category &lt;&gt; 'LOAN'
+                transaction_row.transaction_category NOT IN ('LOAN', 'INSTALLMENT')
                 AND analysis_row.is_consumption = TRUE
                 AND analysis_row.expense_type = 'FIXED'
             )
@@ -85,9 +118,9 @@
     <!--
         월별 총소비 금액을 조회합니다.
 
-        집계 대상은 (1) is_consumption = TRUE인 일반 거래의 out_amount 전액, (2) LOAN 거래의
-        loanAwareAmount(이자만, 원금 제외)입니다. INSTALLMENT, 내부이체 여부는 분류 결과에
-        반영된 값을 따릅니다. 거래는 발생 당시 기록을 기준으로 집계하며, 계좌가 이후 비활성화되더라도
+        집계 대상은 (1) is_consumption = TRUE인 일반 거래의 out_amount 전액, (2) LOAN
+        거래의 loanAwareAmount(이자만, 원금 제외), (3) INSTALLMENT 거래의 in_amount입니다.
+        거래는 발생 당시 기록을 기준으로 집계하며, 계좌가 이후 비활성화되더라도
         과거 거래는 계속 포함해야 하므로 account_row.status 필터는 쓰지 않는다.
     -->
     <select id="findTotalExpense"
@@ -108,8 +141,9 @@
     </select>
 
     <!--
-        월별 카테고리 소비 금액을 조회합니다. status 필터를 쓰지 않는 이유와 LOAN 처리 방식은
-        findTotalExpense와 동일합니다. LOAN 이자는 category = 'FINANCE'로 고정됩니다.
+        월별 카테고리 소비 금액을 조회합니다. status 필터를 쓰지 않는 이유와 LOAN·INSTALLMENT
+        처리 방식은 findTotalExpense와 동일합니다. LOAN 이자·INSTALLMENT 적립액은
+        category = 'FINANCE'로 고정됩니다.
     -->
     <select id="findCategoryExpenses"
             resultType="com.ntropy.common.dto.account.CategoryExpenseAmount">
@@ -134,8 +168,9 @@
     </select>
 
     <!--
-        월별 고정지출 합계를 조회합니다. status 필터를 쓰지 않는 이유는 findTotalExpense와 동일하고,
-        LOAN 이자를 고정지출에 포함하는 이유는 fixedConsumptionFilter를 참고한다.
+        월별 고정지출 합계를 조회합니다. status 필터를 쓰지 않는 이유는 findTotalExpense와
+        동일하고, LOAN 이자·INSTALLMENT 적립액을 고정지출에 포함하는 이유는
+        fixedConsumptionFilter를 참고한다.
     -->
     <select id="findFixedExpense"
             resultType="java.lang.Long">
diff --git a/services/account-service/src/test/java/com/ntropy/account/client/LocalFinancialCommitmentQueryClientWiringTest.java b/services/account-service/src/test/java/com/ntropy/account/client/LocalFinancialCommitmentQueryClientWiringTest.java
index c9f0486e..cb34de62 100644
--- a/services/account-service/src/test/java/com/ntropy/account/client/LocalFinancialCommitmentQueryClientWiringTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/client/LocalFinancialCommitmentQueryClientWiringTest.java
@@ -50,7 +50,8 @@ public List<SavingCommitmentCandidateRow> findSavingCommitmentCandidates(Long us
                 }
 
                 @Override
-                public List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(Long userId) {
+                public List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(
+                        Long userId, List<String> loanDisbursementKeywords) {
                     return List.of();
                 }
 
diff --git a/services/account-service/src/test/java/com/ntropy/account/integration/expense/MonthlyExpenseMapperLoanRuleManualVerificationTest.java b/services/account-service/src/test/java/com/ntropy/account/integration/expense/MonthlyExpenseMapperLoanRuleManualVerificationTest.java
index e3f51d0b..e4201874 100644
--- a/services/account-service/src/test/java/com/ntropy/account/integration/expense/MonthlyExpenseMapperLoanRuleManualVerificationTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/integration/expense/MonthlyExpenseMapperLoanRuleManualVerificationTest.java
@@ -23,15 +23,20 @@
 import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 
+import com.ntropy.account.mapper.FinancialCommitmentMapper;
 import com.ntropy.account.mapper.MonthlyExpenseMapper;
+import com.ntropy.account.mapper.projection.LoanCommitmentCandidateRow;
+import com.ntropy.common.domain.LoanDisbursementKeywords;
 import com.ntropy.common.dto.account.CategoryExpenseAmount;
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
 
 /**
- * 이슈 #143: LOAN 거래 원금 제외·이자 포함 규칙이 실제 MySQL에서 의도한 대로 동작하는지 검증하는
- * 수동 테스트입니다. {@code MonthlyExpenseMapperContractTest}는 XML 텍스트만 확인하므로
- * GREATEST/CASE/LEFT JOIN 같은 실제 SQL 문법 오류나 계산값 자체는 여기서만 잡을 수 있습니다.
+ * 이슈 #143/#169: LOAN 거래 원금 제외·이자 포함 규칙, INSTALLMENT 적립액(in_amount) 집계 규칙,
+ * FinancialCommitmentMapper의 최근 정상 상환 선택 규칙이 실제 MySQL에서 의도한 대로
+ * 동작하는지 검증하는 수동 테스트입니다.
+ * {@code MonthlyExpenseMapperContractTest}는 XML 텍스트만 확인하므로 GREATEST/CASE/LEFT JOIN/
+ * REGEXP_REPLACE 같은 실제 SQL 문법 오류나 계산값 자체는 여기서만 잡을 수 있습니다.
  * RUN_MONTHLY_EXPENSE_LOAN_RULE_TEST=true일 때만 실행합니다.
  */
 class MonthlyExpenseMapperLoanRuleManualVerificationTest {
@@ -52,27 +57,46 @@ void loanInterestOnlyRuleAppliesConsistentlyAcrossTotalCategoryAndFixedExpense()
             seedFixtures(dataSource);
 
             MonthlyExpenseMapper mapper = context.getBean(MonthlyExpenseMapper.class);
+            FinancialCommitmentMapper financialCommitmentMapper =
+                    context.getBean(FinancialCommitmentMapper.class);
             LocalDate startDate = TARGET_MONTH.atDay(1);
             LocalDate endDate = TARGET_MONTH.plusMonths(1).atDay(1);
+            List<String> loanDisbursementKeywords = LoanDisbursementKeywords.KEYWORDS;
 
-            Long totalExpense = mapper.findTotalExpense(USER_ID, startDate, endDate);
-            Long fixedExpense = mapper.findFixedExpense(USER_ID, startDate, endDate);
-            List<CategoryExpenseAmount> categoryRows = mapper.findCategoryExpenses(USER_ID, startDate, endDate);
+            Long totalExpense = mapper.findTotalExpense(USER_ID, startDate, endDate, loanDisbursementKeywords);
+            Long fixedExpense = mapper.findFixedExpense(USER_ID, startDate, endDate, loanDisbursementKeywords);
+            List<CategoryExpenseAmount> categoryRows =
+                    mapper.findCategoryExpenses(USER_ID, startDate, endDate, loanDisbursementKeywords);
             Map<String, Long> categories = categoryRows.stream()
                     .collect(Collectors.toMap(CategoryExpenseAmount::getCategory, CategoryExpenseAmount::getExpenseAmount));
 
             // T1(FOOD/VARIABLE 50,000) + T2(HOUSING/FIXED 200,000) + T3(비소비, 제외)
             // + T4(LOAN 원금+이자 중 이자 50,000) + T5(LOAN 원금만, 이자 null → 0)
             // + T6(LOAN 이자만 30,000) + T7(LOAN out_amount 불일치, 이자 20,000만 반영)
-            // + T8(LOAN 이자 음수 → 제외) + T10(INSTALLMENT, 제외)
+            // + T8(LOAN 이자 음수 → 제외) + T9(대상월 밖 LOAN, 제외)
+            // + T10(INSTALLMENT, TXN_ANALYSIS 없음, in_amount 150,000 반영)
             // + T11(대출실행, 양수 이자가 있어도 제외)
-            assertEquals(350_000L, totalExpense, "총소비: LOAN 원금은 제외하고 이자만 반영해야 합니다");
-            assertEquals(300_000L, fixedExpense,
-                    "고정지출: HOUSING(FIXED)과 LOAN 이자(FINANCE)는 포함, FOOD(VARIABLE)는 제외해야 합니다");
-            assertEquals(Map.of("FOOD", 50_000L, "HOUSING", 200_000L, "FINANCE", 100_000L), categories,
-                    "카테고리별 소비: LOAN 이자는 모두 FINANCE로 합산되어야 합니다");
+            // + T12(INSTALLMENT, TXN_ANALYSIS 있음, in_amount 80,000 반영, 중복 합산 없음)
+            // + T13(INSTALLMENT, in_amount=0 → 제외) + T14(대상월 밖 INSTALLMENT, 제외)
+            assertEquals(580_000L, totalExpense,
+                    "총소비: LOAN 원금은 제외하고 이자만, INSTALLMENT는 out_amount가 아닌 in_amount만 반영해야 합니다");
+            assertEquals(530_000L, fixedExpense,
+                    "고정지출: HOUSING(FIXED)·LOAN 이자(FINANCE)·INSTALLMENT(FINANCE)는 포함, "
+                            + "FOOD(VARIABLE)는 제외해야 합니다");
+            assertEquals(Map.of("FOOD", 50_000L, "HOUSING", 200_000L, "FINANCE", 330_000L), categories,
+                    "카테고리별 소비: LOAN 이자·INSTALLMENT는 모두 FINANCE로 합산되어야 합니다");
             assertEquals(totalExpense, categories.values().stream().mapToLong(Long::longValue).sum(),
                     "카테고리별 합계는 총소비와 일치해야 합니다");
+
+            List<LoanCommitmentCandidateRow> loanCommitments =
+                    financialCommitmentMapper.findLoanCommitmentCandidates(
+                            USER_ID,
+                            loanDisbursementKeywords
+                    );
+            assertEquals(1, loanCommitments.size(), "LOAN 계좌별 후보는 한 건이어야 합니다");
+            LoanCommitmentCandidateRow latestRepayment = loanCommitments.get(0);
+            assertEquals(123_000L, latestRepayment.getExpectedAmount().longValueExact(),
+                    "공백 포함 지급 거래들을 건너뛰고 직전 정상 상환을 선택해야 합니다");
         }
     }
 
@@ -135,22 +159,62 @@ private void seedFixtures(DataSource dataSource) throws Exception {
             // T9: 대상월 밖 LOAN 거래 - 날짜 필터로 제외되어야 한다.
             insertLoanTransaction(statement, loanAccount, previousMonthDay5, 999_999, null, 999_999, "e2e-143-t9");
 
-            // T10: INSTALLMENT 거래, TXN_ANALYSIS 없음 - LEFT JOIN으로 바뀌어도 여전히 제외되어야 한다.
-            statement.execute(
-                    "INSERT INTO ACCOUNT_TRANSACTION (account_id, fingerprint, transaction_category, tran_date, "
-                            + "out_amount, in_amount, after_balance) VALUES ("
-                            + installmentAccount + ", SHA2('e2e-143-t10', 256), 'INSTALLMENT', '" + day5 + "', "
-                        + "150000, 0, 150000)"
-            );
+            // T10: INSTALLMENT 거래, TXN_ANALYSIS 없음 - out_amount가 아닌 in_amount(150,000)가
+            // TXN_ANALYSIS 유무와 무관하게 반영되어야 한다(이슈 #169, 기존에는 0원으로 집계되던 버그).
+            insertInstallmentTransaction(statement, installmentAccount, day5, 150_000, "e2e-169-t10");
 
             // T11: 대출실행 거래 - 양수 이자가 있어도 상환 거래가 아니므로 제외돼야 한다.
             insertLoanTransaction(
                     statement, loanAccount, day5, 1_040_000, 1_000_000, 40_000,
                     "대출실행", "e2e-143-t11"
             );
+
+            // T12: INSTALLMENT 거래, TXN_ANALYSIS 있음(TRUE/FINANCE/FIXED) - 분석 행이 있어도
+            // in_amount(80,000)가 정확히 한 번만 합산되어야 한다(중복 집계 없음).
+            insertInstallmentTransaction(statement, installmentAccount, day5, 80_000, "e2e-169-t12");
+            insertClassification(statement, true, "FINANCE", "FIXED");
+
+            // T13: INSTALLMENT 거래, in_amount=0 - 집계에 기여하지 않아야 한다.
+            insertInstallmentTransaction(statement, installmentAccount, day5, 0, "e2e-169-t13");
+
+            // T14: 대상월 밖 INSTALLMENT 거래 - 날짜 필터로 제외되어야 한다.
+            insertInstallmentTransaction(statement, installmentAccount, previousMonthDay5, 999_999, "e2e-169-t14");
+
+            // T15: FinancialCommitmentMapper가 선택해야 할 최근 정상 상환. 이자가 NULL이어서
+            // 월간 소비에는 기여하지 않지만 대출 납입 예정 후보에는 포함된다.
+            insertLoanTransaction(
+                    statement, loanAccount, day5, 123_000, 123_000, null,
+                    "정상상환", "e2e-169-t15"
+            );
+
+            // T16~T18: T15보다 나중에 저장된 공백 포함 지급 거래. 월간 소비에서 제외되어야 하고,
+            // FinancialCommitmentMapper도 이 거래들을 건너뛰어 T15를 최근 정상 상환으로 선택해야 한다.
+            insertLoanTransaction(
+                    statement, loanAccount, day5, 2_100_000, 2_000_000, 100_000,
+                    "신 규", "e2e-169-t16"
+            );
+            insertLoanTransaction(
+                    statement, loanAccount, day5, 2_100_000, 2_000_000, 100_000,
+                    "실 행", "e2e-169-t17"
+            );
+            insertLoanTransaction(
+                    statement, loanAccount, day5, 2_100_000, 2_000_000, 100_000,
+                    "증 액", "e2e-169-t18"
+            );
         }
     }
 
+    private void insertInstallmentTransaction(
+            Statement statement, long accountId, String date, int inAmount, String fingerprintSeed
+    ) throws Exception {
+        statement.execute(
+                "INSERT INTO ACCOUNT_TRANSACTION (account_id, fingerprint, transaction_category, tran_date, "
+                        + "out_amount, in_amount, after_balance) VALUES ("
+                        + accountId + ", SHA2('" + fingerprintSeed + "', 256), 'INSTALLMENT', '" + date + "', "
+                        + "0, " + inAmount + ", 1000000)"
+        );
+    }
+
     private long insertAccount(
             Statement statement, long connectionId, String accountGroup, String depositTypeCode, String accountNoSeed
     ) throws Exception {
diff --git a/services/account-service/src/test/java/com/ntropy/account/mapper/FinancialCommitmentMapperContractTest.java b/services/account-service/src/test/java/com/ntropy/account/mapper/FinancialCommitmentMapperContractTest.java
index f1b5a216..56a00e92 100644
--- a/services/account-service/src/test/java/com/ntropy/account/mapper/FinancialCommitmentMapperContractTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/mapper/FinancialCommitmentMapperContractTest.java
@@ -39,17 +39,35 @@ void loanQueryScopesByGroupAndExcludesNonRepaymentKeywords() throws IOException
         assertTrue(query.contains("latest_tx.loan_interest_amount AS expectedInterestAmount"));
         assertTrue(query.contains("transaction_category = 'LOAN'"));
         assertTrue(query.contains("loan_row.out_amount > 0"));
-        assertTrue(query.contains("loan_transaction_type_name IS NULL"));
-        assertTrue(query.contains("NOT LIKE '%신규%'"));
-        assertTrue(query.contains("NOT LIKE '%실행%'"));
-        assertTrue(query.contains("NOT LIKE '%대출실행%'"));
-        assertTrue(query.contains("NOT LIKE '%증액%'"));
+        assertTrue(query.contains("<include refid=\"loanDisbursementExclusion\"/>"));
         assertTrue(query.contains("loan_row.account_id = account_row.account_id"));
         assertTrue(query.contains("ORDER BY loan_row.tran_date DESC"));
         assertTrue(query.contains("LIMIT 1"));
         assertFalse(query.contains("ROW_NUMBER()"));
     }
 
+    /**
+     * 이슈 #169: LOAN 지급 판정 키워드는 MonthlyExpenseMapper와 동일한 common
+     * LoanDisbursementKeywords를 파라미터로 전달받아야 하며, SQL에 리터럴로 남아있지 않아야 한다.
+     */
+    @Test
+    void loanDisbursementExclusionUsesSharedKeywordParameterNotLiterals() throws IOException {
+        String fragment = sqlFragmentBody(readMapper(), "loanDisbursementExclusion");
+
+        assertTrue(fragment.contains("<foreach"));
+        assertTrue(fragment.contains("collection=\"loanDisbursementKeywords\""));
+        assertTrue(fragment.contains("separator=\" AND \""));
+        assertTrue(fragment.contains("NOT LIKE CONCAT('%', #{keyword}, '%')"));
+        assertFalse(fragment.contains("${keyword}"),
+                "키워드 바인딩은 문자열 치환(${keyword})이 아니라 #{keyword}를 써야 합니다");
+        assertTrue(fragment.contains("REGEXP_REPLACE"),
+                "loan_transaction_type_name의 공백을 정규화한 뒤 비교해야 합니다");
+        assertFalse(fragment.contains("신규"),
+                "키워드 리터럴은 SQL에 직접 남아있지 않아야 합니다(common LoanDisbursementKeywords 사용)");
+        assertFalse(fragment.contains("대출실행"),
+                "키워드 리터럴은 SQL에 직접 남아있지 않아야 합니다(common LoanDisbursementKeywords 사용)");
+    }
+
     @Test
     void insuranceQueryScopesByOwnerAndObservationWindowOnOrdinaryOutflows() throws IOException {
         String query = selectBody(readMapper(), "findInsuranceOutflowCandidates");
@@ -71,6 +89,12 @@ private static String selectBody(String mapper, String selectId) {
         return mapper.substring(start, end);
     }
 
+    private static String sqlFragmentBody(String mapper, String sqlId) {
+        int start = mapper.indexOf("<sql id=\"" + sqlId + "\"");
+        int end = mapper.indexOf("</sql>", start);
+        return mapper.substring(start, end);
+    }
+
     private static String readMapper() throws IOException {
         String path = "mapper/account/FinancialCommitmentMapper.xml";
         try (InputStream input = FinancialCommitmentMapperContractTest.class
diff --git a/services/account-service/src/test/java/com/ntropy/account/mapper/MonthlyExpenseMapperContractTest.java b/services/account-service/src/test/java/com/ntropy/account/mapper/MonthlyExpenseMapperContractTest.java
index c953cfc1..5de1da22 100644
--- a/services/account-service/src/test/java/com/ntropy/account/mapper/MonthlyExpenseMapperContractTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/mapper/MonthlyExpenseMapperContractTest.java
@@ -40,8 +40,8 @@ void fixedExpenseQueryDoesNotFilterByCurrentAccountStatusAndScopesToFixedType()
     }
 
     /**
-     * 이슈 #143: 세 쿼리 모두 같은 loanAwareAmount fragment로 금액을 계산해야 계산식이 갈라지지 않는다.
-     * TXN_ANALYSIS 행이 없는 LOAN 거래도 걸려야 하므로 INNER JOIN이 아닌 LEFT JOIN을 써야 한다.
+     * 이슈 #143/#169: 세 쿼리 모두 같은 loanAwareAmount fragment로 금액을 계산해야 계산식이 갈라지지 않는다.
+     * TXN_ANALYSIS 행이 없는 LOAN·INSTALLMENT 거래도 걸려야 하므로 INNER JOIN이 아닌 LEFT JOIN을 써야 한다.
      */
     @Test
     void allThreeQueriesShareTheSameLoanAmountAndUseLeftJoinForOptionalAnalysis() throws IOException {
@@ -51,7 +51,7 @@ void allThreeQueriesShareTheSameLoanAmountAndUseLeftJoinForOptionalAnalysis() th
             assertTrue(query.contains("<include refid=\"loanAwareAmount\"/>"),
                     selectId + "는 공통 loanAwareAmount fragment를 재사용해야 합니다");
             assertTrue(query.contains("LEFT JOIN TXN_ANALYSIS analysis_row"),
-                    selectId + "는 TXN_ANALYSIS가 없는 LOAN 거래도 포함하도록 LEFT JOIN을 써야 합니다");
+                    selectId + "는 TXN_ANALYSIS가 없는 LOAN·INSTALLMENT 거래도 포함하도록 LEFT JOIN을 써야 합니다");
         }
     }
 
@@ -68,14 +68,42 @@ void loanAwareAmountExcludesPrincipalAndClampsInterestAtZero() throws IOExceptio
     }
 
     @Test
-    void loanAwareCategoryFixesLoanInterestToFinance() throws IOException {
+    void loanAwareAmountUsesInAmountForInstallment() throws IOException {
+        String fragment = sqlFragmentBody(readMapper(), "loanAwareAmount");
+
+        assertTrue(fragment.contains("transaction_category = 'INSTALLMENT'"));
+        assertTrue(fragment.contains("in_amount"),
+                "INSTALLMENT 적립액은 out_amount가 아닌 in_amount에서 가져와야 합니다");
+    }
+
+    @Test
+    void loanAwareCategoryFixesLoanAndInstallmentToFinance() throws IOException {
         String fragment = sqlFragmentBody(readMapper(), "loanAwareCategory");
 
-        assertTrue(fragment.contains("transaction_category = 'LOAN'"));
+        assertTrue(fragment.contains("'LOAN'"));
+        assertTrue(fragment.contains("'INSTALLMENT'"));
         assertTrue(fragment.contains("'FINANCE'"));
         assertTrue(fragment.contains("analysis_row.category"));
     }
 
+    @Test
+    void loanDisbursementExclusionUsesSharedKeywordParameterNotLiterals() throws IOException {
+        String fragment = sqlFragmentBody(readMapper(), "loanDisbursementExclusion");
+
+        assertTrue(fragment.contains("<foreach"));
+        assertTrue(fragment.contains("collection=\"loanDisbursementKeywords\""));
+        assertTrue(fragment.contains("separator=\" AND \""));
+        assertTrue(fragment.contains("NOT LIKE CONCAT('%', #{keyword}, '%')"));
+        assertFalse(fragment.contains("${keyword}"),
+                "키워드 바인딩은 문자열 치환(${keyword})이 아니라 #{keyword}를 써야 합니다");
+        assertTrue(fragment.contains("REGEXP_REPLACE"),
+                "loan_transaction_type_name의 공백을 정규화한 뒤 비교해야 합니다");
+        assertFalse(fragment.contains("신규"),
+                "키워드 리터럴은 SQL에 직접 남아있지 않아야 합니다(common LoanDisbursementKeywords 사용)");
+        assertFalse(fragment.contains("대출실행"),
+                "키워드 리터럴은 SQL에 직접 남아있지 않아야 합니다(common LoanDisbursementKeywords 사용)");
+    }
+
     @Test
     void loanInterestConsumptionFilterOnlyIncludesPositiveInterestRepayments() throws IOException {
         String fragment = sqlFragmentBody(readMapper(), "loanInterestConsumptionFilter");
@@ -83,28 +111,34 @@ void loanInterestConsumptionFilterOnlyIncludesPositiveInterestRepayments() throw
         assertTrue(fragment.contains("transaction_row.transaction_category = 'LOAN'"));
         assertTrue(fragment.contains("transaction_row.out_amount &gt; 0"));
         assertTrue(fragment.contains("transaction_row.loan_interest_amount &gt; 0"));
-        assertTrue(fragment.contains("loan_transaction_type_name IS NULL"));
-        assertTrue(fragment.contains("NOT LIKE '%신규%'"));
-        assertTrue(fragment.contains("NOT LIKE '%실행%'"));
-        assertTrue(fragment.contains("NOT LIKE '%대출실행%'"));
-        assertTrue(fragment.contains("NOT LIKE '%증액%'"));
+        assertTrue(fragment.contains("<include refid=\"loanDisbursementExclusion\"/>"));
+    }
+
+    @Test
+    void installmentConsumptionFilterRequiresPositiveInAmount() throws IOException {
+        String fragment = sqlFragmentBody(readMapper(), "installmentConsumptionFilter");
+
+        assertTrue(fragment.contains("transaction_row.transaction_category = 'INSTALLMENT'"));
+        assertTrue(fragment.contains("transaction_row.in_amount &gt; 0"));
     }
 
     @Test
-    void consumptionFilterIncludesOnlyEligibleLoanOrClassifiedNonLoan() throws IOException {
+    void consumptionFilterIncludesEligibleLoanOrInstallmentOrClassifiedOther() throws IOException {
         String fragment = sqlFragmentBody(readMapper(), "consumptionFilter");
 
         assertTrue(fragment.contains("<include refid=\"loanInterestConsumptionFilter\"/>"));
-        assertTrue(fragment.contains("transaction_row.transaction_category &lt;&gt; 'LOAN'"));
+        assertTrue(fragment.contains("<include refid=\"installmentConsumptionFilter\"/>"));
+        assertTrue(fragment.contains("transaction_row.transaction_category NOT IN ('LOAN', 'INSTALLMENT')"));
         assertTrue(fragment.contains("analysis_row.is_consumption = TRUE"));
     }
 
     @Test
-    void fixedConsumptionFilterIncludesOnlyEligibleLoanAndKeepsFixedTypeForNonLoan() throws IOException {
+    void fixedConsumptionFilterIncludesEligibleLoanOrInstallmentAndKeepsFixedTypeForOther() throws IOException {
         String fragment = sqlFragmentBody(readMapper(), "fixedConsumptionFilter");
 
         assertTrue(fragment.contains("<include refid=\"loanInterestConsumptionFilter\"/>"));
-        assertTrue(fragment.contains("transaction_row.transaction_category &lt;&gt; 'LOAN'"));
+        assertTrue(fragment.contains("<include refid=\"installmentConsumptionFilter\"/>"));
+        assertTrue(fragment.contains("transaction_row.transaction_category NOT IN ('LOAN', 'INSTALLMENT')"));
         assertTrue(fragment.contains("analysis_row.is_consumption = TRUE"));
         assertTrue(fragment.contains("analysis_row.expense_type = 'FIXED'"));
     }
diff --git a/services/account-service/src/test/java/com/ntropy/account/service/FinancialCommitmentServiceTest.java b/services/account-service/src/test/java/com/ntropy/account/service/FinancialCommitmentServiceTest.java
index 36a251e1..d38c8d7d 100644
--- a/services/account-service/src/test/java/com/ntropy/account/service/FinancialCommitmentServiceTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/service/FinancialCommitmentServiceTest.java
@@ -517,7 +517,8 @@ public List<SavingCommitmentCandidateRow> findSavingCommitmentCandidates(Long us
         }
 
         @Override
-        public List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(Long userId) {
+        public List<LoanCommitmentCandidateRow> findLoanCommitmentCandidates(
+                Long userId, List<String> loanDisbursementKeywords) {
             return loans;
         }
 
diff --git a/services/account-service/src/test/java/com/ntropy/account/service/MonthlyExpenseServiceTest.java b/services/account-service/src/test/java/com/ntropy/account/service/MonthlyExpenseServiceTest.java
index 11517dd8..21de0d26 100644
--- a/services/account-service/src/test/java/com/ntropy/account/service/MonthlyExpenseServiceTest.java
+++ b/services/account-service/src/test/java/com/ntropy/account/service/MonthlyExpenseServiceTest.java
@@ -100,17 +100,20 @@ private static class InMemoryMonthlyExpenseMapper implements MonthlyExpenseMappe
         private List<CategoryExpenseAmount> categoryExpenses = List.of();
 
         @Override
-        public Long findTotalExpense(Long userId, LocalDate startDate, LocalDate endDate) {
+        public Long findTotalExpense(
+                Long userId, LocalDate startDate, LocalDate endDate, List<String> loanDisbursementKeywords) {
             return totalExpense;
         }
 
         @Override
-        public List<CategoryExpenseAmount> findCategoryExpenses(Long userId, LocalDate startDate, LocalDate endDate) {
+        public List<CategoryExpenseAmount> findCategoryExpenses(
+                Long userId, LocalDate startDate, LocalDate endDate, List<String> loanDisbursementKeywords) {
             return categoryExpenses;
         }
 
         @Override
-        public Long findFixedExpense(Long userId, LocalDate startDate, LocalDate endDate) {
+        public Long findFixedExpense(
+                Long userId, LocalDate startDate, LocalDate endDate, List<String> loanDisbursementKeywords) {
             return fixedExpense;
         }
     }
diff --git a/services/ai-service/src/main/java/com/ntropy/ai/service/TransactionPreClassificationService.java b/services/ai-service/src/main/java/com/ntropy/ai/service/TransactionPreClassificationService.java
index 9a30b288..166e0ad6 100644
--- a/services/ai-service/src/main/java/com/ntropy/ai/service/TransactionPreClassificationService.java
+++ b/services/ai-service/src/main/java/com/ntropy/ai/service/TransactionPreClassificationService.java
@@ -6,6 +6,7 @@
 
 import org.springframework.stereotype.Service;
 
+import com.ntropy.common.domain.LoanDisbursementKeywords;
 import com.ntropy.common.dto.account.DailyClassificationTargetTransaction;
 import com.ntropy.common.dto.account.TransactionAnalysisSaveItem;
 
@@ -16,14 +17,6 @@
 @Service
 public class TransactionPreClassificationService {
 
-    private static final List<String> LOAN_DISBURSEMENT_KEYWORDS =
-            List.of(
-                    "신규",
-                    "실행",
-                    "대출실행",
-                    "증액"
-            );
-
     private static final List<String> FINANCIAL_TRANSFER_KEYWORDS =
             List.of(
                     "정기예금",
@@ -87,14 +80,17 @@ public Optional<TransactionAnalysisSaveItem> classify(
 
         /*
          * LOAN 신규·실행·증액은 대출금 지급 거래이므로 비소비입니다.
+         * 판정 키워드는 LoanDisbursementKeywords(common)를 MonthlyExpenseMapper·
+         * FinancialCommitmentMapper의 SQL 판정과 공유합니다.
          *
-         * 그 외 LOAN 거래는 정상 상환으로 보고 총상환액 전체를
-         * FINANCE / FIXED 소비로 처리합니다.
+         * 그 외 LOAN 거래는 정상 상환으로 보고 FINANCE / FIXED 소비로 분류합니다.
+         * 여기서는 분류 정보(is_consumption/category/expense_type)만 저장하며 금액은
+         * 저장하지 않습니다. 월간 집계 금액(원금 제외, 이자만 소비)은 MonthlyExpenseMapper가
+         * ACCOUNT_TRANSACTION에서 별도로 결정적으로 계산합니다.
          */
         if ("LOAN".equals(transactionCategory)) {
-            if (containsAny(
-                    transaction.getLoanTransactionTypeName(),
-                    LOAN_DISBURSEMENT_KEYWORDS
+            if (LoanDisbursementKeywords.matches(
+                    transaction.getLoanTransactionTypeName()
             )) {
                 return Optional.of(
                         nonConsumption(transaction.getTransactionId())