@fcg-labs/cx-agent-hook 0.5.1 → 0.7.1

package/MIGRATION.md

@@ -1,3 +1,50 @@
+# 0.6.0 → 0.7.0 마이그레이션
+
+## 요약 — 좋아요/싫어요 바가 추가된다. **깨지는 것 없음** (additive)
+
+## 새로 생긴 것
+
+- `AiFeedbackBar`(react) + `feedbackBarView`/`feedbackBarTree`/`FB_CLS`(view 코어) —
+  상담사의 명시적 품질 판단. 신호는 **기존 `scored` 5|1** — 새 action·프로토콜
+  변경 없음(허브·서버 재배포 불필요). 비소모라 발송 전 판단 변경 가능, 집계는
+  같은 응답 최신본 우선.
+- 배치는 답변 편집기 곁 1줄:
+  `<AiFeedbackBar session={getCsSession(csId)} agent={agent} actorClaimed={answerWriter} />`
+- 로케일 키 4종: `ui_feedback_ask/up/down/done` (ko·en·ja·zh-TW).
+
+## 행동 계약
+
+- 초안(answerId)이 없으면 바 자체가 그려지지 않는다.
+- 세션 sink 를 새로 만들지 않는다 — 초안 유무는 부모 리렌더 시점에
+  `session.adoptedAnswerId` 로 읽는다 (compose 종료·문의 전환이 리렌더를 보장).
+
+---
+
+# 0.5.x → 0.6.0 마이그레이션
+
+## 요약 — 대상 확정(더블체크, 계약 §B.10)이 추가된다. **깨지는 것 없음** (additive)
+
+문의 컨텍스트 값(예: subUserId)이 PK 라는 보장이 없다 — 오타깃 실행은 다른 유저
+데이터 손상이다. 0.6.0 부터 절차 자산이 `verify`(대상 확정)를 들고 오면 SDK 가
+쓰기 전에 **읽기 전용 API 로 대상을 확인**한다. `verify` 없는 offer 는 0.5.x 와
+바이트 동일하게 동작한다. 고객사 코드 변경 0 — `adminApi` 그대로.
+
+## 새로 생긴 것
+
+- `offer.verify` — `{action_key(읽기), execution(GET 사양), display_fields[{path,label}],
+  preconditions[], resolution}`. 서버(asset v6)가 동봉한다.
+- 실행 흐름: 선점 → **verify 읽기(GET 강제·재시도 0)** → precondition 결정적 평가 →
+  쓰기(읽기 직후 즉시) → 보고. 차단은 전부 `failed` 로 허브 원장에 남는다 —
+  reasonCode `precondition_failed`(deny_copy 가 메시지) · `verify_unavailable` ·
+  `verify_not_readonly` · `verify_manual`.
+- 확인 패널: 열릴 때 같은 읽기로 **대상 확인 블록**(`fcx-act-verify*`)을 렌더하고,
+  확인이 ok 되기 전에는 실행 버튼이 나오지 않는다 (위험도 무관).
+- `session.verifyAction(offer)`(패널 미리보기) · `session.actionVerifies()`,
+  순수 함수 `pluck`·`evaluatePreconditions`·`verifyViaAdminApi` (actions.js).
+- 로케일 키 4종: `ui_action_verify_title/loading/blocked/failed` (ko·en·ja·zh-TW).
+
+---
+
 # 0.4.0 → 0.5.0 마이그레이션
 
 ## 요약 — 처리 액션 표면만 바뀐다 (0.3.0 표면은 그대로)

package/actions.js

@@ -133,6 +133,82 @@ function normalizeResponse(res) {
   return { httpStatus: 200, body: res };
 }
 
+/** 응답 JSON 경로 추출 — `pluck(body, "data.gender")`. 없으면 undefined (결정적). */
+export function pluck(obj, path) {
+  let cur = obj;
+  for (const part of String(path || "").split(".")) {
+    if (!part) continue;
+    if (cur === null || cur === undefined || typeof cur !== "object") return undefined;
+    cur = cur[part];
+  }
+  return cur;
+}
+
+/**
+ * 대상 확정 precondition 의 결정적 평가 — 계약 §B.10. LLM 판정 없음.
+ *   not_equals_param: 응답값 === 바인딩값 이면 차단 (예: 현재 성별 === 요청 성별 → 변경 불요)
+ *   equals_param:     응답값 !== 바인딩값 이면 차단 (대상 동일성 확인)
+ *   equals_value:     응답값 !== 리터럴 이면 차단
+ * @returns {{blocked:boolean, path:string, denyCopy:string}}
+ */
+export function evaluatePreconditions(preconditions, body, paramsBound) {
+  const bound = paramsBound && typeof paramsBound === "object" ? paramsBound : {};
+  for (const p of Array.isArray(preconditions) ? preconditions : []) {
+    if (!p || typeof p !== "object" || !p.path) continue;
+    const val = pluck(body, p.path);
+    let blocked = false;
+    if (p.not_equals_param) blocked = String(val) === String(bound[p.not_equals_param]);
+    else if (p.equals_param) blocked = String(val) !== String(bound[p.equals_param]);
+    else if (p.equals_value !== undefined && p.equals_value !== "") blocked = String(val) !== String(p.equals_value);
+    if (blocked) return { blocked: true, path: String(p.path), denyCopy: String(p.deny_copy || "") };
+  }
+  return { blocked: false, path: "", denyCopy: "" };
+}
+
+/**
+ * 대상 확정(더블체크) 읽기 — 계약 §B.10 (T2.7). 쓰기 전에 offer.verify 의 **읽기 전용**
+ * API 로 대상을 조회해 ① 표시 항목(display_fields)을 뽑고 ② precondition 을 결정적으로
+ * 평가한다. 문의 컨텍스트 값이 PK 라는 보장이 없다 — 오타깃 실행은 타인 데이터 손상이라
+ * 읽기 실패·비 2xx·GET 아님은 전부 **실행 차단**(fail-closed)이다.
+ * @returns {Promise<{ok:boolean, skipped?:boolean, reasonCode?:string, message?:string,
+ *                    denyCopy?:string, display:Array<{label:string,value:string}>, httpStatus?:number}>}
+ */
+export async function verifyViaAdminApi(adminApi, offer) {
+  const v = offer && offer.verify;
+  if (!v || typeof v !== "object") return { ok: true, skipped: true, display: [] };
+  if (v.resolution === "manual") {
+    // 단건 조회로 대상 확정 불가 선언 — 자동 실행 경로가 아예 아니다 (서버 조립도 막지만 이중 방어)
+    return { ok: false, reasonCode: "verify_manual", display: [] };
+  }
+  const resolved = resolveExecution(v.execution, offer && offer.params_bound, adminApi && adminApi.endpoints);
+  if (!resolved.ok) return { ok: false, reasonCode: "verify_unavailable", message: resolved.error || "", display: [] };
+  if (resolved.method !== "get") {
+    // 검증이 부작용을 내면 안 된다 — 읽기 전용 강제
+    return { ok: false, reasonCode: "verify_not_readonly", display: [] };
+  }
+  let httpStatus = 0; let body;
+  try {
+    const res = await adminApi.request({ method: resolved.method, url: resolved.url,
+                                         path: resolved.path, query: resolved.query, data: resolved.data });
+    ({ httpStatus, body } = normalizeResponse(res));
+  } catch (err) {
+    const resp = err && err.response;
+    if (resp && typeof resp.status === "number") { httpStatus = resp.status; body = resp.data; }
+    else return { ok: false, reasonCode: "verify_unavailable", message: "transport", display: [] };
+  }
+  if (httpStatus < 200 || httpStatus >= 300) {
+    return { ok: false, reasonCode: "verify_unavailable", message: `HTTP ${httpStatus}`, httpStatus, display: [] };
+  }
+  const display = (Array.isArray(v.display_fields) ? v.display_fields : []).map((f) => {
+    const val = pluck(body, f && f.path);
+    return { label: String((f && (f.label || f.path)) || ""),
+             value: val === undefined || val === null ? "—" : String(val) };
+  });
+  const pre = evaluatePreconditions(v.preconditions, body, offer && offer.params_bound);
+  if (pre.blocked) return { ok: false, reasonCode: "precondition_failed", denyCopy: pre.denyCopy, display, httpStatus };
+  return { ok: true, display, httpStatus };
+}
+
 /**
  * CMS API 1회 호출 + 판정. **재시도 0.** adminApi.request({method,url,path,query,data}) 는
  * CMS 의 기존 헬퍼(예: TempAdminApi.request) 참조 — 세션 인증·화이트리스트·진행바는

package/client.js

@@ -387,7 +387,7 @@ export class CxAgentClient {
    * @param {string} [fb.note]
    * @returns {Promise<{ok:boolean, feedbackId:number|null, error:string}>}
    */
-  async sendFeedback({ answerId, action, score, finalText, agent, note } = {}) {
+  async sendFeedback({ answerId, action, score, finalText, agent, note, reasonCode } = {}) {
     // 계약 위반은 재시도해도 소용없다 — 즉시 보고
     if (answerId === undefined || answerId === null || answerId === "") {
       return this._fbFail(new Error("answerId 필수"), "invalid_answer_id");
@@ -411,6 +411,9 @@ export class CxAgentClient {
       ...(finalText ? { final_text: finalText } : {}),
       ...(agent ? { agent } : {}),
       ...(note ? { note } : {}),
+      // 사유 코드는 값 판정을 하지 않고 그대로 운반한다 — enum 정본은 서버(0057).
+      // 모르는 값이면 서버가 거절하고, 그 사실이 드러나는 게 조용한 소실보다 낫다.
+      ...(reasonCode ? { reason_code: reasonCode } : {}),
     };
     const path = target.path(this.domain);
     let lastErr = null;
@@ -457,9 +460,9 @@ export class CxAgentClient {
     return this.sendFeedback({ answerId, action: "edited", finalText, agent });
   }
 
-  /** 폐기 후킹 — 품질 경보 신호 */
-  discarded(answerId, agent, note) {
-    return this.sendFeedback({ answerId, action: "discarded", agent, note });
+  /** 폐기 후킹 — 품질 경보 신호. reasonCode 는 서버 enum(0057) 그대로 운반한다. */
+  discarded(answerId, agent, note, reasonCode) {
+    return this.sendFeedback({ answerId, action: "discarded", agent, note, reasonCode });
   }
 
   /**

package/element.js

@@ -57,6 +57,7 @@ function createClass() {
     #context = null;
     #state = "idle";
     #result = null;
+    #evidenceOpen = false;      // 근거는 접힘이 기본 (0.7.0)
 
     /** createCxHook() 결과 */
     get hook() { return this.#hook; }
@@ -79,6 +80,7 @@ function createClass() {
       // 후킹된다.
       this.#state = "idle";
       this.#result = null;
+      this.#evidenceOpen = false;
       if (this.#hook) this.#hook.clearAdopted();
       this.#render();
     }
@@ -114,10 +116,14 @@ function createClass() {
         result: this.#result,
         declineText: this.#hook.declineText,
         messages: this.#hook.messages,
+        expanded: this.#evidenceOpen,
+        ownRequestButton: this.hasAttribute("own-request-button"),
       });
+      if (!tree) return;
       const actions = {
         request: () => this.#request(),
         adopt: () => this.#adopt(),
+        evidence: () => { this.#evidenceOpen = !this.#evidenceOpen; this.#render(); },
       };
       const root = document.createElement("div");
       root.className = CLS.root;
@@ -204,10 +210,19 @@ function createActionsClass() {
       this.replaceChildren();
       if (!this.#agent || !this.#session) return;
       const tree = actionOffersTree({ offers: this.#offers, pending: this.#pending,
-        enabled: Boolean(this.#agent.actionsEnabled), confirming: this.#confirming, messages: this.#agent.messages });
+        enabled: Boolean(this.#agent.actionsEnabled), confirming: this.#confirming,
+        verifies: typeof this.#session.actionVerifies === "function" ? this.#session.actionVerifies() : {},
+        messages: this.#agent.messages });
       if (!tree) return;
       const actions = {
-        confirm: (e) => { this.#confirming = e.currentTarget.dataset.offer || null; this.#ackedOffer = null; this.#render(); },
+        confirm: (e) => {
+          const id = e.currentTarget.dataset.offer || null;
+          this.#confirming = id; this.#ackedOffer = null;
+          // 대상 확정 (T2.7) — 패널이 열리면 읽기 확인을 시동한다 (결과는 notify 로 재렌더)
+          const offer = this.#offers.find((o) => o.offer_id === id);
+          if (offer && offer.verify && typeof this.#session.verifyAction === "function") this.#session.verifyAction(offer);
+          this.#render();
+        },
         cancel: () => { this.#confirming = null; this.#ackedOffer = null; this.#render(); },
         ack: (e) => { const id = e.currentTarget.dataset.offer; this.#ackedOffer = this.#ackedOffer === id ? null : id; this.#render(); },
         execute: (e) => this.#execute(e.currentTarget.dataset.offer),

package/locales.js

@@ -29,8 +29,26 @@ const en = {
   ui_request: "Suggest a reply",
   ui_requesting: "Generating…",
   ui_adopt: "Insert into editor",
+  ui_feedback_ask: "Was this draft helpful?",
+  ui_feedback_up: "Helpful",
+  ui_feedback_down: "Not helpful",
+  ui_feedback_done: "Recorded — it will tune future suggestions.",
   ui_evidence: "Sources",
   ui_correcting: "Fixing phrasing — rewriting…",
+  ui_retrieving: "Finding sources…",
+  ui_ai_label: "AI draft",
+  ui_ai_disclaimer: "AI-generated — review before sending.",
+  ui_feedback_why: "What was wrong?",
+  ui_feedback_skip: "Skip",
+  ui_feedback_note_hint: "What was wrong? (one line)",
+  ui_feedback_note_send: "Send",
+  reason_stale_period: "Outdated",
+  reason_wrong_manual: "Wrong source",
+  reason_factual_error: "Incorrect",
+  reason_missing_answer: "Incomplete",
+  reason_tone_style: "Tone",
+  reason_policy_risk: "Risky wording",
+  reason_other: "Other",
   ui_action_execute: "Process",
   ui_action_confirm_default: "Run this action?",
   ui_action_confirm_ok: "Yes, run",
@@ -48,6 +66,10 @@ const en = {
   ui_action_risk_low: "low risk",
   ui_action_risk_medium: "medium risk",
   ui_action_risk_high: "high risk",
+  ui_action_verify_title: "Confirm the target before running",
+  ui_action_verify_loading: "Checking the target…",
+  ui_action_verify_blocked: "Blocked by a pre-run check.",
+  ui_action_verify_failed: "Could not confirm the target — this action will not run.",
   ui_overwrite_confirm: "Replace your current draft with the AI draft?",
   // 거절·오류 사유
   not_configured: "AI reply suggestions are not connected yet.",
@@ -72,8 +94,26 @@ const ko = {
   ui_request: "AI 답변 제안",
   ui_requesting: "제안 생성 중...",
   ui_adopt: "에디터에 넣기",
+  ui_feedback_ask: "이 초안, 쓸 만했나요?",
+  ui_feedback_up: "좋아요",
+  ui_feedback_down: "싫어요",
+  ui_feedback_done: "기록됐습니다 — 다음 제안 품질에 반영됩니다.",
   ui_evidence: "근거",
   ui_correcting: "표현 교정 중 — 다시 쓰는 중...",
+  ui_retrieving: "근거 찾는 중…",
+  ui_ai_label: "AI 초안",
+  ui_ai_disclaimer: "AI가 쓴 초안입니다 — 확인 후 전송하세요.",
+  ui_feedback_why: "무엇이 문제였나요?",
+  ui_feedback_skip: "건너뛰기",
+  ui_feedback_note_hint: "무엇이 문제였나요? (한 줄)",
+  ui_feedback_note_send: "보내기",
+  reason_stale_period: "낡은 내용",
+  reason_wrong_manual: "다른 근거",
+  reason_factual_error: "내용 오류",
+  reason_missing_answer: "일부 미답",
+  reason_tone_style: "어조·표현",
+  reason_policy_risk: "위험 표현",
+  reason_other: "기타",
   ui_action_execute: "처리하기",
   ui_action_confirm_default: "이 처리를 진행할까요?",
   ui_action_confirm_ok: "네, 진행",
@@ -91,6 +131,10 @@ const ko = {
   ui_action_risk_low: "위험 낮음",
   ui_action_risk_medium: "위험 보통",
   ui_action_risk_high: "위험 높음",
+  ui_action_verify_title: "실행 전 대상 확인",
+  ui_action_verify_loading: "대상 확인 중…",
+  ui_action_verify_blocked: "실행 전 확인에서 차단되었습니다.",
+  ui_action_verify_failed: "대상을 확인할 수 없습니다 — 실행하지 않습니다.",
   ui_overwrite_confirm: "작성 중인 답변을 지우고 AI 초안으로 바꿀까요?",
   not_configured: "AI 답변 제안이 아직 연결되지 않았습니다.",
   unsupported_api: "AI 답변 제안이 아직 연결되지 않았습니다.",
@@ -110,8 +154,26 @@ const ja = {
   ui_request: "AI 返信案",
   ui_requesting: "生成中...",
   ui_adopt: "エディタに挿入",
+  ui_feedback_ask: "この下書きは役に立ちましたか?",
+  ui_feedback_up: "良い",
+  ui_feedback_down: "悪い",
+  ui_feedback_done: "記録しました — 今後の提案に反映されます。",
   ui_evidence: "根拠",
   ui_correcting: "表現を修正中 — 書き直しています…",
+  ui_retrieving: "根拠を検索中…",
+  ui_ai_label: "AI 下書き",
+  ui_ai_disclaimer: "AI が作成した下書きです — 確認してから送信してください。",
+  ui_feedback_why: "何が問題でしたか?",
+  ui_feedback_skip: "スキップ",
+  ui_feedback_note_hint: "何が問題でしたか?(一行)",
+  ui_feedback_note_send: "送信",
+  reason_stale_period: "古い内容",
+  reason_wrong_manual: "根拠が違う",
+  reason_factual_error: "内容の誤り",
+  reason_missing_answer: "一部未回答",
+  reason_tone_style: "語調・表現",
+  reason_policy_risk: "リスク表現",
+  reason_other: "その他",
   ui_action_execute: "処理する",
   ui_action_confirm_default: "この処理を実行しますか？",
   ui_action_confirm_ok: "はい、実行",
@@ -129,6 +191,10 @@ const ja = {
   ui_action_risk_low: "リスク低",
   ui_action_risk_medium: "リスク中",
   ui_action_risk_high: "リスク高",
+  ui_action_verify_title: "実行前に対象を確認",
+  ui_action_verify_loading: "対象を確認しています…",
+  ui_action_verify_blocked: "実行前チェックでブロックされました。",
+  ui_action_verify_failed: "対象を確認できません — 実行しません。",
   ui_overwrite_confirm: "作成中の回答を消してAI下書きに置き換えますか？",
   not_configured: "AI 返信案はまだ接続されていません。",
   unsupported_api: "AI 返信案はまだ接続されていません。",
@@ -148,8 +214,26 @@ const zhTW = {
   ui_request: "AI 回覆建議",
   ui_requesting: "產生中...",
   ui_adopt: "插入編輯器",
+  ui_feedback_ask: "這份草稿有幫助嗎?",
+  ui_feedback_up: "有幫助",
+  ui_feedback_down: "沒幫助",
+  ui_feedback_done: "已記錄 — 將反映於後續建議。",
   ui_evidence: "依據",
   ui_correcting: "正在修正表述 — 重新撰寫中…",
+  ui_retrieving: "尋找依據中…",
+  ui_ai_label: "AI 草稿",
+  ui_ai_disclaimer: "AI 產生的草稿 — 請確認後再傳送。",
+  ui_feedback_why: "哪裡有問題?",
+  ui_feedback_skip: "略過",
+  ui_feedback_note_hint: "哪裡有問題?(一行)",
+  ui_feedback_note_send: "送出",
+  reason_stale_period: "內容過時",
+  reason_wrong_manual: "依據不符",
+  reason_factual_error: "內容錯誤",
+  reason_missing_answer: "部分未答",
+  reason_tone_style: "語氣表達",
+  reason_policy_risk: "風險用語",
+  reason_other: "其他",
   ui_action_execute: "處理",
   ui_action_confirm_default: "要執行這項處理嗎？",
   ui_action_confirm_ok: "是，執行",
@@ -167,6 +251,10 @@ const zhTW = {
   ui_action_risk_low: "風險低",
   ui_action_risk_medium: "風險中",
   ui_action_risk_high: "風險高",
+  ui_action_verify_title: "執行前確認對象",
+  ui_action_verify_loading: "正在確認對象…",
+  ui_action_verify_blocked: "已被執行前檢查擋下。",
+  ui_action_verify_failed: "無法確認對象 — 不會執行。",
   ui_overwrite_confirm: "要清除目前草稿並以 AI 草稿取代嗎？",
   not_configured: "AI 回覆建議尚未連接。",
   unsupported_api: "AI 回覆建議尚未連接。",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fcg-labs/cx-agent-hook",
-  "version": "0.5.1",
+  "version": "0.7.1",
   "description": "FCG CX Agent 후킹 SDK — 서빙 답변 수신 + CS팀 교정(점수·수정·발송) 후킹. 의존성 0, CMS에 install만으로 이식",
   "type": "module",
   "main": "index.js",

package/react.d.ts

@@ -31,4 +31,13 @@ export interface ActionOffersPanelProps {
 /** 처리 선택지 카드 (actions/1 프로파일 B) — 잠김·비활성·2단 확인·상태·미보고 규약을 갖는다. */
 export declare function ActionOffersPanel(props: ActionOffersPanelProps): ReactElement | null;
 
+export interface AiFeedbackBarProps {
+  session: InquirySession;
+  agent: CxAgent;
+  actorClaimed?: string;
+  className?: string;
+}
+/** 좋아요/싫어요 바 — scored 5|1 로 원장에 남는 상담사 품질 판단 (0.7.0). */
+export declare function AiFeedbackBar(props: AiFeedbackBarProps): ReactElement | null;
+
 export default AiSuggestPanel;

package/react.js

@@ -19,7 +19,7 @@
  */
 import { createElement as h, useCallback, useEffect, useRef, useState } from "react";
 
-import { actionOffersTree, aiSuggestTree, aiSuggestView, CLS } from "./view.js";
+import { actionOffersTree, aiSuggestTree, aiSuggestView, CLS, feedbackBarTree } from "./view.js";
 
 // 표시 판단은 프레임워크 중립 코어가 갖는다 — Vue·웹 컴포넌트와 같은 것을 쓴다.
 export { aiSuggestView };
@@ -30,6 +30,7 @@ function renderNode(node, actions, key) {
   if (node.tag === "button") {
     props.type = node.type || "button";
     props.disabled = Boolean(node.disabled);
+    if (node.pressed !== undefined) props["aria-pressed"] = Boolean(node.pressed);
   }
   if (node.action && actions[node.action]) props.onClick = actions[node.action];
   const children = node.children
@@ -48,17 +49,62 @@ function renderNode(node, actions, key) {
  * @param {(text: string) => void} props.onAdopt  "에디터에 넣기"
  * @param {string}  [props.className] 바깥 배치용 (레이아웃만)
  */
-export function AiSuggestPanel({ hook, inquiry, context, onAdopt, className }) {
+/**
+ * 세션+agent → 패널 어댑터. **(session, agent) 쌍당 하나**만 만든다.
+ *
+ * 렌더마다 새 객체를 만들면(0.7.0 이 그랬다) 그것을 deps 로 둔 리셋 effect 가
+ * 렌더마다 돌아 `clearAdopted()` 로 세션의 answer_id 를 지운다 — compose 가
+ * 확정한 id 가 부모의 첫 리렌더에서 사라져 피드백 바가 안 뜨고, 발송 gold 쌍
+ * 후킹도 id 없이 나간다(2026-08-27 운영 실측: answered=true·answer_id 도착,
+ * `.fcx-fb` 0개). 정체성은 훅이 아니라 캐시로 고정한다 — React 밖에서도
+ * 시험할 수 있어야 한다(이 패키지는 react-dom 을 의존하지 않는다).
+ */
+const API_CACHE = new WeakMap();   // session → { agent, api }
+export function sessionApi(session, agent) {
+  if (!session || !agent) return null;
+  const hit = API_CACHE.get(session);
+  if (hit && hit.agent === agent) return hit.api;
+  const api = {
+    enabled: agent.enabled,
+    messages: agent.messages,
+    declineText: agent.declineText,
+    requestAnswer: (q, ctx) => session.compose({ inquiry: q, context: ctx }).promise,
+    noteAdopted: (id) => session.noteAdopted(id),
+    clearAdopted: () => session.clearAdopted(),
+  };
+  API_CACHE.set(session, { agent, api });
+  return api;
+}
+
+export function AiSuggestPanel({ hook, session, agent, inquiry, context, onAdopt, className, ownRequestButton }) {
+  /*
+   * 두 계약을 다 받는다 (0.7.0):
+   *   - `hook`   0.2.x 단일 훅(createCxHook) — 옛 소비처 보존
+   *   - `session`+`agent`  세션 기반(현행) — 초안 정본이 세션 버퍼라 문의 전환·
+   *     복귀에도 살아남는다. 세션엔 enabled·messages 가 없어 agent 가 짝이다.
+   * 섞어 넘기면(session 을 hook 자리에) 카드가 조용히 안 그려진다 —
+   * 실제로 2026-08-27 그 사고가 났다. 그래서 어댑터가 **명시적으로** 짝을
+   * 맞추고, 짝이 안 맞으면 개발 콘솔에 사유를 남긴다.
+   */
+  const api = hook || sessionApi(session, agent);
+  if (!api && typeof console !== "undefined") {
+    console.warn("[cx-agent-hook] AiSuggestPanel: hook 또는 (session+agent) 가 필요합니다");
+  }
   const [state, setState] = useState("idle");
   const [result, setResult] = useState(null);
+  const [evidenceOpen, setEvidenceOpen] = useState(false);   // 근거는 접힘이 기본 (0.7.0)
 
-  // 다른 문의로 옮기면 앞 문의의 제안이 남아 있으면 안 된다. 채택 기록도 같이
-  // 지운다 — 안 지우면 다음 문의를 발송할 때 엉뚱한 answer_id 로 후킹된다.
+  // 다른 문의로 옮기면 앞 문의의 제안이 남아 있으면 안 된다.
+  // 채택 기록은 **단일 훅(hook) 계약에서만** 같이 지운다 — 훅 하나가 모든 문의를
+  // 겸하므로 안 지우면 다음 문의 발송이 엉뚱한 answer_id 로 후킹된다.
+  // 세션 계약에서는 지우지 않는다: 세션이 문의별로 따로라 섞일 일이 없고,
+  // 여기서 지우면 옮겨 간 문의의 세션이 가진 id 까지 죽는다(0.7.1).
   useEffect(() => {
     setState("idle");
     setResult(null);
-    hook.clearAdopted();
-  }, [inquiry, hook]);
+    setEvidenceOpen(false);
+    if (hook) hook.clearAdopted();
+  }, [inquiry, hook, api]);
 
   // context 는 ref 로 최신값만 읽는다 — deps 에 넣으면 인라인 객체가
   // 리렌더마다 새 참조가 되어 요청 콜백이 계속 재생성된다.
@@ -68,21 +114,24 @@ export function AiSuggestPanel({ hook, inquiry, context, onAdopt, className }) {
   const request = useCallback(async () => {
     if (!inquiry || state === "loading") return;
     setState("loading");
-    setResult(await hook.requestAnswer(inquiry, contextRef.current));
+    setResult(await api.requestAnswer(inquiry, contextRef.current));
     setState("done");
-  }, [hook, inquiry, state]);
+  }, [api, inquiry, state]);
 
   const adopt = useCallback(() => {
     if (!result || !result.answered) return;
-    hook.noteAdopted(result.answerId);
+    api.noteAdopted(result.answerId);
     if (onAdopt) onAdopt(result.answer);
-  }, [hook, onAdopt, result]);
+  }, [api, onAdopt, result]);
 
-  if (!hook || !hook.enabled) return null;
+  if (!api || !api.enabled) return null;
 
   const tree = aiSuggestTree({
-    state, result, declineText: hook.declineText, messages: hook.messages,
+    state, result, declineText: api.declineText, messages: api.messages,
+    expanded: evidenceOpen, ownRequestButton,
   });
+  // 그릴 것이 없으면 빈 상자를 남기지 않는다 (0.7.0)
+  if (!tree) return null;
 
   return h(
     "div",
@@ -92,7 +141,9 @@ export function AiSuggestPanel({ hook, inquiry, context, onAdopt, className }) {
       // 행 선택이 토글되면 제안이 초기화된다.
       onClick: (event) => event.stopPropagation(),
     },
-    tree.children.map((node, i) => renderNode(node, { request, adopt }, i)),
+    tree.children.map((node, i) => renderNode(node, {
+      request, adopt, evidence: () => setEvidenceOpen((v) => !v),
+    }, i)),
   );
 }
 
@@ -144,11 +195,18 @@ export function ActionOffersPanel({ session, agent, actorClaimed, onResult, clas
   }, [offers, ackedOffer, session, onResult]);
 
   if (!session || !agent) return null;
-  const tree = actionOffersTree({ offers, pending, enabled: Boolean(agent.actionsEnabled), confirming, messages: agent.messages });
+  const tree = actionOffersTree({ offers, pending, enabled: Boolean(agent.actionsEnabled), confirming,
+    verifies: typeof session.actionVerifies === "function" ? session.actionVerifies() : {},
+    messages: agent.messages });
   if (!tree) return null;
 
   const actions = {
-    confirm: (e) => { setConfirming(e.currentTarget.dataset.offer || null); setAckedOffer(null); },
+    confirm: (e) => {
+      const id = e.currentTarget.dataset.offer || null;
+      setConfirming(id); setAckedOffer(null);
+      const offer = offers.find((o) => o.offer_id === id);
+      if (offer && offer.verify && typeof session.verifyAction === "function") session.verifyAction(offer); // T2.7 — 결과는 notify 재렌더
+    },
     cancel: () => { setConfirming(null); setAckedOffer(null); },
     ack: (e) => { const id = e.currentTarget.dataset.offer; setAckedOffer((v) => (v === id ? null : id)); },
     execute: (e) => execute(e.currentTarget.dataset.offer),
@@ -176,3 +234,99 @@ export function ActionOffersPanel({ session, agent, actorClaimed, onResult, clas
                     onClick: (event) => event.stopPropagation() },
            tree.children.map((n, i) => render(n, i)));
 }
+
+// ── 좋아요/싫어요 바 (0.7.0) ──────────────────────────────────────────────
+//
+// 답변 패널과 같은 이유로 라이브러리에 있다: 이 판단(scored 5|1)이 절차별
+// 서빙 웨이트·재학습 라벨의 원료다. 고객사는 답변 편집기 곁에 배치만 한다.
+//
+// ```jsx
+// import { AiFeedbackBar } from "@fcg-labs/cx-agent-hook/react";
+// <AiFeedbackBar session={getCsSession(csId)} agent={agent} actorClaimed={answerWriter} />
+// ```
+//
+// 세션 sink 를 새로 늘리지 않는다 — 초안 유무는 부모 리렌더 시점에
+// `session.adoptedAnswerId` 로 읽는다 (compose 종료·문의 전환 때 CMS 가
+// 어차피 리렌더한다). scored 는 비소모라 발송 전 판단 변경이 가능하다.
+
+/**
+ * @param {object} props
+ * @param {object} props.session   agent.session(externalId)
+ * @param {object} props.agent     createCxAgent() 결과 — enabled·messages
+ * @param {string} [props.actorClaimed]  행위자 이름(자기 주장) — 원장에 남는다
+ * @param {string} [props.className]  바깥 배치용 (레이아웃만)
+ */
+export function AiFeedbackBar({ session, agent, actorClaimed, className }) {
+  const answerId = session ? session.adoptedAnswerId : null;
+  const [voted, setVoted] = useState(null);
+  const [asking, setAsking] = useState(false);   // 싫어요 뒤 사유 묻기 (선택)
+  const [noting, setNoting] = useState(false);   // 「기타」 — 한 줄 자유 입력
+  const noteRef = useRef("");
+  // 다른 초안(또는 다른 문의)이 오면 앞 판단 표시가 남으면 안 된다.
+  useEffect(() => {
+    setVoted(null); setAsking(false); setNoting(false); noteRef.current = "";
+  }, [session, answerId]);
+
+  const actorRef = useRef(actorClaimed);
+  actorRef.current = actorClaimed;
+
+  const vote = useCallback((dir) => {
+    if (!session) return;
+    // 판단은 **즉시** 기록된다 — 사유는 그 뒤의 선택이지 전제가 아니다.
+    session.scored(dir === "up" ? 5 : 1, actorRef.current);
+    setVoted(dir);
+    setAsking(dir === "down");
+  }, [session]);
+
+  const sendNote = useCallback(() => {
+    // 코드는 other, 문장은 note — 사유 코드만으로는 뜻을 못 읽는다.
+    if (session) session.discarded(actorRef.current, noteRef.current.trim(), "other");
+    setNoting(false); setAsking(false); noteRef.current = "";
+  }, [session]);
+
+  const pickReason = useCallback((code) => {
+    /*
+     * 사유는 **폐기의 이유**로 남는다 — 서버 계약(store/serving.py:600)이
+     * `reason_code` 를 discarded 에만 허용한다. 점수는 이미 남았고(1클릭),
+     * 여기서 한 번 더 남기는 것은 "이 초안을 버린 이유"다.
+     * discarded 는 소모라 이 뒤로 그 초안의 판단은 닫힌다.
+     */
+    if (code === "other") { setNoting(true); return; }   // 기타 → 한 줄 적기
+    if (session && code) session.discarded(actorRef.current, "", code);
+    setAsking(false);
+  }, [session]);
+
+  if (!session || !agent || !agent.enabled) return null;
+  const tree = feedbackBarTree({ answerId, voted, asking, noting, messages: agent.messages });
+  if (!tree) return null;
+
+  const actions = {
+    up: () => vote("up"),
+    down: () => vote("down"),
+    reason: (e) => pickReason(e.currentTarget.dataset.reason || ""),
+    skip: () => { setAsking(false); setNoting(false); },
+    note: (e) => { noteRef.current = e.target.value; },
+    noteSend: () => sendNote(),
+  };
+  const render = (node, key) => {
+    const props = { key, className: node.cls };
+    if (node.tag === "button") {
+      props.type = node.type || "button";
+      if (node.action && actions[node.action]) props.onClick = actions[node.action];
+      if (node.reason) props["data-reason"] = node.reason;
+      if (node.pressed !== undefined) props["aria-pressed"] = Boolean(node.pressed);
+    } else if (node.tag === "input") {
+      props.type = "text";
+      props.placeholder = node.placeholder || "";
+      props.defaultValue = "";
+      if (node.action && actions[node.action]) props.onChange = actions[node.action];
+      // Enter 로도 보낼 수 있게 — 한 줄 입력에 버튼만 두면 손이 한 번 더 간다
+      props.onKeyDown = (e) => { if (e.key === "Enter") { e.preventDefault(); sendNote(); } };
+    }
+    if (node.live) props.role = "status";
+    return h(node.tag, props, node.children ? node.children.map((c, i) => render(c, i)) : node.text);
+  };
+  return h("div", { className: className ? `${tree.cls} ${className}` : tree.cls,
+                    onClick: (event) => event.stopPropagation() },
+           tree.children.map((n, i) => render(n, i)));
+}

package/session.js

@@ -24,7 +24,7 @@
  * **수명이 다르다**: 요청은 전송 **전에** 남고, 종단 뒤 24h 까지 살아 새로고침·
  * 재진입 시 "이미 눌렀던 것" 을 안다. 정본은 허브 원장이다 — 브라우저 소실은
  * 기록 손실이 아니라 표시 손실일 뿐. localStorage 부재면 메모리로만 산다. */
-import { executeViaAdminApi } from "./actions.js";
+import { executeViaAdminApi, verifyViaAdminApi } from "./actions.js";
 
 export class ActionLedger {
   constructor({ impl, prefix = "cx-agent-actions", terminalTtlMs = 24 * 60 * 60 * 1000 } = {}) {
@@ -139,6 +139,14 @@ export class SessionStore {
   }
 }
 
+/** 의사 스트림 (0.7.0) — 통짜 청크로 판정하는 길이. 이보다 크면 조각내어 보여 준다. */
+const BULK_CHUNK_CHARS = 120;
+/** 조각 표시 주기(ms)와 전체를 다 보여주는 데 쓰는 틱 수 — 약 1.4초에 완주. */
+const REVEAL_INTERVAL_MS = 40;
+const REVEAL_TICKS = 35;
+/** 한 틱 최소 글자 — 짧은 답변이 지나치게 느리게 흐르지 않게. */
+const REVEAL_MIN_STEP = 2;
+
 export class InquirySession {
   /**
    * 직접 만들지 않는다 — `agent.session(externalId)` 가 만든다.
@@ -156,6 +164,7 @@ export class InquirySession {
     this._offers = [];              // 마지막 답변의 처리 선택지 (actions/1 §4)
     this._actionUi = null;
     this._locks = {};               // action_key\x00target_key → 잠금 조회 결과 (세션 캐시)
+    this._verify = {};              // offer_id → 대상 확정(더블체크) 결과 (T2.7, 화면 표시용 캐시)
 
     // 영속 복원 — TTL 만료분은 store 가 이미 걸렀다
     if (this._id && deps.store) {
@@ -263,6 +272,27 @@ export class InquirySession {
       return { requestId, ...r };
     }
     if (d.actionLedger) d.actionLedger.put(requestId, { ...rec, state: "received" });
+    // ②-a 대상 확정 (T2.7, 계약 §B.10) — verify 동봉 offer 는 **쓰기 직전에 읽기 재검**.
+    // 패널의 verifyAction 표시와 별개로 여기서 다시 읽는다 (TOCTOU 최소화 — 읽기
+    // 직후 즉시 쓰기). 읽기 실패·precondition 불통과 = 실행 차단 + 원장 보고.
+    if (offer.verify) {
+      const vr = await verifyViaAdminApi(d.adminApi, offer);
+      this._verify[offer.offer_id] = { state: vr.ok ? "ok" : "blocked", reasonCode: vr.reasonCode || "",
+                                       denyCopy: vr.denyCopy || "", message: vr.message || "", display: vr.display || [] };
+      if (!vr.ok) {
+        const reasonCode = vr.reasonCode || "verify_unavailable";
+        const message = vr.denyCopy || vr.message || "";
+        const report = { state: "failed", reasonCode, message, httpStatus: vr.httpStatus || 0, latencyMs: 0 };
+        const rep = await d.client.reportActionResult(requestId, report);
+        const unreported = !rep.ok && rep.httpStatus === 0;
+        if (d.actionLedger) {
+          d.actionLedger.put(requestId, { ...rec, state: "failed", reasonCode, message,
+                                          unreported, pendingReport: unreported ? report : undefined });
+        }
+        this._notifyActions();
+        return { requestId, ok: true, state: "failed", reasonCode, message, reported: !unreported, error: null };
+      }
+    }
     // ② CMS 자기 API — 재시도 0
     const out = await executeViaAdminApi(d.adminApi, offer);
     if (out.authExpired && typeof d.adminApi.onAuthExpired === "function") {
@@ -285,6 +315,25 @@ export class InquirySession {
     return { requestId, ok: true, state: out.state, reasonCode: out.reasonCode, message: out.message,
              reported: !unreported, error: null };
   }
+  /**
+   * 대상 확정 미리보기 (T2.7) — 확인 패널이 열릴 때 UI 가 부른다. 결과는 캐시돼
+   * 카드의 "대상 확인" 블록에 표시되고, 실행 버튼은 ok 일 때만 나온다.
+   * 실제 실행(executeAction)은 이 캐시를 믿지 않고 쓰기 직전에 다시 읽는다.
+   */
+  async verifyAction(offer) {
+    const d = this._d;
+    if (!offer || !offer.offer_id || !offer.verify) return { ok: true, skipped: true, display: [] };
+    if (!d.adminApi || typeof d.adminApi.request !== "function") return { ok: false, reasonCode: "admin_api_missing", display: [] };
+    this._verify[offer.offer_id] = { state: "loading", reasonCode: "", denyCopy: "", message: "", display: [] };
+    this._notifyActions();
+    const out = await verifyViaAdminApi(d.adminApi, offer);
+    this._verify[offer.offer_id] = { state: out.ok ? "ok" : "blocked", reasonCode: out.reasonCode || "",
+                                     denyCopy: out.denyCopy || "", message: out.message || "", display: out.display || [] };
+    this._notifyActions();
+    return out;
+  }
+  /** offer_id → 대상 확정 상태 스냅샷 — view 의 `verifies` 입력. */
+  actionVerifies() { return { ...this._verify }; }
   /** 미보고 결과 재보고 — 재실행이 아니다. ledger 의 pendingReport 만 다시 보낸다. */
   async resendResult(requestId) {
     const d = this._d;
@@ -416,6 +465,27 @@ export class InquirySession {
     };
     const clearPending = () => {
       if (pending !== null) { clearTimeout(pending); pending = null; }
+      if (reveal !== null) { clearInterval(reveal); reveal = null; }
+    };
+
+    /*
+     * 의사 스트림 (0.7.0) — 공급자가 통짜로 줄 때도 글자가 흐르게.
+     *
+     * codex 계열은 답변을 **한 번에** 낸다(finish_reason='single_chunk') — 그대로
+     * 그리면 15초 정적 뒤 완성본이 튀어나와 "AI 가 쓰고 있다"는 신호가 0 이다.
+     * 진짜 토큰 스트림이면 이 경로는 타지 않는다(작은 청크는 그대로 흐른다).
+     * 정본(this._draft)은 늘 전체 텍스트다 — 화면에 보이는 양만 늦춘다.
+     */
+    let reveal = null;
+    let revealed = 0;
+    const revealFrom = (full) => {
+      if (reveal !== null) { clearInterval(reveal); reveal = null; }
+      const step = Math.max(REVEAL_MIN_STEP, Math.ceil(full.length / REVEAL_TICKS));
+      reveal = setInterval(() => {
+        revealed = Math.min(full.length, revealed + step);
+        if (this._ui) this._ui.setDraft(decorate(full.slice(0, revealed)));
+        if (revealed >= full.length) { clearInterval(reveal); reveal = null; }
+      }, REVEAL_INTERVAL_MS);
     };
 
     this._state = "composing";
@@ -427,7 +497,17 @@ export class InquirySession {
       signal: controller.signal,
       ...(idleTimeoutMs ? { idleTimeoutMs } : {}),
       ...(overallTimeoutMs ? { overallTimeoutMs } : {}),
-      onDelta: (text) => { accumulated += text; queueDraft(); },
+      onDelta: (text) => {
+        accumulated += text;
+        // 통짜 청크(공급자가 한 번에 준 것)면 조각내어 흘린다 — 판정은 길이뿐이라
+        // 결정적이고, 진짜 스트림의 작은 청크는 기존 스로틀 경로 그대로.
+        if (text.length >= BULK_CHUNK_CHARS) {
+          this._draft = decorate(accumulated);
+          revealFrom(accumulated);
+        } else {
+          queueDraft();
+        }
+      },
       onRestart: () => {
         // 계약 위반 교정 — 지금까지 보인 초안은 폐기본이다
         clearPending();
@@ -437,7 +517,10 @@ export class InquirySession {
         this._setStatus(d.messages.ui_correcting);
       },
       onStage: (phase) => {
-        if (phase === "generating") this._setStatus(d.messages.ui_requesting);
+        // 단계를 사람 말로 — "제안 생성 중" 한 문구로는 15초 동안 무엇이
+        // 진행 중인지 알 수 없다(근거 검색과 생성은 체감이 다른 구간이다).
+        if (phase === "retrieving") this._setStatus(d.messages.ui_retrieving);
+        else if (phase === "generating") this._setStatus(d.messages.ui_requesting);
       },
     }).then((result) => {
       clearPending();
@@ -524,7 +607,7 @@ export class InquirySession {
     this._emit((id) => this._d.client.sent(id, finalText, agent), true);
   }
 
-  /** 품질 점수 1~5 — 발송 전 여러 번 가능 (비소모) */
+  /** 품질 점수 1~5 — 발송 전 여러 번 가능 (비소모). 사유는 여기 안 실린다(아래 계약). */
   scored(score, agent) {
     this._emit((id) => this._d.client.scored(id, score, agent), false);
   }
@@ -534,8 +617,8 @@ export class InquirySession {
     this._emit((id) => this._d.client.edited(id, finalText, agent), false);
   }
 
-  /** 폐기 + 이유 — 마지막 판단이라 기록을 비운다 */
-  discarded(agent, note) {
-    this._emit((id) => this._d.client.discarded(id, agent, note), true);
+  /** 폐기 + 이유 — 마지막 판단이라 기록을 비운다. reasonCode 는 서버 enum(0057). */
+  discarded(agent, note, reasonCode) {
+    this._emit((id) => this._d.client.discarded(id, agent, note, reasonCode), true);
   }
 }

package/styles.css

@@ -139,6 +139,15 @@
   background: var(--fcx-surface-2, #e8eef7); border-radius: var(--fcx-radius, 10px);
 }
 .fcx-act-confirm-text { font-weight: 600; }
+/* 대상 확인 블록 (T2.7 §B.10) — 실행 전 읽기 검증 표시 */
+.fcx-act-verify {
+  display: grid; gap: 2px; padding: 6px 8px;
+  border: 1px dashed var(--fcx-accent, #2f6fed); border-radius: 6px;
+  background: var(--fcx-surface, #fff);
+}
+.fcx-act-verify-title { font-weight: 600; font-size: 0.92em; }
+.fcx-act-verify-line { font-variant-numeric: tabular-nums; }
+.fcx-act-verify-status { color: var(--fcx-warn, #6b4a0b); font-size: 0.92em; }
 .fcx-act-ack {
   justify-self: start; cursor: pointer; font: inherit;
   padding: 2px 4px; border: 0; background: transparent; border-radius: 4px;
@@ -163,8 +172,95 @@
 [data-fcx-theme="dark"] .fcx-act { color: var(--fcx-text, #dbe6f3); }
 [data-fcx-theme="dark"] .fcx-act-params, [data-fcx-theme="dark"] .fcx-act-status { color: var(--fcx-muted, #8ba0b8); }
 [data-fcx-theme="dark"] .fcx-act-risk, [data-fcx-theme="dark"] .fcx-act-confirm { background: var(--fcx-surface-2, #182238); }
+[data-fcx-theme="dark"] .fcx-act-verify { background: var(--fcx-surface, #0f1626); }
 [data-fcx-theme="dark"] .fcx-act-locked { background: var(--fcx-success-bg, #12301c); }
 
 @media (prefers-reduced-motion: reduce) {
   .fcx-ai-button, .fcx-ai-adopt, .fcx-act-button, .fcx-act-resend { transition: none; }
 }
+
+/* ── 좋아요/싫어요 바 (0.7.0) ─────────────────────────────────────────── */
+/* ⚠ 줄바꿈 금지 — 편집기 폭이 좁으면 "좋아요" 가 세로로 쪼개진다(2026-08-27 실측).
+   flex 아이템은 기본적으로 자기 콘텐츠보다 작게 줄어든다(min-width:auto 예외 아님). */
+.fcx-fb { display: flex; align-items: center; gap: 8px; margin-top: 6px; font-size: 13px; flex-wrap: wrap; }
+.fcx-fb-label { color: var(--fcx-muted, #5b6b7d); }
+.fcx-fb-up, .fcx-fb-down {
+  padding: 3px 10px; border-radius: 6px; font-size: 13px; cursor: pointer;
+  border: 1px solid var(--fcx-border, #d4dde7); background: var(--fcx-surface, #fff);
+  color: var(--fcx-text, #1c2733);
+  white-space: nowrap; flex: 0 0 auto;
+}
+.fcx-fb-up[aria-pressed="true"] { background: var(--fcx-success-bg, #e8f5ec); border-color: var(--fcx-success, #1f7a3f); color: var(--fcx-success, #1f7a3f); }
+.fcx-fb-down[aria-pressed="true"] { background: var(--fcx-danger-bg, #fdecea); border-color: var(--fcx-danger, #b42318); color: var(--fcx-danger, #b42318); }
+.fcx-fb-done { color: var(--fcx-muted, #5b6b7d); }
+
+[data-fcx-theme="dark"] .fcx-fb-up, [data-fcx-theme="dark"] .fcx-fb-down {
+  background: var(--fcx-surface, #10182a); border-color: var(--fcx-border, #24344d); color: var(--fcx-text, #dbe6f3);
+}
+[data-fcx-theme="dark"] .fcx-fb-up[aria-pressed="true"] { background: var(--fcx-success-bg, #12301c); }
+[data-fcx-theme="dark"] .fcx-fb-down[aria-pressed="true"] { background: var(--fcx-danger-bg, #3a1512); }
+
+/* ── AI 제안 카드 (0.7.0) — 표식·근거 3단·고지 ─────────────────────────── */
+.fcx-ai-label {
+  align-items: center; display: inline-flex; gap: 4px;
+  border: 1px solid var(--fcx-brand-border, #d4dde7);
+  border-radius: 999px; padding: 1px 8px;
+  font-size: 11px; font-weight: 600; letter-spacing: 0.01em;
+  color: var(--fcx-brand, #5b6b7d);
+}
+.fcx-ai-label::before { content: "✦"; font-size: 10px; }
+
+
+/* 근거 — 접힌 칩이 기본, 펼치면 목록 */
+.fcx-ai-evidence { margin-top: 6px; }
+.fcx-ai-evidence-chip {
+  border: 1px solid var(--fcx-border, #d4dde7); background: var(--fcx-surface, #fff);
+  border-radius: 999px; padding: 2px 10px; font-size: 12px; cursor: pointer;
+  color: var(--fcx-muted, #5b6b7d);
+}
+.fcx-ai-evidence-chip::after { content: " ⌄"; }
+.fcx-ai-evidence-chip[aria-pressed="true"]::after { content: " ⌃"; }
+.fcx-ai-evidence-list { margin-top: 6px; display: grid; gap: 4px; }
+.fcx-ai-evidence-item {
+  font-size: 12px; color: var(--fcx-muted, #5b6b7d);
+  padding-left: 10px; border-left: 2px solid var(--fcx-border, #d4dde7);
+}
+
+/* 고지 — 상시, 그러나 조용하게 */
+.fcx-ai-disclaimer { margin-top: 8px; font-size: 11px; color: var(--fcx-muted, #5b6b7d); }
+
+[data-fcx-theme="dark"] .fcx-ai-evidence-chip { background: var(--fcx-surface, #10182a); border-color: var(--fcx-border, #24344d); }
+[data-fcx-theme="dark"] .fcx-ai-evidence-item { border-left-color: var(--fcx-border, #24344d); }
+
+
+/* 싫어요 사유 (0.7.0) — 1클릭 판단 뒤의 **선택** 단계. 강제하지 않는다. */
+.fcx-fb-why { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-top: 6px; }
+.fcx-fb-why-label { color: var(--fcx-muted, #5b6b7d); font-size: 12px; }
+.fcx-fb-reason, .fcx-fb-skip {
+  border: 1px solid var(--fcx-border, #d4dde7); background: var(--fcx-surface, #fff);
+  border-radius: 999px; padding: 2px 9px; font-size: 12px; cursor: pointer;
+  color: var(--fcx-text, #1c2733); transition: background-color 140ms ease, border-color 140ms ease;
+  white-space: nowrap; flex: 0 0 auto;
+}
+
+/* 기타 = 자유 입력 (2026-08-27 사용자 지적: "기타"만으로는 싫어요의 의미를
+   알 수 없다). 사유 코드는 other 로 남고, 적은 문장은 note 로 함께 간다. */
+.fcx-fb-note { display: flex; gap: 6px; align-items: center; width: 100%; margin-top: 6px; }
+.fcx-fb-note-input {
+  flex: 1 1 auto; min-width: 0;
+  border: 1px solid var(--fcx-border, #d4dde7); border-radius: 6px;
+  padding: 4px 8px; font-size: 12px; color: var(--fcx-text, #1c2733);
+  background: var(--fcx-surface, #fff);
+}
+.fcx-fb-note-send {
+  flex: 0 0 auto; white-space: nowrap;
+  border: 1px solid var(--fcx-brand-border, #d4dde7); background: var(--fcx-surface, #fff);
+  border-radius: 6px; padding: 4px 10px; font-size: 12px; cursor: pointer;
+  color: var(--fcx-brand, #1c2733);
+}
+.fcx-fb-reason:hover { background: var(--fcx-danger-bg, #fdecea); border-color: var(--fcx-danger, #b42318); }
+.fcx-fb-skip { color: var(--fcx-muted, #5b6b7d); border-style: dashed; }
+
+[data-fcx-theme="dark"] .fcx-fb-reason, [data-fcx-theme="dark"] .fcx-fb-skip {
+  background: var(--fcx-surface, #10182a); border-color: var(--fcx-border, #24344d); color: var(--fcx-text, #dbe6f3);
+}

package/view.d.ts

@@ -69,3 +69,18 @@ export declare function actionOffersView(input: {
 }): { visible: boolean; items: ActionOfferItemView[]; disabledHint: string };
 /** action: "confirm" | "execute" | "cancel" | "resend" | "ack" — 텍스트 노드만 */
 export declare function actionOffersTree(input: Parameters<typeof actionOffersView>[0]): AiSuggestNode | null;
+
+// ── 좋아요/싫어요 (0.7.0) ────────────────────────────────────────────────
+export declare const FB_CLS: {
+  root: string; label: string; up: string; down: string; done: string;
+};
+export declare function feedbackBarView(input: {
+  answerId?: string | number | null;
+  voted?: "up" | "down" | null;
+  messages?: Record<string, string>;
+}): {
+  label: string; upLabel: string; downLabel: string; doneText: string;
+  voted: "up" | "down" | null;
+} | null;
+/** action: "up" | "down" — 어댑터가 자기 이벤트로 배선한다 */
+export declare function feedbackBarTree(input: Parameters<typeof feedbackBarView>[0]): AiSuggestNode | null;

package/view.js

@@ -29,10 +29,18 @@ export function aiSuggestView({ state, result, declineText, messages = {} }) {
     body = {
       kind: "answer",
       text: result.answer || "",
-      // 근거 제목이 없으면 키로 대신한다 — 빈 칩을 그리지 않는다.
+      /*
+       * 근거는 **구조로** 낸다 (0.7.0). 예전엔 제목을 이어붙인 문자열 하나라
+       * 소비처가 칩·목록·원문의 3단 접기를 만들 수 없었다 — 화면이 근거를
+       * 아예 안 그리는 실질적 원인이었다. 키는 남긴다(클릭 시 원문 조회용).
+       */
       evidence: (result.evidence || [])
-        .map((e) => e.title || e.unit_key)
-        .filter(Boolean),
+        .map((e) => ({
+          key: e.unit_key || "",
+          title: e.title || e.unit_key || "",
+          score: typeof e.score === "number" ? e.score : null,
+        }))
+        .filter((e) => e.title),
       evidenceLabel: messages.ui_evidence,
     };
   } else if (done) {
@@ -44,6 +52,10 @@ export function aiSuggestView({ state, result, declineText, messages = {} }) {
     buttonDisabled: loading,
     showAdopt: answered,
     adoptLabel: messages.ui_adopt,
+    // AI 산출물의 상시 표식 — Carbon 의 AI label 자리(장식 아님, 설명의 문).
+    aiLabel: messages.ui_ai_label,
+    // "확인 후 전송" 상시 고지 — Cloudscape 의 disclaimer 블록 자리.
+    disclaimer: answered ? messages.ui_ai_disclaimer : "",
     body,
   };
 }
@@ -51,11 +63,16 @@ export function aiSuggestView({ state, result, declineText, messages = {} }) {
 export const CLS = {
   root: "fcx-ai",
   head: "fcx-ai-head",
+  label: "fcx-ai-label",
   button: "fcx-ai-button",
   adopt: "fcx-ai-adopt",
   body: "fcx-ai-body",
   answer: "fcx-ai-answer",
   evidence: "fcx-ai-evidence",
+  evidenceChip: "fcx-ai-evidence-chip",
+  evidenceList: "fcx-ai-evidence-list",
+  evidenceItem: "fcx-ai-evidence-item",
+  disclaimer: "fcx-ai-disclaimer",
   declined: "fcx-ai-declined",
 };
 
@@ -75,11 +92,19 @@ export const CLS = {
  */
 export function aiSuggestTree(input) {
   const v = aiSuggestView(input);
+  const expanded = Boolean(input && input.expanded);
+  // 소비처가 요청 버튼을 자기 화면에 따로 뒀는가 (그러면 카드 안 버튼은 잉여다)
+  const ownRequestButton = Boolean(input && input.ownRequestButton);
   const head = {
     tag: "div", cls: CLS.head,
     children: [
-      { tag: "button", cls: CLS.button, type: "button",
-        disabled: v.buttonDisabled, text: v.buttonLabel, action: "request" },
+      // AI 산출물의 상시 표식 — 답변이 있을 때만(빈 카드에 라벨을 달지 않는다)
+      ...(v.body.kind === "answer" && v.aiLabel
+        ? [{ tag: "span", cls: CLS.label, text: v.aiLabel }] : []),
+      ...(ownRequestButton ? [] : [{
+        tag: "button", cls: CLS.button, type: "button",
+        disabled: v.buttonDisabled, text: v.buttonLabel, action: "request",
+      }]),
       ...(v.showAdopt
         ? [{ tag: "button", cls: CLS.adopt, type: "button",
              disabled: false, text: v.adoptLabel, action: "adopt" }]
@@ -88,19 +113,46 @@ export function aiSuggestTree(input) {
   };
   const children = [head];
   if (v.body.kind === "answer") {
+    /*
+     * 근거는 3단으로 접는다 (0.7.0, 관행 조사 반영): 칩("근거 N") → 목록 →
+     * (소비처가 원하면) 원문. 기본은 접힘 — 상담사가 읽는 것은 답변이지
+     * 출처 목록이 아니다. 펼침 상태는 어댑터가 `expanded` 로 준다.
+     */
+    const ev = v.body.evidence;
+    const evNodes = ev.length > 0
+      ? [{
+          tag: "div", cls: CLS.evidence,
+          children: [
+            { tag: "button", cls: CLS.evidenceChip, type: "button",
+              text: `${v.body.evidenceLabel} ${ev.length}`, action: "evidence",
+              pressed: Boolean(expanded) },
+            ...(expanded
+              ? [{ tag: "div", cls: CLS.evidenceList,
+                   children: ev.map((e) => ({
+                     tag: "div", cls: CLS.evidenceItem, text: e.title,
+                   })) }]
+              : []),
+          ],
+        }]
+      : [];
     children.push({
       tag: "div", cls: CLS.body,
       children: [
         { tag: "div", cls: CLS.answer, text: v.body.text },
-        ...(v.body.evidence.length > 0
-          ? [{ tag: "div", cls: CLS.evidence,
-               text: `${v.body.evidenceLabel}: ${v.body.evidence.join(" · ")}` }]
-          : []),
+        ...evNodes,
+        ...(v.disclaimer ? [{ tag: "div", cls: CLS.disclaimer, text: v.disclaimer }] : []),
       ],
     });
   } else if (v.body.kind === "declined") {
     children.push({ tag: "div", cls: CLS.declined, text: v.body.text });
   }
+  /*
+   * 요청 버튼을 소비처가 자기 화면에 따로 두면(`ownRequestButton`), 초안이 없는
+   * 동안 이 카드는 **테두리·여백만 남은 빈 상자**가 된다 — 2026-08-27 실사고:
+   * CSS 로 버튼만 숨겼더니 화면에 빈 카드가 떠 있었다. 그때는 아예 그리지 않는다.
+   * SDK 는 소비처의 CSS 를 모르므로 **소비처가 선언**한다(추론 금지).
+   */
+  if (ownRequestButton && v.body.kind === "none") return null;
   return { tag: "div", cls: CLS.root, children };
 }
 
@@ -126,6 +178,10 @@ export const ACTION_CLS = {
   button: "fcx-act-button",
   confirm: "fcx-act-confirm",
   confirmText: "fcx-act-confirm-text",
+  verify: "fcx-act-verify",
+  verifyTitle: "fcx-act-verify-title",
+  verifyLine: "fcx-act-verify-line",
+  verifyStatus: "fcx-act-verify-status",
   ack: "fcx-act-ack",
   status: "fcx-act-status",
   locked: "fcx-act-locked",
@@ -148,9 +204,10 @@ function fmtWhen(iso) {
  * @param {Array} pending session.pendingActions()  [{requestId, offerId, state, reasonCode, message, label, unreported}]
  * @param {boolean} enabled  agent.actionsEnabled
  * @param {string|null} confirming  확인 패널이 열린 offer_id
+ * @param {Record<string,object>} verifies  session.actionVerifies() — offer_id → 대상 확정 상태 (T2.7)
  * @param {Record<string,string>} messages
  */
-export function actionOffersView({ offers = [], pending = [], enabled = true, confirming = null, messages = {} }) {
+export function actionOffersView({ offers = [], pending = [], enabled = true, confirming = null, verifies = {}, messages = {} }) {
   const byOffer = new Map();
   for (const p of pending) byOffer.set(p.offerId, p);
   const items = offers.map((o) => {
@@ -168,6 +225,16 @@ export function actionOffersView({ offers = [], pending = [], enabled = true, co
     // success_copy 는 실행이 실제로 성공한 뒤에만 — 절차 자산의 "실행 성공 후 문구"
     // (실행 전 카드·답변에 실으면 완료 사칭이 된다. 서버도 같은 이유로 승인 게이트를 둔다.)
     const successCopy = state === "succeeded" ? String(o.success_copy || "") : "";
+    const needsVerify = Boolean(o.verify);
+    const vr = needsVerify ? (verifies[o.offer_id] || null) : null;
+    const verifyState = !needsVerify ? "" : (vr ? vr.state : "none");
+    let verifyText = "";
+    if (needsVerify && (verifyState === "none" || verifyState === "loading")) {
+      verifyText = messages.ui_action_verify_loading;
+    } else if (verifyState === "blocked") {
+      verifyText = (vr && vr.denyCopy)
+        || (vr && vr.reasonCode === "precondition_failed" ? messages.ui_action_verify_blocked : messages.ui_action_verify_failed);
+    }
     let lockedText = "";
     if (locked) {
       const who = o.lock && o.lock.actorClaimed ? ` · ${o.lock.actorClaimed}` : "";
@@ -184,6 +251,12 @@ export function actionOffersView({ offers = [], pending = [], enabled = true, co
       buttonLabel: messages.ui_action_execute,
       confirming: confirming === o.offer_id,
       confirmText: o.confirm || messages.ui_action_confirm_default,
+      // 대상 확정 (T2.7) — verify 동봉 offer 는 읽기 확인이 ok 여야 실행 버튼이 나온다 (위험도 무관)
+      needsVerify,
+      verifyOk: !needsVerify || verifyState === "ok",
+      verifyTitle: messages.ui_action_verify_title,
+      verifyLines: vr && Array.isArray(vr.display) ? vr.display.map((f) => `${f.label}: ${f.value}`) : [],
+      verifyText,
       needsAck: o.risk_level === "high",
       ackLabel: messages.ui_action_ack,
       okLabel: messages.ui_action_confirm_ok,
@@ -218,9 +291,17 @@ export function actionOffersTree(input) {
       children.push({
         tag: "div", cls: ACTION_CLS.confirm, children: [
           { tag: "div", cls: ACTION_CLS.confirmText, text: it.confirmText },
+          // 대상 확인 블록 (T2.7) — 읽기 결과를 상담사 눈으로 확인한 뒤에만 실행 버튼이 나온다
+          ...(it.needsVerify ? [{
+            tag: "div", cls: ACTION_CLS.verify, children: [
+              { tag: "div", cls: ACTION_CLS.verifyTitle, text: it.verifyTitle },
+              ...it.verifyLines.map((t) => ({ tag: "div", cls: ACTION_CLS.verifyLine, text: t })),
+              ...(it.verifyText ? [{ tag: "div", cls: ACTION_CLS.verifyStatus, text: it.verifyText, live: true }] : []),
+            ],
+          }] : []),
           // 고위험 2단 확인 — 토글 **버튼**(aria-pressed): 포커스·Space/Enter 가 되어야 키보드 사용자도 실행할 수 있다
           ...(it.needsAck ? [{ tag: "button", type: "button", cls: ACTION_CLS.ack, text: it.ackLabel, action: "ack", offerId: it.offerId, pressed: true }] : []),
-          { tag: "button", cls: ACTION_CLS.button, type: "button", text: it.okLabel, action: "execute", offerId: it.offerId },
+          ...(it.verifyOk ? [{ tag: "button", cls: ACTION_CLS.button, type: "button", text: it.okLabel, action: "execute", offerId: it.offerId }] : []),
           { tag: "button", cls: ACTION_CLS.button, type: "button", text: it.cancelLabel, action: "cancel", offerId: it.offerId },
         ],
       });
@@ -237,3 +318,104 @@ export function actionOffersTree(input) {
   if (v.disabledHint) items.push({ tag: "div", cls: ACTION_CLS.status, text: v.disabledHint });
   return { tag: "div", cls: ACTION_CLS.root, children: items };
 }
+
+// ── 좋아요/싫어요 (0.7.0) — 상담사의 명시적 품질 판단 ─────────────────────
+//
+// 왜 라이브러리에 있나: 이 판단이 절차별 서빙 웨이트·재학습 라벨의 원료다
+// (북극성 "상담사의 매일의 판단이 곧 라벨"). 신호는 기존 scored 5|1 —
+// 새 action·프로토콜 없음. 비소모라 발송 전 판단 변경 가능하고, 집계는
+// 같은 응답 최신본 우선이라 마지막 판단이 이긴다.
+
+export const FB_CLS = {
+  root: "fcx-fb",
+  label: "fcx-fb-label",
+  up: "fcx-fb-up",
+  down: "fcx-fb-down",
+  done: "fcx-fb-done",
+  why: "fcx-fb-why",
+  whyLabel: "fcx-fb-why-label",
+  reason: "fcx-fb-reason",
+  skip: "fcx-fb-skip",
+  note: "fcx-fb-note",
+  noteInput: "fcx-fb-note-input",
+  noteSend: "fcx-fb-note-send",
+};
+
+/** 무엇을 그릴지 — 초안(answerId)이 없으면 판단 대상이 없다(null). */
+/** 기각 사유 코드 — 서버 enum(0057)과 같은 키. 값 판정은 서버가 한다. */
+export const FB_REASONS = [
+  "wrong_manual", "factual_error", "missing_answer",
+  "stale_period", "tone_style", "policy_risk", "other",
+];
+
+export function feedbackBarView({ answerId, voted, asking, noting, messages = {} }) {
+  if (!answerId) return null;
+  const v = voted === "up" || voted === "down" ? voted : null;
+  return {
+    label: messages.ui_feedback_ask,
+    upLabel: messages.ui_feedback_up,
+    downLabel: messages.ui_feedback_down,
+    doneText: v ? messages.ui_feedback_done : "",
+    voted: v,
+    /*
+     * 싫어요 뒤에만 사유를 묻는다 (0.7.0). 1클릭이 기본이고 사유는 선택 —
+     * 관행(Open WebUI RateComment·Claude·Zendesk)이 공통으로 그렇고, 강제하면
+     * 상담사가 싫어요 자체를 안 누른다(신호가 통째로 사라진다).
+     */
+    asking: Boolean(asking) && v === "down",
+    /*
+     * 「기타」는 코드만으로는 뜻이 없다 — 무엇이 문제였는지 못 읽으면 그 신호는
+     * 집계 숫자로만 남고 개선에 못 쓴다(2026-08-27 사용자 지적). 그래서 기타를
+     * 고르면 한 줄 적는 칸이 열린다: 코드는 other, 문장은 note 로 함께 간다.
+     */
+    noting: Boolean(noting) && v === "down",
+    whyLabel: messages.ui_feedback_why,
+    skipLabel: messages.ui_feedback_skip,
+    notePlaceholder: messages.ui_feedback_note_hint,
+    noteSendLabel: messages.ui_feedback_note_send,
+    reasons: FB_REASONS.map((code) => ({ code, label: messages[`reason_${code}`] || code })),
+  };
+}
+
+/** 트리 스펙 — 어댑터가 action "up"/"down" 을 자기 이벤트로 배선한다. */
+export function feedbackBarTree(input) {
+  const v = feedbackBarView(input);
+  if (!v) return null;
+  return {
+    tag: "div", cls: FB_CLS.root,
+    children: [
+      { tag: "span", cls: FB_CLS.label, text: v.label },
+      { tag: "button", cls: FB_CLS.up, type: "button",
+        text: v.upLabel, action: "up", pressed: v.voted === "up" },
+      { tag: "button", cls: FB_CLS.down, type: "button",
+        text: v.downLabel, action: "down", pressed: v.voted === "down" },
+      ...(v.doneText && !v.asking
+        ? [{ tag: "span", cls: FB_CLS.done, text: v.doneText, live: true }]
+        : []),
+      ...(v.noting
+        ? [{
+            tag: "div", cls: FB_CLS.note,
+            children: [
+              { tag: "input", cls: FB_CLS.noteInput, action: "note",
+                placeholder: v.notePlaceholder },
+              { tag: "button", cls: FB_CLS.noteSend, type: "button",
+                text: v.noteSendLabel, action: "noteSend" },
+            ],
+          }]
+        : []),
+      ...(v.asking && !v.noting
+        ? [{
+            tag: "div", cls: FB_CLS.why,
+            children: [
+              { tag: "span", cls: FB_CLS.whyLabel, text: v.whyLabel },
+              ...v.reasons.map((r) => ({
+                tag: "button", cls: FB_CLS.reason, type: "button",
+                text: r.label, action: "reason", reason: r.code,
+              })),
+              { tag: "button", cls: FB_CLS.skip, type: "button", text: v.skipLabel, action: "skip" },
+            ],
+          }]
+        : []),
+    ],
+  };
+}

package/vue.js

@@ -147,7 +147,12 @@ export const ActionOffersPanel = defineComponent({
       emit("result", r);
     };
     const actions = {
-      confirm: (e) => { confirming.value = e.currentTarget.dataset.offer || null; ackedOffer.value = null; },
+      confirm: (e) => {
+        const id = e.currentTarget.dataset.offer || null;
+        confirming.value = id; ackedOffer.value = null;
+        const offer = offers.value.find((o) => o.offer_id === id);
+        if (offer && offer.verify && typeof props.session.verifyAction === "function") props.session.verifyAction(offer); // T2.7
+      },
       cancel: () => { confirming.value = null; ackedOffer.value = null; },
       ack: (e) => { const id = e.currentTarget.dataset.offer; ackedOffer.value = ackedOffer.value === id ? null : id; },
       execute: (e) => execute(e.currentTarget.dataset.offer),
@@ -155,7 +160,9 @@ export const ActionOffersPanel = defineComponent({
     };
     const tree = computed(() => actionOffersTree({
       offers: offers.value, pending: pending.value, enabled: Boolean(props.agent && props.agent.actionsEnabled),
-      confirming: confirming.value, messages: props.agent ? props.agent.messages : {},
+      confirming: confirming.value,
+      verifies: props.session && typeof props.session.actionVerifies === "function" ? props.session.actionVerifies() : {},
+      messages: props.agent ? props.agent.messages : {},
     }));
     const render = (node) => {
       const p = { class: node.cls };