@sayren/store-sdk 0.52.0 → 0.54.0

package/src/schemas/coupon-rules.ts

@@ -1,6 +1,5 @@
 import * as z from "zod";
 import {
-  anyConditionHolds,
   type BirthdateFact,
   birthdateFactOf,
   type ConditionCatalog,
@@ -19,6 +18,7 @@ import {
   conditionIssues,
   conditionRuleSchema,
   evaluateCondition,
+  evaluateConditionNode,
   isConditionGroup,
 } from "./condition-tree";
 
@@ -27,7 +27,8 @@ import {
  *
  * 쿠폰은 세 트리를 갖는다.
  * - `eligibility`(사용 조건): 구매자·주문서·시각. 그룹 중첩 3단까지
- * - `targetRules`(할인 대상): 줄 단위. `{ include, exclude }` 고정 형태 — 포함은 하나라도 맞으면 대상(비면 전 상품), 제외는 하나라도 맞으면 빠지고 포함보다 우선
+ * - `targetTree`(할인 대상, 이슈 #263): 줄 단위. `{ include, exclude }` 각각 조건 그룹(3단) — 포함이 참이면 대상(비면 전 상품), 제외가 참이면 빠지고 포함보다 우선(비면 제외 없음).
+ *   옛 칸 `targetRules`(평평한 「하나라도」 목록)는 `couponTargetTreeFromRules`로 같은 트리가 되고, 응답의 `targetRules`는 트리에서 만든 가장 가까운 값이다
  * - `audience`(발급 대상): 누가 받을 수 있는가. 구매자 사실 값만
  *
  * 기간·한도·혜택·`memberOnly`·중복 정책은 트리 밖 칸이다. 옛 칸(`conditions`·`target`)은 프리셋 변환(`couponRulesFromLegacy`)으로 같은 트리가 된다 —
@@ -424,6 +425,20 @@ export type CouponTargetRules = z.infer<typeof couponTargetRulesSchema>;
 
 export const COUPON_TARGET_RULES_ALL: CouponTargetRules = { include: [], exclude: [] };
 
+/** 할인 대상 트리(이슈 #263) — 포함·제외 각각 조건 그룹(3단, 규칙 50개). 다른 자리와 같은 그룹 형식이다 */
+export const couponTargetTreeSchema = z.strictObject({
+  include: (conditionGroupSchema as z.ZodType<ConditionGroup>).describe(
+    "포함 그룹 — 참인 줄이 대상. 비면 전 상품",
+  ),
+  exclude: (conditionGroupSchema as z.ZodType<ConditionGroup>).describe(
+    "제외 그룹 — 참인 줄은 대상에서 빠진다. 포함보다 우선한다. 비면 제외 없음",
+  ),
+});
+export interface CouponTargetTree {
+  include: ConditionGroup;
+  exclude: ConditionGroup;
+}
+
 export const EMPTY_CONDITION_GROUP: ConditionGroup = { combinator: "and", rules: [] };
 
 /** 사용 조건·발급 대상 트리 */
@@ -464,6 +479,60 @@ export function canonicalizeCouponTargetRules(rules: CouponTargetRules): CouponT
   };
 }
 
+/**
+ * 규칙 1개 이하 그룹은 결합어와 무관하다 — `or`로 고정해 옛 쿠폰의 `{or,[r]}`와 화면이 보낸 `{and,[r]}`를 같은 값으로 본다.
+ * 규칙 없는 하위 그룹은 뺀다 — 빈 그룹은 참으로 평가되므로 남기면 포함 「하나 이상」은 전 상품, 제외는 모든 상품을 뺀다(화면 `treeOf`와 같은 뜻)
+ */
+function canonicalTargetGroup(group: ConditionGroup): ConditionGroup {
+  const rules = group.rules.flatMap((node): ConditionNode[] => {
+    if (!isConditionGroup(node)) return [canonicalizeConditionRule(node)];
+    const child = canonicalTargetGroup(node);
+    return child.rules.length > 0 ? [child] : [];
+  });
+  return { combinator: rules.length <= 1 ? "or" : group.combinator, rules };
+}
+
+/** 할인 대상 트리의 정규형 — 저장·잠금 비교·승인 비교·스냅샷이 같은 함수다 */
+export function canonicalizeCouponTargetTree(tree: CouponTargetTree): CouponTargetTree {
+  return {
+    include: canonicalTargetGroup(tree.include),
+    exclude: canonicalTargetGroup(tree.exclude),
+  };
+}
+
+/** 옛 평평한 목록 → 트리. 「하나라도」가 그대로 `or` 그룹이다(같은 줄 판정) */
+export function couponTargetTreeFromRules(rules: CouponTargetRules): CouponTargetTree {
+  return {
+    include: { combinator: "or", rules: rules.include },
+    exclude: { combinator: "or", rules: rules.exclude },
+  };
+}
+
+/** 그룹이 평평한 「하나라도」 목록으로 같은 뜻인가 — 하위 그룹이 없고 `or`이거나 규칙이 1개 이하 */
+function flatRulesOf(group: ConditionGroup): ConditionRule[] | null {
+  if (group.rules.some(isConditionGroup)) return null;
+  if (group.combinator === "and" && group.rules.length > 1) return null;
+  return group.rules as ConditionRule[];
+}
+
+/**
+ * 트리 → 옛 평평한 목록. 같은 뜻으로 옮길 수 없으면(`모두`에 규칙 2개 이상, 하위 그룹) `rulesOnly: true`이고 목록은
+ * 그룹 최상위 규칙을 평평하게 모은 가장 가까운 값이다
+ */
+export function couponTargetRulesFromTree(tree: CouponTargetTree): {
+  targetRules: CouponTargetRules;
+  rulesOnly: boolean;
+} {
+  const include = flatRulesOf(tree.include);
+  const exclude = flatRulesOf(tree.exclude);
+  const top = (group: ConditionGroup) =>
+    group.rules.filter((node): node is ConditionRule => !isConditionGroup(node));
+  return {
+    targetRules: { include: include ?? top(tree.include), exclude: exclude ?? top(tree.exclude) },
+    rulesOnly: include === null || exclude === null,
+  };
+}
+
 export function canonicalizeCouponStacking(stacking: CouponStacking): CouponStacking {
   return {
     combinesWith: {
@@ -495,7 +564,15 @@ export interface LegacyCouponTarget {
 
 export interface CouponRuleTrees {
   eligibility: ConditionGroup;
+  /** 할인 대상의 옛 평평한 목록 — `targetTree`가 있으면 그 트리에서 만든 가장 가까운 값이다 */
   targetRules: CouponTargetRules;
+  /** 할인 대상 트리(이슈 #263). 없으면 `targetRules`에서 만든다(`couponTargetTreeOf`) — 계산은 트리만 읽는다 */
+  targetTree?: CouponTargetTree;
+}
+
+/** 묶음의 할인 대상 트리 — 트리가 없으면 옛 목록에서 만든다(읽기 한 경로) */
+export function couponTargetTreeOf(trees: Pick<CouponRuleTrees, "targetRules" | "targetTree">) {
+  return trees.targetTree ?? couponTargetTreeFromRules(trees.targetRules);
 }
 
 const inRule = (field: string, ids: readonly string[]): ConditionRule[] =>
@@ -552,6 +629,10 @@ const isFirstOrderRule = (node: ConditionNode): boolean =>
 const isInstantExcludeRule = (rule: ConditionRule) =>
   rule.field === "line.hasInstantDiscount" && rule.operator === "=" && rule.value === true;
 
+const instantExcluded = (exclude: ConditionGroup) =>
+  (exclude.combinator === "or" || exclude.rules.length <= 1) &&
+  exclude.rules.some((node) => !isConditionGroup(node) && isInstantExcludeRule(node));
+
 const isIdRule = (rule: ConditionRule) =>
   (rule.field === "line.productId" || rule.field === "line.categoryId") && rule.operator === "in";
 
@@ -575,9 +656,11 @@ export function legacyFromCouponRules(
           .flatMap((r) => r.value as string[]),
       ),
     ].sort();
-  const { include, exclude } = trees.targetRules;
+  const flat = couponTargetRulesFromTree(couponTargetTreeOf(trees));
+  const { include, exclude } = flat.targetRules;
   const mappedEligibility = nodes.filter((n) => n === minRule || n === firstRule).length;
   const rulesOnly =
+    flat.rulesOnly ||
     mappedEligibility !== trees.eligibility.rules.length ||
     nodes.filter(isMinOrderRule).length > 1 ||
     include.some((r) => !isIdRule(r)) ||
@@ -587,7 +670,8 @@ export function legacyFromCouponRules(
       minOrderAmount: minRule ? (minRule.value as number) : 0,
       firstOrderOnly: Boolean(firstRule),
       memberOnly,
-      stackWithInstantDiscount: !exclude.some(isInstantExcludeRule),
+      // 즉시할인 줄을 모두 빼는 것은 제외가 「하나 이상」(또는 규칙 하나)이고 즉시할인 규칙이 최상위에 있을 때뿐이다 — 「모두」 묶음의 일부면 일부 줄만 빠진다
+      stackWithInstantDiscount: !instantExcluded(couponTargetTreeOf(trees).exclude),
     },
     target: {
       includeProductIds: ids(include, "line.productId"),
@@ -601,11 +685,22 @@ export function legacyFromCouponRules(
 
 // ─── 평가(쿠폰용) ─────────────────────────────────────
 
-/** 줄이 대상인가 — 제외가 포함보다 우선, 포함이 비면 전 상품 */
+/**
+ * 줄이 대상인가(트리) — 제외가 포함보다 우선, 포함이 비면 전 상품, 제외가 비면 제외 없음(빈 그룹 참 규칙을 쓰지 않는다).
+ * 계산(`quotePricing`·최대 조합·대상 상품 판정)은 모두 이 함수를 지난다
+ */
+export function couponTargetTreeMatches(tree: CouponTargetTree, line: CouponLineContext): boolean {
+  if (
+    tree.exclude.rules.length > 0 &&
+    evaluateConditionNode(tree.exclude, COUPON_LINE_CONDITIONS, line)
+  )
+    return false;
+  return evaluateConditionNode(tree.include, COUPON_LINE_CONDITIONS, line);
+}
+
+/** 줄이 대상인가(옛 평평한 목록) — 트리로 바꿔 같은 판정 함수를 지난다 */
 export function couponLineMatches(rules: CouponTargetRules, line: CouponLineContext): boolean {
-  if (anyConditionHolds(rules.exclude, COUPON_LINE_CONDITIONS, line)) return false;
-  if (rules.include.length === 0) return true;
-  return anyConditionHolds(rules.include, COUPON_LINE_CONDITIONS, line);
+  return couponTargetTreeMatches(couponTargetTreeFromRules(rules), line);
 }
 
 /** 사용 조건 실패 사유 — 옛 칸으로 옮겨지는 실패는 옛 코드를 그대로 쓴다 */
@@ -752,6 +847,7 @@ export function couponRuleIssues(input: {
   perMemberUseLimit?: number | null;
   eligibility?: ConditionGroup;
   targetRules?: CouponTargetRules;
+  targetTree?: CouponTargetTree;
   audience?: ConditionGroup;
 }): CouponRuleIssue[] {
   const issues: CouponRuleIssue[] = [];
@@ -785,7 +881,16 @@ export function couponRuleIssues(input: {
       }),
     );
   }
-  if (input.targetRules) {
+  if (input.targetTree) {
+    for (const key of ["include", "exclude"] as const) {
+      push(
+        ["targetTree", key],
+        conditionIssues(input.targetTree[key], COUPON_LINE_CONDITIONS, {
+          allowed: allowedIn("target"),
+        }),
+      );
+    }
+  } else if (input.targetRules) {
     for (const key of ["include", "exclude"] as const) {
       push(
         ["targetRules", key],
@@ -860,9 +965,14 @@ export function couponRuleIssues(input: {
 
 /** 정규형 트리 묶음 */
 export function canonicalizeCouponTrees(trees: CouponRuleTrees): CouponRuleTrees {
+  const eligibility = canonicalizeConditionGroup(trees.eligibility);
+  if (!trees.targetTree)
+    return { eligibility, targetRules: canonicalizeCouponTargetRules(trees.targetRules) };
+  const targetTree = canonicalizeCouponTargetTree(trees.targetTree);
   return {
-    eligibility: canonicalizeConditionGroup(trees.eligibility),
-    targetRules: canonicalizeCouponTargetRules(trees.targetRules),
+    eligibility,
+    targetRules: canonicalizeCouponTargetRules(couponTargetRulesFromTree(targetTree).targetRules),
+    targetTree,
   };
 }
 
@@ -1002,6 +1112,23 @@ export function describeCouponTargetRules(
   return `${include} (${exclude} 제외)`;
 }
 
+/**
+ * 할인 대상 문구(트리) — 「상품 1개 그리고 판매가 30,000원 이상 (즉시할인 상품 제외)」. 포함이 비면 「전 상품」.
+ * 「하나라도」만 쓴 옛 쿠폰은 `describeCouponTargetRules`와 같은 문구다
+ */
+export function describeCouponTargetTree(
+  tree: CouponTargetTree,
+  formatMoney?: (minor: number) => string,
+): string {
+  const flat = couponTargetRulesFromTree(tree);
+  if (!flat.rulesOnly) return describeCouponTargetRules(flat.targetRules, formatMoney);
+  const include = tree.include.rules.length
+    ? describeCouponGroup(tree.include, formatMoney)
+    : "전 상품";
+  if (tree.exclude.rules.length === 0) return include;
+  return `${include} (${describeCouponGroup(tree.exclude, formatMoney)} 제외)`;
+}
+
 /**
  * 스토어프론트 `requirements` — 최상위 `and`면 노드마다 한 줄(그룹은 문구 한 줄), 최상위 `or`면 트리 전체를 한 줄로.
  * `minOrderAmount`(옛 필드)와 같은 원천에서 나온다.

package/src/schemas/coupon.ts

@@ -8,6 +8,7 @@ import {
   couponRulesFromLegacy,
   couponStackingSchema,
   couponTargetRulesSchema,
+  couponTargetTreeSchema,
 } from "./coupon-rules";
 import { currencyCodeSchema } from "./currency";
 import {
@@ -100,7 +101,12 @@ const descriptions = {
     "주면 `conditions`의 최소 주문 금액·첫 구매를 쓰지 않는다(`conditions`에는 `memberOnly`만 둔다). 필드 목록은 `COUPON_CONDITION_FIELDS`",
   targetRules:
     "할인 대상 규칙(이슈 #222) — `include`(하나라도 맞으면 대상, 비면 전 상품)·`exclude`(하나라도 맞으면 제외, 포함보다 우선). " +
-    "주면 `target`과 `conditions.stackWithInstantDiscount`를 쓰지 않는다(즉시할인 제외는 `line.hasInstantDiscount` 규칙)",
+    "주면 `target`과 `conditions.stackWithInstantDiscount`를 쓰지 않는다(즉시할인 제외는 `line.hasInstantDiscount` 규칙). " +
+    "포함·제외를 「모두」나 묶음으로 걸려면 `targetTree`를 쓴다",
+  targetTree:
+    "할인 대상 트리(이슈 #263) — `include`·`exclude` 각각 사용 조건과 같은 그룹 `{ combinator: and|or, rules }`(3단·규칙 50개, 줄 필드만). " +
+    "포함 그룹이 참인 줄이 대상(비면 전 상품), 제외 그룹이 참인 줄은 빠진다(포함보다 우선, 비면 제외 없음). " +
+    "주면 `targetRules`·`target`·`conditions.stackWithInstantDiscount`를 함께 주지 않는다",
   audience:
     "발급 대상 트리(이슈 #222) — 셀러 지급·받기·회원가입 지급에서 누가 받을 수 있는가. 구매자 조건만. 코드 입력형에는 두지 않는다",
   stacking:
@@ -119,6 +125,7 @@ const descriptions = {
 const ruleFields = {
   eligibility: couponConditionTreeSchema.optional().describe(descriptions.eligibility),
   targetRules: couponTargetRulesSchema.optional().describe(descriptions.targetRules),
+  targetTree: couponTargetTreeSchema.optional().describe(descriptions.targetTree),
   audience: couponConditionTreeSchema.optional().describe(descriptions.audience),
   stacking: couponStackingSchema.optional().describe(descriptions.stacking),
   reward: couponRewardSchema.nullable().optional().describe(descriptions.reward),
@@ -145,6 +152,7 @@ export function couponRequestRuleIssues(body: {
   >;
   eligibility?: CouponRuleTrees["eligibility"];
   targetRules?: CouponRuleTrees["targetRules"];
+  targetTree?: CouponRuleTrees["targetTree"];
   audience?: CouponRuleTrees["eligibility"];
   stacking?: { perOrderLimit: number };
   reward?: { type: "TIERED" | "BUY_X_GET_Y" | "POINT" } | null;
@@ -171,6 +179,14 @@ export function couponRequestRuleIssues(body: {
       path: ["target"],
       message: "할인 대상 규칙을 주면 대상 상품·즉시할인 제외는 규칙으로 둡니다",
     });
+  if (
+    body.targetTree &&
+    (body.targetRules || body.target || body.conditions?.stackWithInstantDiscount !== undefined)
+  )
+    issues.push({
+      path: ["targetTree"],
+      message: "할인 대상 트리를 주면 할인 대상 규칙·대상 상품·즉시할인 제외는 트리로 둡니다",
+    });
   const legacy = couponRulesFromLegacy(conditions, {
     includeProductIds: body.target?.includeProductIds ?? [],
     includeCategoryIds: body.target?.includeCategoryIds ?? [],
@@ -184,6 +200,7 @@ export function couponRequestRuleIssues(body: {
       perMemberUseLimit: body.perMemberUseLimit ?? null,
       eligibility: body.eligibility ?? legacy.eligibility,
       targetRules: body.targetRules ?? legacy.targetRules,
+      ...(body.targetTree ? { targetTree: body.targetTree } : {}),
       ...(body.audience ? { audience: body.audience } : {}),
     }),
   );
@@ -445,7 +462,12 @@ export const couponSchema = z.object({
   targetRules: couponTargetRulesSchema
     .optional()
     .describe(
-      "할인 대상 규칙(이슈 #222). 옛 쿠폰은 `target`에서 만든 규칙이다. 서버는 항상 싣는다",
+      "할인 대상 규칙(이슈 #222). 옛 쿠폰은 `target`에서 만든 규칙이다. `targetTree`가 「하나라도」 목록으로 나타나지 않으면 가장 가까운 값이고 `rulesOnly`가 true다. 서버는 항상 싣는다",
+    ),
+  targetTree: couponTargetTreeSchema
+    .optional()
+    .describe(
+      "할인 대상 트리(이슈 #263). 할인 대상의 원천이다. 옛 쿠폰은 `targetRules`에서 만든 트리(「하나 이상」 그룹)다. 서버는 항상 싣는다",
     ),
   audience: couponConditionTreeSchema
     .optional()

package/src/schemas/plans.ts

@@ -10,8 +10,8 @@ const limitOrContract = (description: string) =>
   z.number().int().nullable().describe(`${description}. null이면 계약(엔터프라이즈)·한도 없음`);
 
 /**
- * 요금제 기능 키 값 — 요금제 비교표·상점 플랫폼 요금제 화면이 쓴다. 키는 서버 판정의 기능 키와 같다(추가만 한다). 상위 요금제는 하위 요금제
- * 기능을 모두 포함한다
+ * 요금제 기능 키 값 — 요금제 비교표·상점 플랫폼 요금제 화면이 쓴다. 키는 서버 판정의 기능 키와 같다(추가만 한다 — 예외는 0.53에서 지운
+ * `limits.ai_credits_monthly`). 상위 요금제는 하위 요금제 기능을 모두 포함한다
  */
 export const planEntitlementsSchema = z
   .object({
@@ -24,6 +24,10 @@ export const planEntitlementsSchema = z
         "관리 API(개인 액세스 토큰·외부 앱 토큰 호출). 상점 플랫폼·CLI·MCP는 모든 요금제에서 쓴다",
       ),
     "features.analytics": z.boolean().describe("애널리틱스 화면·조회 API"),
+    "features.ai_assistant": z
+      .boolean()
+      .optional()
+      .describe("AI 상점 도우미. false면 새 실행을 시작할 수 없다(403 `PLAN_FEATURE_REQUIRED`)"),
     "limits.ai_reads_monthly": limitOrContract("MCP 읽기 월 한도"),
     "limits.ai_actions_monthly": limitOrContract(
       "MCP 쓰기(AI 작업) 월 한도 — 주문 처리는 막지 않는다",
@@ -34,9 +38,6 @@ export const planEntitlementsSchema = z
     "limits.private_apps": limitOrContract(
       "비공개 앱(이 상점 전용 앱) 설치 수(0이면 설치할 수 없다)",
     ),
-    "limits.ai_credits_monthly": limitOrContract(
-      "AI 상점 도우미 월 크레딧(1 크레딧 = 모델 원가 $0.01, 이월 없음)",
-    ),
     "limits.storefront_preview_hours_monthly": limitOrContract("편집 환경 시간(월, 시간)"),
     "limits.storefront_build_minutes_monthly": limitOrContract("빌드 시간(월, 분)"),
     "limits.storefront_requests_monthly": limitOrContract(

package/src/schemas/promotion.ts

@@ -7,11 +7,15 @@ import {
   type CouponRuleTrees,
   type CouponStacking,
   type CouponTargetRules,
+  type CouponTargetTree,
   couponLineContextOf,
-  couponLineMatches,
   couponRulesFromLegacy,
   couponStackingSchema,
+  couponTargetRulesFromTree,
   couponTargetRulesSchema,
+  couponTargetTreeFromRules,
+  couponTargetTreeMatches,
+  couponTargetTreeSchema,
   couponTimeFactsAt,
   evaluateCouponEligibility,
   pickCouponFacts,
@@ -307,6 +311,11 @@ export const couponRuleSchema = z.object({
     .describe(
       "할인 대상 규칙(이슈 #222). 없으면 `target`·`conditions.stackWithInstantDiscount`에서 만든다",
     ),
+  targetTree: couponTargetTreeSchema
+    .optional()
+    .describe(
+      "할인 대상 트리(이슈 #263). 없으면 `targetRules`(없으면 옛 칸)에서 만든다. 있으면 이것이 원천이고 `targetRules`는 가장 가까운 옛 값이다",
+    ),
   stacking: couponStackingSchema
     .optional()
     .describe("중복 사용 정책(이슈 #222). 없으면 종류별 한 장·서로 결합·적립금과 함께"),
@@ -314,17 +323,22 @@ export const couponRuleSchema = z.object({
 });
 export type CouponRule = z.infer<typeof couponRuleSchema>;
 
-/** 규칙의 트리 — 트리 칸이 없으면 옛 칸에서 만든다(계산은 늘 이 한 경로) */
+/** 규칙의 트리 — 트리 칸이 없으면 옛 칸에서 만든다(계산은 늘 이 한 경로). 할인 대상은 늘 트리(`targetTree`)까지 채운다 */
 export function couponTreesOf(
   rule: Pick<CouponRule, "conditions" | "target"> & {
     eligibility?: ConditionGroup;
     targetRules?: CouponTargetRules;
+    targetTree?: CouponTargetTree;
   },
-): CouponRuleTrees {
+): CouponRuleTrees & { targetTree: CouponTargetTree } {
   const legacy = couponRulesFromLegacy(rule.conditions, rule.target);
+  const targetRules = rule.targetTree
+    ? couponTargetRulesFromTree(rule.targetTree).targetRules
+    : (rule.targetRules ?? legacy.targetRules);
   return {
     eligibility: rule.eligibility ?? legacy.eligibility,
-    targetRules: rule.targetRules ?? legacy.targetRules,
+    targetRules,
+    targetTree: rule.targetTree ?? couponTargetTreeFromRules(targetRules),
   };
 }
 
@@ -609,17 +623,20 @@ export function allocateByWeight(total: number, weights: readonly number[]): num
 
 /** 카테고리 경로(`/a/b/c/`)가 그 카테고리 또는 하위를 가리키는가 */
 /**
- * 줄이 쿠폰 대상인가 — 제외가 포함보다 우선하고, 포함이 비면 전 상품이다. 트리(`targetRules`)가 없으면 옛 칸에서 만든 트리로 본다.
+ * 줄이 쿠폰 대상인가 — 제외가 포함보다 우선하고, 포함이 비면 전 상품이다. 트리(`targetTree`, 없으면 `targetRules`)가 없으면 옛 칸에서 만든 트리로 본다.
  * `quantity`를 생략하면 1로 본다(단가 조건은 금액 ÷ 수량).
  */
 export function isCouponTargetLine(
-  rule: Pick<CouponRule, "target" | "conditions"> & { targetRules?: CouponTargetRules },
+  rule: Pick<CouponRule, "target" | "conditions"> & {
+    targetRules?: CouponTargetRules;
+    targetTree?: CouponTargetTree;
+  },
   line: Pick<PricingLine, "productId" | "categoryPath" | "baseAmount" | "amount"> & {
     quantity?: number;
   },
 ): boolean {
-  return couponLineMatches(
-    couponTreesOf(rule).targetRules,
+  return couponTargetTreeMatches(
+    couponTreesOf(rule).targetTree,
     couponLineContextOf({ ...line, quantity: line.quantity ?? 1 }),
   );
 }
@@ -719,7 +736,7 @@ export function quotePricing(input: PricingInput): PricingResult {
     const eligible = lines.filter((entry) =>
       pinned
         ? pinned.has(entry.line.lineId)
-        : couponLineMatches(trees.targetRules, couponLineContextOf(entry.line)),
+        : couponTargetTreeMatches(trees.targetTree, couponLineContextOf(entry.line)),
     );
     result.eligibleLineIds = eligible.map((entry) => entry.line.lineId);
     if (eligible.length === 0) return "NO_ELIGIBLE_ITEMS";

package/src/schemas/subscription.ts

@@ -49,7 +49,6 @@ export const subscriptionLimitsSchema = z.object({
   adminApiRequestsMonthly: limit("관리 API 요청 월 포함량(넘으면 속도만 낮춘다, 주문 처리 제외)"),
   publicApps: limit("공개 앱(앱 스토어에 게시된 앱) 설치 수").optional(),
   privateApps: limit("비공개 앱(이 상점 전용 앱) 설치 수(0이면 설치할 수 없다)").optional(),
-  aiCreditsMonthly: limit("AI 상점 도우미 월 크레딧").optional(),
 });
 export type SubscriptionLimits = z.infer<typeof subscriptionLimitsSchema>;
 
@@ -98,6 +97,10 @@ export const storeSubscriptionSchema = z.object({
       .boolean()
       .optional()
       .describe("소유자 외 구성원이 상점에 접근할 수 있다(false면 소유자만, 구성원 목록은 남는다)"),
+    aiAssistant: z
+      .boolean()
+      .optional()
+      .describe("AI 상점 도우미를 쓸 수 있다(false면 새 실행을 시작할 수 없다)"),
     storeClone: z.boolean().describe("더 쓰지 않는다 — 상점 복제 기능을 없애 항상 false"),
     removeBadge: z.boolean().describe("더 쓰지 않는다 — 배지 키를 없애 항상 false"),
   }),
@@ -116,31 +119,6 @@ export const storeSubscriptionSchema = z.object({
       resetsAt: z.string().describe("한도가 초기화되는 시각(ISO 8601)"),
     })
     .describe("MCP 읽기 한도 요약"),
-  aiCredits: z
-    .object({
-      monthly: z.number().int().nullable().describe("요금제 월 크레딧. null이면 한도 없음"),
-      granted: z.number().int().describe("이번 기간에 쓸 수 있는 추가 지급 크레딧"),
-      used: z.number().int().describe("이번 기간 사용한 크레딧"),
-      monthlyUsed: z.number().int().optional().describe("이번 기간 월 크레딧에서 쓴 양"),
-      purchased: z
-        .number()
-        .int()
-        .optional()
-        .describe("남은 구매 크레딧 — 구매일부터 1년, 월 크레딧이 초기화돼도 남는다"),
-      complimentary: z.number().int().optional().describe("남은 무상 지급 크레딧(이벤트·보상)"),
-      remaining: z
-        .number()
-        .int()
-        .nullable()
-        .describe("남은 크레딧(월 + 구매 + 무상). null이면 한도 없음"),
-      resetsAt: z
-        .string()
-        .describe("월 크레딧이 초기화되는 시각(ISO 8601). 월 크레딧은 이월하지 않는다"),
-    })
-    .optional()
-    .describe(
-      "AI 상점 도우미 크레딧 — 1 크레딧은 모델 원가 $0.01. 남은 크레딧이 없으면 새 실행을 만들 수 없다",
-    ),
   salesFeePercent: z.literal(0).describe("판매 수수료(%). 모든 요금제 0이다"),
 });
 export type StoreSubscription = z.infer<typeof storeSubscriptionSchema>;