refs #708: report configured Smilegate Select AI profile

.env.example

@@ -43,8 +43,7 @@ export BACKOFFICE_SESSION_COOKIE_SECURE="false"
 export BACKOFFICE_REMEMBER_ME_ENABLED="false"
 export BACKOFFICE_REMEMBER_ME_KEY=""
 export BACKOFFICE_REMEMBER_ME_DAYS="14"
-# HMM HR 질의는 HMM MCP/DBMS_CLOUD_AI_AGENT를 사용합니다. 기존 ORDS 운영 기능이 필요할 때만 설정합니다.
-export BACKOFFICE_ORDS_BASE_URL=""
+export BACKOFFICE_ORDS_BASE_URL="https://yh0olybn5pqce4n-d8aukro81636mon0.adb.ap-seoul-1.oraclecloudapps.com/ords"
 export BACKOFFICE_ORDS_TIMEOUT_SECONDS="10"
 # ORDS metadata 생성/수정 전용 계정. 비워두면 BACKOFFICE_DB_* 연결을 사용하므로
 # ADMIN으로 실행 중이면 Handler 생성은 막히고 소스 보기만 사용합니다.
@@ -52,47 +51,12 @@ export BACKOFFICE_ORDS_DB_URL="${BACKOFFICE_DB_URL}"
 export BACKOFFICE_ORDS_DB_USERNAME="CB_ORDS"
 export BACKOFFICE_ORDS_DB_PASSWORD=""
 
-# Select AI는 프로파일 소유 스키마로 별도 접속합니다.
+# Smilegate Select AI는 프로파일 소유 스키마(SGMP_POC)로 별도 접속합니다.
 # 원문 비밀번호는 .env 또는 배포 환경 secret에만 두며 Git에 올리지 않습니다.
 export BACKOFFICE_SELECT_AI_DB_URL="${BACKOFFICE_DB_URL}"
-export BACKOFFICE_SELECT_AI_DB_USERNAME=""
+export BACKOFFICE_SELECT_AI_DB_USERNAME="SGMP_POC"
 export BACKOFFICE_SELECT_AI_DB_PASSWORD=""
-export BACKOFFICE_SELECT_AI_PROFILE=""
-export BACKOFFICE_SELECT_AI_FEW_SHOT_ENABLED="true"
-export BACKOFFICE_SELECT_AI_FEW_SHOT_TOP_K="3"
-# Customer-owned DB view: game aliases, approved profile objects, and valid DB objects.
-export BACKOFFICE_GAME_SCOPE_ENABLED="false"
-export BACKOFFICE_GAME_SCOPE_VIEW=""
-export BACKOFFICE_GAME_SCOPE_MAX_SCOPES="8"
-
-# 공통 데이터 카탈로그. objects는 key/tableName/objectType/businessName/description JSON 배열입니다.
-# 배포 환경마다 반드시 실제 소유자와 허용 객체를 지정합니다.
-export BACKOFFICE_CATALOG_OWNER="APP_OWNER"
-export BACKOFFICE_CATALOG_OBJECTS='[{"key":"customers","tableName":"CUSTOMER","objectType":"TABLE","businessName":"고객","description":"고객 기본 정보"}]'
-export BACKOFFICE_PRODUCT_NAME="Data & AI Backoffice"
-export BACKOFFICE_PRODUCT_TITLE="Data & AI Backoffice"
-export BACKOFFICE_PRODUCT_DATA_LABEL="업무 데이터"
-export BACKOFFICE_MCP_TOOL_NAME="oracle.select_ai.data_text2sql"
-export BACKOFFICE_MCP_TOOL_LABEL="업무 데이터 Text2SQL"
-export BACKOFFICE_MCP_TOOL_DESCRIPTION="승인된 업무 데이터에 대해 읽기 전용 SQL을 생성하고 실행합니다."
-export BACKOFFICE_MCP_PROMPT_DESCRIPTION="업무 데이터에서 조회할 내용을 자연어로 입력합니다."
-export BACKOFFICE_MCP_SHOWPROMPT_TOOL_NAME="oracle.select_ai.data_showprompt"
-export BACKOFFICE_MCP_SHOWPROMPT_TOOL_LABEL="업무 데이터 SHOWPROMPT"
-export BACKOFFICE_MCP_SHOWPROMPT_TOOL_DESCRIPTION="Select AI가 SQL 생성에 사용한 prompt를 조회하는 읽기 전용 진단 도구입니다."
-# Select AI few-shot 예제 SQL 조회·저장 MCP. 운영 환경은 고객별 도구명과 안내문만 변경합니다.
-export BACKOFFICE_MCP_QA_VECTOR_SEARCH_TOOL_NAME="oracle.select_ai.qa_vector_search"
-export BACKOFFICE_MCP_QA_VECTOR_SEARCH_TOOL_LABEL="Select AI 예제 SQL 조회"
-export BACKOFFICE_MCP_QA_VECTOR_SEARCH_TOOL_DESCRIPTION="현재 질문에 사용할 유사 예제 SQL을 Select AI 실행 전에 조회합니다."
-export BACKOFFICE_MCP_QA_VECTOR_STORE_TOOL_NAME="oracle.select_ai.qa_vector_store"
-export BACKOFFICE_MCP_QA_VECTOR_STORE_TOOL_LABEL="Select AI 예제 SQL 저장"
-export BACKOFFICE_MCP_QA_VECTOR_STORE_TOOL_DESCRIPTION="검토된 Select AI 결과를 후속 Text2SQL 품질 향상용 예제 SQL로 저장합니다."
-export BACKOFFICE_MCP_GAME_SCOPE_TOOL_NAME="oracle.select_ai.game_scope_resolve"
-export BACKOFFICE_MCP_GAME_SCOPE_TOOL_LABEL="게임 조회 범위 확인"
-export BACKOFFICE_MCP_GAME_SCOPE_TOOL_DESCRIPTION="질문의 게임 별칭을 DB 범위 view로 확인하고, SUPPORTED 결과에만 Few-shot NL2SQL을 호출하도록 안내합니다."
-# 마스킹 관리 대상. objectName/policyName JSON 배열이며, 비우면 어떤 DB 정책도 관리하지 않습니다.
-export BACKOFFICE_MASKING_POLICIES=''
-# 보안 SQL 화면에 노출할 번들 SQL. fileName은 패키지의 sql/adb/ 아래 파일명만 허용됩니다.
-export BACKOFFICE_SECURITY_SQL_SCRIPTS=''
+export BACKOFFICE_SELECT_AI_PROFILE="SGMP_POC_OCI_GPT54MINI"
 
 # --- (2c) OpenAI 호환 AI 호출 (MCP-style Reasoning 탭) ---
 export BACKOFFICE_AI_ENABLED="false"
@@ -113,7 +77,7 @@ export BACKOFFICE_AI_OCI_COMPARTMENT_ID=""
 export VPDTEST1_API_KEY=""
 export VPDTEST2_API_KEY=""
 
-# --- (3) 데모용 ADB 엔드유저 비밀번호 (database/adb/07_end_users.sql 에서 사용) ---
+# --- (3) 데모용 ADB 엔드유저 비밀번호 (sql/adb/07_end_users.sql 에서 사용) ---
 # ADB 비번 정책: 12자 이상, 대/소/숫자/특수 조합.
 # 4명의 데모 유저:
 #   vpduser_my   → MySQL view 만 SELECT 가능
@@ -126,7 +90,7 @@ export VPDUSER_BOTH_PASSWORD="RowFilter#Both26"
 export VPDUSER_NONE_PASSWORD="RowFilter#None26"
 
 # --- (3b) OPTIONAL — DDS 변형 데모용 엔드유저 비밀번호 ---
-# database/adb/13_dds_variant.sql (Oracle 26ai Deep Data Security 재구현) 에서만 사용.
+# sql/adb/13_dds_variant.sql (Oracle 26ai Deep Data Security 재구현) 에서만 사용.
 # 동일한 4-user 매트릭스를 declarative Data Grants 로 재현. VPD 데모와 공존.
 export DDSUSER_MY_PASSWORD="DdsGrant#My2026"
 export DDSUSER_PG_PASSWORD="DdsGrant#Pg2026"
@@ -147,7 +111,7 @@ export DDS_MCP_BASE_URL="http://127.0.0.1:8083"
 export DDS_MCP_TEST_BEARER=""           # 발급한 활성 CB_APP_USER Bearer만 로컬 테스트에 사용
 
 # --- (4) 원격 Postgres (AWS RDS, Cloud SQL, ...) ---
-# database/source/postgres_setup.sql 가 여기로 customers 테이블/seed 생성.
+# sql/source/postgres_setup.sql 가 여기로 customers 테이블/seed 생성.
 # ADB 의 RDS_POSTGRES_LINK 가 이 인스턴스를 가리킴.
 export PG_HOST=""                                                # 예: vpd-poc.xxxxx.ap-northeast-2.rds.amazonaws.com
 export PG_PORT="5432"

README.md

@@ -32,7 +32,7 @@ End-to-End 데모입니다.
 행 자체는 보여주되 특정 컬럼만 가리는 통제입니다. 예: 영업팀은 고객 행은 다 보지만
 `email` 컬럼은 항상 `NULL` 로 반환.
 
-* VPD 경로: 별도의 `DBMS_REDACT` 정책 (`database/adb/06a_redaction.sql`).
+* VPD 경로: 별도의 `DBMS_REDACT` 정책 (`sql/adb/06a_redaction.sql`).
 * DDS 경로: 데이터 그랜트 안에 `(ALL COLUMNS EXCEPT email)` 한 줄로 흡수.
 
 ### 3. 두 가지 구현 — VPD 와 DDS
@@ -59,21 +59,19 @@ DDS 변형의 능력 (멀티테넌트, OAuth2 federated identity, MAC 모드,
 
 ## 소스 위치와 Git 저장 기준
 
-현재 이 저장소에는 서로 독립적으로 빌드·실행되는 세 애플리케이션이 있다. 각 제품은
-최상위 폴더를 하나씩 사용하며 저장소 루트에 프레임워크 `src`를 두지 않는다.
+현재 이 저장소에는 **VPD 관리 백오피스**와 **PoC4 MCP AI Console 외피**가 함께 들어 있다.
+두 소스는 별도 Git repository가 아니라 같은 repository의 서로 다른 경로로 관리한다.
 
 | 구분 | 저장 위치 | 역할 |
 |---|---|---|
-| VPD/ASO/FGA 관리 백오피스 | `vpd-backoffice/` | Spring Boot 기반 데이터 접근 제어 관리 콘솔 |
-| VPD 백오피스 화면 | `vpd-backoffice/src/main/resources/templates/` | Thymeleaf 서버 렌더링 화면 |
-| VPD 백오피스 CSS/JS | `vpd-backoffice/src/main/resources/static/` | 화면 동작과 스타일 |
-| VPD/ASO/FGA/ORDS/Select AI SQL | `database/adb/` | ADB 적용·검증 SQL 스크립트 |
-| 원격 원장 seed/검증 SQL | `database/source/` | PostgreSQL·MySQL 가상 원장과 HMM 선사 실적 데이터 |
+| VPD/ASO/FGA 관리 백오피스 | `src/main/java/com/cloudhandson/vpdbackoffice/` | Spring Boot 기반 데이터 접근 제어 관리 콘솔 |
+| VPD 백오피스 화면 | `src/main/resources/templates/` | Thymeleaf 서버 렌더링 화면 |
+| VPD 백오피스 CSS/JS | `src/main/resources/static/` | 화면 동작과 스타일 |
+| VPD/ASO/FGA/ORDS/Select AI SQL | `sql/adb/` | ADB 적용·검증 SQL 스크립트 |
 | DDS 백오피스 | `dds-backoffice/` | VPD와 분리된 DDS 전용 Spring Boot 데모 |
-| AI Web Agent Console | `ai-web-agent-console/` | Streamlit 기반 MCP 업무 에이전트 콘솔 |
-| AI Web Agent Console 진입점 | `ai-web-agent-console/app.py` | MCP discovery, 도구 호출, 답변 합성, 감사 증적 표시 |
-| AI Web Agent Console 패키지 | `ai-web-agent-console/ai_web_agent_console/` | 인증, 화면, MCP, 모델과 질의 계약 모듈 |
-| AI Web Agent Console 설정 | `ai-web-agent-console/config/` | 제품, MCP, 모델, 데모 사용자와 질문 JSON |
+| Streamlit 외피 / PoC4 MCP AI Console | `poc4_active_source_20260714/` | ReAct-style로 MCP tool을 호출하는 PoC4 데모 소스 snapshot |
+| Streamlit 외피 메인 화면 | `poc4_active_source_20260714/apps/poc4/mcp_discovery_ui.py` | MCP discovery, tool routing, ReAct-style agent loop, FGA evidence 표시 |
+| Streamlit 외피 MCP 설정 | `poc4_active_source_20260714/config/mcp_servers.json` | `kb_mcp`, `kb_vector_mcp` endpoint와 allowlist |
 
 Git 기준은 다음과 같다.
 
@@ -82,12 +80,14 @@ Git 기준은 다음과 같다.
 | 로컬 작업 디렉터리 | `/home/opc/workspaces/vpd-permission-poc-20260628213409` |
 | 운영 기준 remote | `gitea` |
 | 운영 기준 repository | `https://gittea.cloud-handson.com/joungmin/vpd-permission-poc.git` |
-| HMM 기준 branch | `hmm-backoffice` |
+| 기준 branch | `main` |
+| 보조 remote | `origin` = `https://github.com/devmrko/vpd-permission-poc.git` |
 
 주의:
 
-- HMM 운영·현행화 기준은 Gitea의 `hmm-backoffice` 브랜치다.
-- 날짜 스냅샷과 PoC 번호는 현재 소스 경로로 사용하지 않는다.
+- 현재 운영·현행화 기준은 `gitea/main`이다.
+- `origin/main`은 보조 remote이며, 이 작업공간의 `main`이 `origin/main`보다 앞서 있을 수 있다.
+- `poc4_active_source_20260714/`는 배포 VM의 PoC4 활성 소스를 가져온 snapshot이다. 원본은 배포 VM의 `/home/opc/poc_4/` 계열 경로에서 운영되었고, 저장소에는 비밀정보 없이 소스와 설정 sample만 보관한다.
 - 실제 DB password, wallet password, Bearer token, AI key, 대화 SQLite DB는 Git에 넣지 않는다.
 
 ---
@@ -97,7 +97,6 @@ Git 기준은 다음과 같다.
 | 계층 | 객체 | 역할 |
 |---|---|---|
 | 원격 | `public.customers` (PG), `ecommerce_poc.customers` (MySQL) | 원본 데이터 |
-| 원격 HMM 데모 | `hmm_demo.carriers`, `hmm_demo.carrier_monthly_performance` (PG) | 가상 선사 기준정보와 최근 18개월 월간 KPI |
 | ADB - 연결 | `RDS_POSTGRES_LINK`, `RDS_LINK` | `DBMS_CLOUD_ADMIN.CREATE_DATABASE_LINK` 로 만든 heterogeneous DB Link |
 | ADB - 매핑 | `app_customer`, `app_user`, `app_group`, `user_group`, `db_source`, `permission` | 누가 어느 소스의 어느 region 을 볼 수 있는지 |
 | ADB - 컨텍스트 | `vpd_ctx` (Secure Application Context) + `ctx_pkg` | 로그인 시 권한을 세션 컨텍스트로 로딩 |
@@ -110,7 +109,7 @@ Git 기준은 다음과 같다.
 ## 빠른 시작 (One-Click)
 
 ```bash
-git clone --branch hmm-backoffice https://gittea.cloud-handson.com/joungmin/vpd-permission-poc.git
+git clone https://github.com/<you>/vpd-permission-poc.git
 cd vpd-permission-poc
 
 # 1) 환경값 채우기
@@ -168,7 +167,7 @@ $EDITOR .env
 
 ## 데모 시나리오 — 2×2 source access matrix
 
-`database/adb/03_seed.sql` 의 매핑 (4 유저, 4 케이스):
+`sql/adb/03_seed.sql` 의 매핑 (4 유저, 4 케이스):
 
 | DB 유저 | 그룹 | PG 뷰 | MySQL 뷰 | VPD 결과 |
 |---|---|---|---|---|
@@ -186,7 +185,7 @@ $EDITOR .env
   (`1=0` predicate) — **deny by default**.
 * 누구든 원본 테이블 직접 접근 시도 (`@RDS_POSTGRES_LINK` 등) → 권한 없음.
 
-`database/adb/08_tests_user_my.sql` 가 우회 시도 5개 (원격 직접 SELECT, 컨텍스트
+`sql/adb/08_tests_user_my.sql` 가 우회 시도 5개 (원격 직접 SELECT, 컨텍스트
 스푸핑, DBMS_RLS 변경, 매핑 테이블 SELECT) 를 시도하고 모두 ORA-xxxxx 로 실패하는 것을
 보여줍니다. 09/10/11 은 각 유저의 expected 행 수를 가볍게 확인합니다.
 
@@ -198,7 +197,7 @@ $EDITOR .env
 
 ## DDS 설정 핵심
 
-DDS 변형을 직접 셋업할 때 알아야 하는 최소 단위. `database/adb/13_dds_variant.sql` 가 이
+DDS 변형을 직접 셋업할 때 알아야 하는 최소 단위. `sql/adb/13_dds_variant.sql` 가 이
 순서로 돌아가며, 행/컬럼 통제가 모두 **선언형 DDL 한 줄** 로 끝납니다.
 
 ### 사전 조건
@@ -258,23 +257,10 @@ CREATE DATA GRANT admin.alice_apac_grant
 .
 ├── run.sh                       # 원클릭 엔트리포인트
 ├── .env.example
-├── vpd-backoffice/              # Spring Boot VPD 관리 백오피스
-│   ├── pom.xml
-│   └── src/
-├── ai-web-agent-console/        # Streamlit MCP 업무 에이전트
-│   ├── app.py
-│   ├── ai_web_agent_console/
-│   ├── config/
-│   └── tests/
-├── dds-backoffice/              # DDS 전용 Spring Boot 백오피스
-├── deploy/                      # 애플리케이션별 배포 설정
-├── tests/                       # 저장소 폴더 경계와 경로 규칙 검증
 ├── scripts/lib/common.sh        # log/ok/warn/die + env 검증 헬퍼
-├── database/
+├── sql/
 │   ├── source/
 │   │   ├── postgres_setup.sql   # 원격 PG: customers + 12 rows
-│   │   ├── postgres_hmm_carrier_performance.sql        # 원격 PG: HMM 가상 선사 8개 + 월간 KPI 144 rows
-│   │   ├── postgres_hmm_carrier_performance_verify.sql # HMM 선사 실적 건수·패턴·제약·TLS·권한 검증
 │   │   └── mysql_setup.sql      # 원격 MySQL: customers + 12 rows
 │   └── adb/
 │       ├── 00_cleanup.sql       # 멱등 teardown

ai-web-agent-console/.env.example

@@ -1,48 +0,0 @@
-# AI Web Agent Console local/VM configuration example.
-# Copy to .env and keep real credentials out of Git.
-
-# MCP
-HMM_MCP_BEARER_TOKEN=
-AI_WEB_AGENT_CONSOLE_MCP_TIMEOUT_SECONDS=45
-
-# OCI Generative AI SDK
-OCI_AUTH_TYPE=config_file
-OCI_CONFIG_FILE=~/.oci/config
-OCI_PROFILE=DEFAULT
-OCI_GENAI_COMPARTMENT_ID=
-AI_WEB_AGENT_CONSOLE_MODEL_PROFILE=gpt54_mini_oci
-AI_WEB_AGENT_CONSOLE_COMPLEX_REASONING_MODEL_PROFILE=gpt54_mini_oci
-
-# Optional model route overrides
-# AI_WEB_AGENT_CONSOLE_LLM_GPT54_MINI_OCI_MODEL_ID=openai.gpt-5.4-mini
-# AI_WEB_AGENT_CONSOLE_LLM_GPT54_MINI_OCI_REGION=us-chicago-1
-# AI_WEB_AGENT_CONSOLE_LLM_GPT54_MINI_OCI_ENDPOINT=https://inference.generativeai.us-chicago-1.oci.oraclecloud.com
-
-# Login gateway. Generate PBKDF2 hash and random cookie secret outside Git.
-AI_WEB_AGENT_CONSOLE_LOGIN_USER=demo-admin
-AI_WEB_AGENT_CONSOLE_LOGIN_PASSWORD_PBKDF2=
-AI_WEB_AGENT_CONSOLE_LOGIN_COOKIE_SECRET=
-PORTAL_AUTH_BIND_ADDRESS=127.0.0.1
-PORTAL_AUTH_PORT=8621
-PORTAL_AUTH_SESSION_SECONDS=43200
-PORTAL_AUTH_REMEMBER_SECONDS=604800
-
-# Product display
-AGENT_CONSOLE_NAME=HMM AI 업무 에이전트
-AGENT_CONSOLE_SHORT_NAME=HMM
-AGENT_CONSOLE_PAGE_TITLE=HMM AI 업무 에이전트
-AGENT_CONSOLE_PRIMARY_COLOR=#004b87
-
-# Local conversation store
-AI_WEB_AGENT_CONSOLE_CHAT_DB_PATH=data/ai_web_agent_console_chat.sqlite3
-
-# Optional audit DB. Password and Wallet remain outside Git.
-AI_WEB_AGENT_CONSOLE_AUDIT_DB_ENV_FILE=.env
-AI_WEB_AGENT_CONSOLE_AUDIT_DB_USER=ADMIN
-AI_WEB_AGENT_CONSOLE_AUDIT_DB_PASSWORD=
-AI_WEB_AGENT_CONSOLE_AUDIT_DSN=
-AI_WEB_AGENT_CONSOLE_AUDIT_WALLET_DIR=
-AI_WEB_AGENT_CONSOLE_AUDIT_WALLET_PASSWORD=
-
-# Optional query contract override
-AI_WEB_AGENT_CONSOLE_QUERY_CONTRACTS_PATH=config/hmm_hr_query_contracts.json

ai-web-agent-console/README.md

@@ -1,57 +0,0 @@
-# AI Web Agent Console
-
-HMM 업무 데이터를 MCP 도구로 조회하고 OCI Generative AI로 답변을 구성하는 Streamlit
-애플리케이션이다. 과거 PoC 번호나 소스 추출 날짜는 애플리케이션 이름과 패키지 경계로
-사용하지 않는다.
-
-## 구조
-
-```text
-ai-web-agent-console/
-├── app.py                       Streamlit 실행 진입점
-├── ai_web_agent_console/        인증, 화면, MCP, 모델, 질의 계약 모듈
-├── config/                      제품·모델·MCP·시나리오 JSON
-├── tests/                       Python 회귀 테스트
-├── .env.example                 환경변수 예시
-└── requirements.txt
-```
-
-## 실행
-
-```bash
-cd ai-web-agent-console
-python3 -m venv .venv
-.venv/bin/pip install -r requirements.txt
-.venv/bin/streamlit run app.py --server.address 0.0.0.0 --server.port 8622
-```
-
-인증 게이트웨이는 같은 디렉토리에서 다음과 같이 실행한다.
-
-```bash
-.venv/bin/python -m ai_web_agent_console.auth_gateway
-```
-
-## 설정
-
-- `config/app_profile.json`: 제품명, 설명, 아이콘, 색상
-- `config/mcp_servers.json`: MCP endpoint와 허용 도구
-- `config/model_profiles.json`: OCI Generative AI 모델 profile
-- `config/vpd_token_presets.json`: 데모 사용자와 토큰 환경변수 매핑
-- `config/hmm_demo_scenarios.json`: 화면의 예제 질문
-- `config/hmm_hr_query_contracts.json`: 질의별 필수 근거와 계산·시간 규칙
-
-실제 토큰, DB 비밀번호, Wallet, OCI private key는 Git에 넣지 않는다. 데모 사용자 JSON은
-`HMM_MCP_BEARER_TOKEN` 같은 환경변수 이름만 참조한다.
-
-## 검증
-
-```bash
-python3 -m compileall -q app.py ai_web_agent_console tests
-python3 -m unittest discover -s tests -p 'test_*.py'
-```
-
-## 운영 호환성
-
-운영 서버의 물리 경로 `/opt/hmm-poc4`와 기존 SQLite 테이블명은 대화 이력과 서비스 전환
-호환을 위해 유지할 수 있다. Git 폴더, Python 패키지와 실행 명령은 이 문서의 새 이름만
-사용한다.

ai-web-agent-console/ai_web_agent_console/audit.py

@@ -1,190 +0,0 @@
-"""Reusable audit-tab renderer with data loaders supplied by the application."""
-
-from __future__ import annotations
-
-from typing import Any, Callable
-
-
-AuditInventoryLoader = Callable[[], list[dict[str, Any]]]
-AuditEventsLoader = Callable[[int, int, str, str], list[dict[str, Any]]]
-
-
-def render_hmm_audit_tab(
-    st: Any,
-    inventory_loader: AuditInventoryLoader,
-    events_loader: AuditEventsLoader,
-    error_type: type[Exception],
-) -> None:
-    """Render HMM access audit data without owning DB connection details."""
-
-    st.markdown(
-        '<div class="kb-section-title input" role="heading" aria-level="3">'
-        '감사로그 ( <strong>HMM 접근 관리</strong> )'
-        '</div>',
-        unsafe_allow_html=True,
-    )
-    st.markdown(
-        '<div class="kb-audit-lead">'
-        'HMM 백오피스의 사용자·그룹·역할·토큰·접근 정책 변경 이력을 시간순으로 확인합니다. '
-        '이벤트 유형과 처리 상태로 필터링해 운영 변경의 성공·실패를 추적할 수 있습니다.'
-        '</div>',
-        unsafe_allow_html=True,
-    )
-    try:
-        inventory = inventory_loader()
-    except error_type as exc:
-        st.error(str(exc))
-        return
-
-    event_types = tuple(
-        str(item.get("event_type") or "").strip()
-        for item in inventory
-        if str(item.get("event_type") or "").strip()
-    )
-    st.markdown('<div class="kb-audit-heading">조회 조건</div>', unsafe_allow_html=True)
-    with st.container(key="poc4_hmm_audit_filters"):
-        event_column, status_column = st.columns(2)
-        with event_column:
-            selected_event_type = st.selectbox(
-                "이벤트 유형",
-                options=("", *event_types),
-                format_func=lambda value: "전체 이벤트" if not value else value,
-                key="poc4_hmm_audit_event_filter",
-            )
-        with status_column:
-            selected_status = st.selectbox(
-                "처리 상태",
-                options=("", "SUCCESS", "FAILURE", "DENIED"),
-                format_func=lambda value: "전체 상태" if not value else value,
-                key="poc4_hmm_audit_status_filter",
-            )
-        days_column, limit_column, refresh_column = st.columns([1.5, 1, 0.8])
-        with days_column:
-            days = st.slider(
-                "조회 기간",
-                min_value=1,
-                max_value=90,
-                value=7,
-                format="%d일",
-                key="poc4_hmm_audit_days",
-            )
-        with limit_column:
-            row_limit = st.number_input(
-                "최대 건수",
-                min_value=10,
-                max_value=500,
-                value=100,
-                step=10,
-                key="poc4_hmm_audit_row_limit",
-            )
-        with refresh_column:
-            st.markdown('<div style="height: 28px"></div>', unsafe_allow_html=True)
-            if st.button(
-                "새로고침",
-                icon=":material/refresh:",
-                width="stretch",
-                key="poc4_hmm_audit_refresh",
-            ):
-                inventory_loader.clear()
-                events_loader.clear()
-                st.rerun()
-
-    try:
-        events = events_loader(
-            int(days), int(row_limit), selected_event_type, selected_status
-        )
-    except error_type as exc:
-        st.error(str(exc))
-        return
-
-    success_count = sum(
-        1 for item in events if str(item.get("status") or "").upper() == "SUCCESS"
-    )
-    with st.container(key="poc4_hmm_audit_metrics"):
-        type_metric, event_metric, success_metric, failure_metric = st.columns(4)
-        type_metric.metric("이벤트 유형", len(inventory))
-        event_metric.metric("조회 이벤트", len(events))
-        success_metric.metric("성공", success_count)
-        failure_metric.metric("실패·거부", len(events) - success_count)
-
-    st.markdown(
-        '<div class="kb-audit-heading">이벤트 유형 현황</div>'
-        f'<div class="kb-audit-caption">현재 기록된 이벤트 유형 {len(inventory)}개 · '
-        '유형별 누적 건수와 최근 발생 시각을 확인합니다.</div>',
-        unsafe_allow_html=True,
-    )
-    with st.container(key="poc4_hmm_audit_inventory_panel"):
-        with st.expander("감사 이벤트 유형", expanded=True):
-            if inventory:
-                st.dataframe(
-                    [
-                        {
-                            "이벤트 유형": str(item.get("event_type") or ""),
-                            "누적 건수": int(item.get("event_count") or 0),
-                            "최근 발생(KST)": str(item.get("latest_event_time") or ""),
-                        }
-                        for item in inventory
-                    ],
-                    column_config={
-                        "이벤트 유형": st.column_config.TextColumn(width="large"),
-                        "누적 건수": st.column_config.NumberColumn(width="small"),
-                        "최근 발생(KST)": st.column_config.TextColumn(width="medium"),
-                    },
-                    hide_index=True,
-                    width="stretch",
-                    height=min(360, 72 + 36 * len(inventory)),
-                )
-            else:
-                st.caption("아직 기록된 HMM 접근 관리 이벤트가 없습니다.")
-
-    st.markdown(
-        '<div class="kb-audit-heading">감사 이벤트</div>'
-        '<div class="kb-audit-caption">최신 이벤트부터 표시합니다. '
-        '처리 상태와 대상 식별자, 오류 메시지를 먼저 확인하세요.</div>',
-        unsafe_allow_html=True,
-    )
-    show_details = st.toggle(
-        "상세 메시지 표시",
-        value=True,
-        key="poc4_hmm_audit_show_details",
-    )
-    if not events:
-        st.info("선택한 조건에 해당하는 HMM 접근 관리 이벤트가 없습니다.")
-        return
-
-    display_rows: list[dict[str, Any]] = []
-    for event in events:
-        row: dict[str, Any] = {
-            "감사 ID": int(event.get("audit_id") or 0),
-            "발생시각(KST)": str(event.get("event_time") or ""),
-            "이벤트 유형": str(event.get("event_type") or ""),
-            "상태": str(event.get("status") or ""),
-            "토큰 Key ID": event.get("key_id"),
-            "대상 Object ID": event.get("object_id"),
-            "처리 행": event.get("row_count"),
-            "오류 코드": str(event.get("error_code") or ""),
-        }
-        if show_details:
-            row["메시지"] = str(event.get("message") or "")
-        display_rows.append(row)
-
-    column_config: dict[str, Any] = {
-        "감사 ID": st.column_config.NumberColumn(width="small"),
-        "발생시각(KST)": st.column_config.TextColumn(width="medium"),
-        "이벤트 유형": st.column_config.TextColumn(width="large"),
-        "상태": st.column_config.TextColumn(width="small"),
-        "토큰 Key ID": st.column_config.NumberColumn(width="small"),
-        "대상 Object ID": st.column_config.NumberColumn(width="small"),
-        "처리 행": st.column_config.NumberColumn(width="small"),
-        "오류 코드": st.column_config.TextColumn(width="medium"),
-    }
-    if show_details:
-        column_config["메시지"] = st.column_config.TextColumn(width="large")
-    with st.container(key="poc4_hmm_audit_event_panel"):
-        st.dataframe(
-            display_rows,
-            column_config=column_config,
-            hide_index=True,
-            width="stretch",
-            height=min(640, 104 + 38 * len(display_rows)),
-        )

ai-web-agent-console/ai_web_agent_console/auth_gateway.py

@@ -1,563 +0,0 @@
-"""Small localhost authentication service for the HMM Streamlit portal.
-
-Nginx owns the public security boundary.  This module validates the existing
-PBKDF2 login, issues a signed HttpOnly cookie, and answers Nginx auth_request
-subrequests.  Authentication values are never accepted from a URL.
-"""
-
-from __future__ import annotations
-
-import base64
-import binascii
-from collections import defaultdict, deque
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from http import HTTPStatus
-from http.cookies import SimpleCookie
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-import hashlib
-import hmac
-import html
-import json
-import logging
-import os
-import secrets
-import threading
-import time
-from typing import Deque
-from urllib.parse import parse_qs, urlsplit
-
-
-def _environment_value(*names: str, default: str = "") -> str:
-    for name in names:
-        value = os.environ.get(name)
-        if value is not None and value.strip():
-            return value.strip()
-    return default
-
-
-LOG = logging.getLogger("hmm_portal_auth")
-SESSION_COOKIE_NAME = "__Host-HMM_PORTAL_SESSION"
-CSRF_COOKIE_NAME = "__Host-HMM_LOGIN_CSRF"
-SESSION_TOKEN_VERSION = 2
-MAX_REQUEST_BYTES = 8_192
-MAX_FIELD_CHARS = 200
-
-
-@dataclass(frozen=True)
-class AuthConfig:
-    username: str
-    password_pbkdf2: str
-    cookie_secret: str
-    bind_address: str = "127.0.0.1"
-    port: int = 8621
-    session_seconds: int = 12 * 60 * 60
-    remember_seconds: int = 7 * 24 * 60 * 60
-    product_name: str = "HMM AI 업무 에이전트"
-    login_title: str = "HMM AI 업무 에이전트"
-    login_description: str = "사용자 인증 후 AI 업무 질의 기능을 이용할 수 있습니다."
-    login_footer: str = "승인된 사용자만 접속할 수 있습니다."
-    primary_color: str = "#004b87"
-
-    @classmethod
-    def from_environment(cls) -> "AuthConfig":
-        config = cls(
-            username=_environment_value(
-                "AI_WEB_AGENT_CONSOLE_LOGIN_USER", "POC4_LOGIN_USER"
-            ),
-            password_pbkdf2=_environment_value(
-                "AI_WEB_AGENT_CONSOLE_LOGIN_PASSWORD_PBKDF2",
-                "POC4_LOGIN_PASSWORD_PBKDF2",
-            ),
-            cookie_secret=_environment_value(
-                "AI_WEB_AGENT_CONSOLE_LOGIN_COOKIE_SECRET",
-                "POC4_LOGIN_COOKIE_SECRET",
-            ),
-            bind_address=os.environ.get(
-                "PORTAL_AUTH_BIND_ADDRESS", "127.0.0.1"
-            ).strip(),
-            port=int(os.environ.get("PORTAL_AUTH_PORT", "8621")),
-            session_seconds=int(
-                os.environ.get("PORTAL_AUTH_SESSION_SECONDS", str(12 * 60 * 60))
-            ),
-            remember_seconds=int(
-                os.environ.get(
-                    "PORTAL_AUTH_REMEMBER_SECONDS", str(7 * 24 * 60 * 60)
-                )
-            ),
-            product_name=os.environ.get(
-                "AGENT_CONSOLE_NAME", "HMM AI 업무 에이전트"
-            ).strip(),
-            login_title=os.environ.get(
-                "AGENT_CONSOLE_LOGIN_TITLE", "HMM AI 업무 에이전트"
-            ).strip(),
-            login_description=os.environ.get(
-                "AGENT_CONSOLE_LOGIN_DESCRIPTION",
-                "사용자 인증 후 AI 업무 질의 기능을 이용할 수 있습니다.",
-            ).strip(),
-            login_footer=os.environ.get(
-                "AGENT_CONSOLE_LOGIN_FOOTER",
-                "승인된 사용자만 접속할 수 있습니다.",
-            ).strip(),
-            primary_color=os.environ.get(
-                "AGENT_CONSOLE_PRIMARY_COLOR", "#004b87"
-            ).strip(),
-        )
-        config.validate()
-        return config
-
-    def validate(self) -> None:
-        if not self.username or not self.password_pbkdf2:
-            raise ValueError("AI web agent console login credentials are not configured")
-        if len(self.cookie_secret.encode("utf-8")) < 32:
-            raise ValueError(
-                "AI_WEB_AGENT_CONSOLE_LOGIN_COOKIE_SECRET must be at least 32 bytes"
-            )
-        if self.bind_address not in {"127.0.0.1", "::1"}:
-            raise ValueError("Portal authentication service must bind to loopback")
-        if not 1 <= self.port <= 65535:
-            raise ValueError("PORTAL_AUTH_PORT is invalid")
-        if not 300 <= self.session_seconds <= 24 * 60 * 60:
-            raise ValueError("PORTAL_AUTH_SESSION_SECONDS is outside the safe range")
-        if not self.session_seconds <= self.remember_seconds <= 30 * 24 * 60 * 60:
-            raise ValueError("PORTAL_AUTH_REMEMBER_SECONDS is outside the safe range")
-
-
-@dataclass(frozen=True)
-class AuthenticatedSession:
-    username: str
-    expires_at: int
-
-
-class SessionTokenCodec:
-    def __init__(self, secret: str):
-        self._secret = secret.encode("utf-8")
-
-    def issue(self, username: str, lifetime_seconds: int, now: int | None = None) -> str:
-        issued_at = int(time.time()) if now is None else now
-        payload = {
-            "v": SESSION_TOKEN_VERSION,
-            "u": username,
-            "i": issued_at,
-            "e": issued_at + lifetime_seconds,
-            "n": secrets.token_urlsafe(18),
-        }
-        encoded = _base64url_encode(
-            json.dumps(payload, separators=(",", ":")).encode("utf-8")
-        )
-        signature = hmac.new(
-            self._secret, encoded.encode("ascii"), hashlib.sha256
-        ).hexdigest()
-        return f"{encoded}.{signature}"
-
-    def verify(self, token: str, expected_username: str, now: int | None = None) -> AuthenticatedSession | None:
-        if not token or len(token) > 2048:
-            return None
-        current_time = int(time.time()) if now is None else now
-        try:
-            encoded, supplied_signature = token.split(".", 1)
-            expected_signature = hmac.new(
-                self._secret, encoded.encode("ascii"), hashlib.sha256
-            ).hexdigest()
-            if not hmac.compare_digest(supplied_signature, expected_signature):
-                return None
-            payload = json.loads(_base64url_decode(encoded).decode("utf-8"))
-            version = int(payload["v"])
-            username = str(payload["u"])
-            issued_at = int(payload["i"])
-            expires_at = int(payload["e"])
-        except (
-            binascii.Error,
-            KeyError,
-            TypeError,
-            ValueError,
-            UnicodeDecodeError,
-            json.JSONDecodeError,
-        ):
-            return None
-        if version != SESSION_TOKEN_VERSION:
-            return None
-        if issued_at > current_time + 30 or expires_at <= current_time:
-            return None
-        if expires_at - issued_at > 30 * 24 * 60 * 60:
-            return None
-        if not hmac.compare_digest(username, expected_username):
-            return None
-        return AuthenticatedSession(username=username, expires_at=expires_at)
-
-
-class LoginAttemptLimiter:
-    def __init__(self, maximum_failures: int = 5, window_seconds: int = 300):
-        self._maximum_failures = maximum_failures
-        self._window_seconds = window_seconds
-        self._failures: dict[str, Deque[float]] = defaultdict(deque)
-        self._lock = threading.Lock()
-
-    def blocked(self, key: str, now: float | None = None) -> bool:
-        current_time = time.monotonic() if now is None else now
-        with self._lock:
-            failures = self._failures[key]
-            self._prune(failures, current_time)
-            return len(failures) >= self._maximum_failures
-
-    def record_failure(self, key: str, now: float | None = None) -> None:
-        current_time = time.monotonic() if now is None else now
-        with self._lock:
-            failures = self._failures[key]
-            self._prune(failures, current_time)
-            failures.append(current_time)
-
-    def reset(self, key: str) -> None:
-        with self._lock:
-            self._failures.pop(key, None)
-
-    def _prune(self, failures: Deque[float], now: float) -> None:
-        cutoff = now - self._window_seconds
-        while failures and failures[0] < cutoff:
-            failures.popleft()
-
-
-def password_matches(password: str, encoded_password: str) -> bool:
-    try:
-        scheme, iterations_text, salt_hex, expected_hex = encoded_password.split(
-            "$", 3
-        )
-        iterations = int(iterations_text)
-        salt = bytes.fromhex(salt_hex)
-        expected = bytes.fromhex(expected_hex)
-    except (TypeError, ValueError):
-        return False
-    if scheme != "pbkdf2_sha256" or not 100_000 <= iterations <= 2_000_000:
-        return False
-    candidate = hashlib.pbkdf2_hmac(
-        "sha256", password.encode("utf-8"), salt, iterations
-    )
-    return hmac.compare_digest(candidate, expected)
-
-
-def session_cookie_header(token: str, max_age: int | None) -> str:
-    attributes = [
-        f"{SESSION_COOKIE_NAME}={token}",
-        "Path=/",
-        "Secure",
-        "HttpOnly",
-        "SameSite=Lax",
-    ]
-    if max_age is not None:
-        attributes.append(f"Max-Age={max_age}")
-    return "; ".join(attributes)
-
-
-def clear_session_cookie_header() -> str:
-    return (
-        f"{SESSION_COOKIE_NAME}=; Path=/; Max-Age=0; "
-        "Secure; HttpOnly; SameSite=Lax"
-    )
-
-
-def csrf_cookie_header(value: str, max_age: int = 600) -> str:
-    return (
-        f"{CSRF_COOKIE_NAME}={value}; Path=/; Max-Age={max_age}; "
-        "Secure; HttpOnly; SameSite=Strict"
-    )
-
-
-def clear_csrf_cookie_header() -> str:
-    return (
-        f"{CSRF_COOKIE_NAME}=; Path=/; Max-Age=0; "
-        "Secure; HttpOnly; SameSite=Strict"
-    )
-
-
-def _base64url_encode(value: bytes) -> str:
-    return base64.urlsafe_b64encode(value).decode("ascii").rstrip("=")
-
-
-def _base64url_decode(value: str) -> bytes:
-    padded = value + "=" * (-len(value) % 4)
-    return base64.urlsafe_b64decode(padded)
-
-
-def _cookie_value(cookie_header: str, name: str) -> str:
-    try:
-        cookies = SimpleCookie()
-        cookies.load(cookie_header)
-        morsel = cookies.get(name)
-        return morsel.value if morsel is not None else ""
-    except (KeyError, TypeError):
-        return ""
-
-
-def _login_page(config: AuthConfig, csrf_value: str, error: str = "") -> bytes:
-    error_html = (
-        f'<div class="error" role="alert">{html.escape(error)}</div>'
-        if error
-        else ""
-    )
-    return f"""<!doctype html>
-<html lang="ko">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <title>{html.escape(config.product_name)}</title>
-  <style>
-    :root {{ --primary:{html.escape(config.primary_color)}; --text:#17232d;
-      --muted:#60717f; --border:#d9e0e5; }}
-    * {{ box-sizing:border-box; }}
-    body {{ margin:0; background:#fff; color:var(--text);
-      font-family:"Noto Sans KR","Malgun Gothic",sans-serif; }}
-    main {{ width:min(420px,calc(100% - 40px)); margin:12vh auto 0; }}
-    .wordmark {{ color:var(--primary); font-size:1.25rem; font-weight:800;
-      letter-spacing:.08em; }}
-    h1 {{ margin:16px 0 8px; font-size:1.75rem; }}
-    .description,.footer {{ color:var(--muted); line-height:1.55; }}
-    form {{ margin-top:28px; }}
-    label {{ display:block; margin:0 0 18px; font-weight:700; }}
-    input[type="text"],input[type="password"] {{ width:100%; margin-top:8px;
-      padding:12px 13px; border:1px solid var(--border); border-radius:5px;
-      font:inherit; color:var(--text); background:#fff; }}
-    .remember {{ display:flex; align-items:center; gap:8px; font-weight:500; }}
-    .remember input {{ width:17px; height:17px; }}
-    button {{ width:100%; padding:12px; border:1px solid var(--primary);
-      border-radius:5px; background:var(--primary); color:#fff; font:inherit;
-      font-weight:800; cursor:pointer; }}
-    .error {{ margin:18px 0 0; padding:11px 12px; border:1px solid #d99898;
-      border-radius:5px; color:#8a2222; background:#fff7f7; }}
-    .footer {{ margin-top:22px; font-size:.9rem; }}
-  </style>
-</head>
-<body>
-<main>
-  <div class="wordmark">HMM</div>
-  <h1>{html.escape(config.login_title)}</h1>
-  <p class="description">{html.escape(config.login_description)}</p>
-  {error_html}
-  <form action="/auth/login" method="post" autocomplete="on">
-    <input type="hidden" name="csrf" value="{html.escape(csrf_value)}">
-    <label>사용자 ID
-      <input name="username" type="text" maxlength="80" autocomplete="username"
-        required autofocus>
-    </label>
-    <label>비밀번호
-      <input name="password" type="password" maxlength="200"
-        autocomplete="current-password" required>
-    </label>
-    <label class="remember">
-      <input name="remember" type="checkbox" value="yes"> 로그인 유지 (7일)
-    </label>
-    <button type="submit">로그인</button>
-  </form>
-  <p class="footer">{html.escape(config.login_footer)}</p>
-</main>
-</body>
-</html>""".encode("utf-8")
-
-
-def build_handler(config: AuthConfig) -> type[BaseHTTPRequestHandler]:
-    codec = SessionTokenCodec(config.cookie_secret)
-    limiter = LoginAttemptLimiter()
-
-    class PortalAuthHandler(BaseHTTPRequestHandler):
-        server_version = "HMMPortalAuth/1.0"
-        sys_version = ""
-
-        def do_HEAD(self) -> None:
-            self._route(send_body=False)
-
-        def do_GET(self) -> None:
-            self._route(send_body=True)
-
-        def do_POST(self) -> None:
-            path = urlsplit(self.path).path
-            if path == "/auth/login":
-                self._login()
-            elif path == "/auth/logout":
-                self._logout()
-            else:
-                self._send_text(HTTPStatus.NOT_FOUND, "Not found")
-
-        def _route(self, send_body: bool) -> None:
-            path = urlsplit(self.path).path
-            if path == "/auth/check":
-                self._check()
-            elif path == "/auth/login":
-                self._show_login(send_body=send_body)
-            elif path == "/auth/logout":
-                self._logout()
-            elif path == "/auth/healthz":
-                self._send_text(HTTPStatus.OK, "ok", send_body=send_body)
-            else:
-                self._send_text(HTTPStatus.NOT_FOUND, "Not found", send_body=send_body)
-
-        def _check(self) -> None:
-            session = self._session()
-            if session is None:
-                self._send_empty(HTTPStatus.UNAUTHORIZED)
-                return
-            self.send_response(HTTPStatus.NO_CONTENT)
-            self._security_headers()
-            self.send_header("X-Auth-User", session.username)
-            self.send_header("X-Auth-Expires", str(session.expires_at))
-            self.end_headers()
-
-        def _show_login(self, send_body: bool = True, error: str = "") -> None:
-            if self._session() is not None and not error:
-                self._redirect("/")
-                return
-            csrf_value = secrets.token_urlsafe(32)
-            body = _login_page(config, csrf_value, error)
-            self.send_response(HTTPStatus.OK)
-            self._security_headers()
-            self.send_header("Content-Type", "text/html; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.send_header("Set-Cookie", csrf_cookie_header(csrf_value))
-            self.end_headers()
-            if send_body:
-                self.wfile.write(body)
-
-        def _login(self) -> None:
-            client_key = self._client_key()
-            if limiter.blocked(client_key):
-                self._show_login(error="로그인 시도가 잠시 제한되었습니다. 잠시 후 다시 시도해 주세요.")
-                return
-            try:
-                content_length = int(self.headers.get("Content-Length", "0"))
-            except ValueError:
-                content_length = 0
-            if not 1 <= content_length <= MAX_REQUEST_BYTES:
-                self._send_text(HTTPStatus.BAD_REQUEST, "Invalid request")
-                return
-            raw_body = self.rfile.read(content_length)
-            try:
-                form = parse_qs(
-                    raw_body.decode("utf-8"),
-                    keep_blank_values=True,
-                    strict_parsing=False,
-                    max_num_fields=8,
-                )
-            except (UnicodeDecodeError, ValueError):
-                self._send_text(HTTPStatus.BAD_REQUEST, "Invalid request")
-                return
-            username = _form_value(form, "username")
-            password = _form_value(form, "password")
-            csrf_form = _form_value(form, "csrf")
-            csrf_cookie = _cookie_value(
-                self.headers.get("Cookie", ""), CSRF_COOKIE_NAME
-            )
-            if (
-                not csrf_form
-                or not csrf_cookie
-                or not hmac.compare_digest(csrf_form, csrf_cookie)
-            ):
-                self._send_text(HTTPStatus.BAD_REQUEST, "Invalid request")
-                return
-            valid_credentials = (
-                len(username) <= 80
-                and len(password) <= MAX_FIELD_CHARS
-                and hmac.compare_digest(username.strip(), config.username)
-                and password_matches(password, config.password_pbkdf2)
-            )
-            if not valid_credentials:
-                limiter.record_failure(client_key)
-                self._show_login(error="사용자 ID 또는 비밀번호를 확인해 주세요.")
-                return
-            limiter.reset(client_key)
-            remember = _form_value(form, "remember") == "yes"
-            lifetime = (
-                config.remember_seconds if remember else config.session_seconds
-            )
-            token = codec.issue(config.username, lifetime)
-            self.send_response(HTTPStatus.SEE_OTHER)
-            self._security_headers()
-            self.send_header("Location", "/")
-            self.send_header(
-                "Set-Cookie",
-                session_cookie_header(token, lifetime if remember else None),
-            )
-            self.send_header("Set-Cookie", clear_csrf_cookie_header())
-            self.end_headers()
-
-        def _logout(self) -> None:
-            self.send_response(HTTPStatus.SEE_OTHER)
-            self._security_headers()
-            self.send_header("Location", "/auth/login")
-            self.send_header("Set-Cookie", clear_session_cookie_header())
-            self.send_header("Set-Cookie", clear_csrf_cookie_header())
-            self.end_headers()
-
-        def _session(self) -> AuthenticatedSession | None:
-            token = _cookie_value(
-                self.headers.get("Cookie", ""), SESSION_COOKIE_NAME
-            )
-            return codec.verify(token, config.username)
-
-        def _client_key(self) -> str:
-            forwarded = self.headers.get("X-Real-IP", "").strip()
-            return forwarded or self.client_address[0]
-
-        def _redirect(self, location: str) -> None:
-            self.send_response(HTTPStatus.SEE_OTHER)
-            self._security_headers()
-            self.send_header("Location", location)
-            self.end_headers()
-
-        def _send_empty(self, status: HTTPStatus) -> None:
-            self.send_response(status)
-            self._security_headers()
-            self.send_header("Content-Length", "0")
-            self.end_headers()
-
-        def _send_text(
-            self,
-            status: HTTPStatus,
-            message: str,
-            send_body: bool = True,
-        ) -> None:
-            body = message.encode("utf-8")
-            self.send_response(status)
-            self._security_headers()
-            self.send_header("Content-Type", "text/plain; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            if send_body:
-                self.wfile.write(body)
-
-        def _security_headers(self) -> None:
-            self.send_header("Cache-Control", "no-store")
-            self.send_header("Pragma", "no-cache")
-            self.send_header("X-Content-Type-Options", "nosniff")
-            self.send_header("X-Frame-Options", "DENY")
-            self.send_header("Referrer-Policy", "no-referrer")
-            self.send_header(
-                "Content-Security-Policy",
-                "default-src 'none'; style-src 'unsafe-inline'; "
-                "form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
-            )
-
-        def log_message(self, _format: str, *args: object) -> None:
-            # Do not log query strings, cookies, form bodies, or tokens.
-            LOG.info("%s %s", self.command, urlsplit(self.path).path)
-
-    return PortalAuthHandler
-
-
-def _form_value(form: dict[str, list[str]], name: str) -> str:
-    values = form.get(name)
-    return values[0] if values else ""
-
-
-def main() -> None:
-    logging.basicConfig(
-        level=os.environ.get("PORTAL_AUTH_LOG_LEVEL", "INFO"),
-        format="%(asctime)s %(levelname)s %(name)s %(message)s",
-    )
-    config = AuthConfig.from_environment()
-    server = ThreadingHTTPServer(
-        (config.bind_address, config.port), build_handler(config)
-    )
-    LOG.info("HMM portal authentication service listening on loopback port %s", config.port)
-    server.serve_forever()
-
-
-if __name__ == "__main__":
-    main()

ai-web-agent-console/ai_web_agent_console/mcp_result.py

@@ -1,80 +0,0 @@
-"""Pure helpers for MCP result envelopes used by the Streamlit console."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-
-def response_payload(value: Any) -> Mapping[str, Any]:
-    """Return the business payload from a direct or nested MCP response."""
-
-    if not isinstance(value, Mapping):
-        return {}
-    nested = value.get("response")
-    return nested if isinstance(nested, Mapping) else value
-
-
-def text_result(value: Any) -> str:
-    """Return a textual `result` field without stringifying other structures."""
-
-    result = response_payload(value).get("result")
-    return result.strip() if isinstance(result, str) else ""
-
-
-def status_result_summary(value: Any, *, excerpt_chars: int = 900) -> dict[str, Any]:
-    """Build a safe UI summary for status/result-style compatibility tools."""
-
-    payload = response_payload(value)
-    summary: dict[str, Any] = {}
-    for key in ("status", "success", "error", "errorCode", "errorMessage"):
-        item = payload.get(key)
-        if item not in (None, "", []):
-            summary[key] = item
-    result = text_result(value)
-    if result:
-        summary["result_chars"] = len(result)
-        summary["result_excerpt"] = result[:excerpt_chars] + (
-            "..." if len(result) > excerpt_chars else ""
-        )
-    return summary
-
-
-def status_result_evidence(value: Any, *, max_chars: int = 7000) -> dict[str, Any]:
-    """Preserve bounded textual policy/data evidence for final answer synthesis."""
-
-    payload = response_payload(value)
-    evidence: dict[str, Any] = {}
-    for key in ("status", "success", "error", "errorCode", "errorMessage"):
-        item = payload.get(key)
-        if item not in (None, "", []):
-            evidence[key] = item
-    result = text_result(value)
-    if result:
-        evidence["result"] = result[:max_chars] + (
-            "..." if len(result) > max_chars else ""
-        )
-        evidence["result_chars"] = len(result)
-    return evidence
-
-
-def has_actionable_text_result(value: Any) -> bool:
-    """Return whether a textual result contains evidence worth stopping on."""
-
-    result = text_result(value)
-    if not result:
-        return False
-    normalized = " ".join(result.casefold().split())
-    return not any(
-        marker in normalized
-        for marker in ("no data found", "no evidence found", "error:")
-    )
-
-
-__all__ = [
-    "has_actionable_text_result",
-    "response_payload",
-    "status_result_evidence",
-    "status_result_summary",
-    "text_result",
-]

ai-web-agent-console/ai_web_agent_console/query_contracts.py

@@ -1,407 +0,0 @@
-"""Configuration-driven query and answer evidence contracts."""
-
-from __future__ import annotations
-
-import ast
-from decimal import Decimal, InvalidOperation
-from functools import lru_cache
-import json
-import os
-from pathlib import Path
-import re
-from typing import Any, Mapping
-
-
-ROOT = Path(__file__).resolve().parents[1]
-DEFAULT_CONTRACT_FILE = ROOT / "config" / "hmm_hr_query_contracts.json"
-
-
-def _contract_file() -> Path:
-    configured = str(
-        os.getenv("AI_WEB_AGENT_CONSOLE_QUERY_CONTRACTS_PATH")
-        or os.getenv("POC4_QUERY_CONTRACTS_PATH")
-        or ""
-    ).strip()
-    if not configured:
-        return DEFAULT_CONTRACT_FILE
-    path = Path(configured).expanduser()
-    return path if path.is_absolute() else ROOT / path
-
-
-@lru_cache(maxsize=4)
-def _load_contract_file(path_text: str) -> tuple[Mapping[str, Any], ...]:
-    path = Path(path_text)
-    if not path.exists():
-        return ()
-    value = json.loads(path.read_text(encoding="utf-8"))
-    contracts = value.get("contracts") if isinstance(value, Mapping) else None
-    if not isinstance(contracts, list):
-        raise ValueError("query contracts must contain a contracts array")
-    return tuple(item for item in contracts if isinstance(item, Mapping))
-
-
-def load_query_contracts() -> tuple[Mapping[str, Any], ...]:
-    return _load_contract_file(str(_contract_file()))
-
-
-def matching_query_contracts(
-    question: str,
-    tool_name: str,
-) -> tuple[Mapping[str, Any], ...]:
-    normalized_question = " ".join(str(question or "").casefold().split())
-    normalized_tool = str(tool_name or "").strip()
-    selected: list[Mapping[str, Any]] = []
-    for contract in load_query_contracts():
-        tools = contract.get("applies_to_tools")
-        if isinstance(tools, list) and normalized_tool not in {
-            str(item) for item in tools
-        }:
-            continue
-        intent = contract.get("intent_match")
-        if not isinstance(intent, Mapping):
-            continue
-        subject_terms = [
-            str(item).casefold()
-            for item in intent.get("subject_terms_any", [])
-            if str(item).strip()
-        ]
-        action_terms = [
-            str(item).casefold()
-            for item in intent.get("action_terms_any", [])
-            if str(item).strip()
-        ]
-        if subject_terms and not any(
-            term in normalized_question for term in subject_terms
-        ):
-            continue
-        if action_terms and not any(
-            term in normalized_question for term in action_terms
-        ):
-            continue
-        selected.append(contract)
-    return tuple(selected)
-
-
-def query_contract_guidance(question: str, tool_name: str) -> str:
-    contracts = matching_query_contracts(question, tool_name)
-    if not contracts:
-        return ""
-    return json.dumps(
-        {"query_contracts": contracts},
-        ensure_ascii=False,
-        separators=(",", ":"),
-    )
-
-
-def append_query_contract_guidance(
-    tool_query: str,
-    *,
-    original_question: str,
-    tool_name: str,
-) -> str:
-    guidance = query_contract_guidance(original_question, tool_name)
-    normalized = str(tool_query or "").strip()
-    if not guidance:
-        return normalized
-    return (
-        f"{normalized}\n"
-        "다음 질의 계약의 필드·계산·시간 기준을 반드시 지켜 결과를 반환하세요. "
-        f"계약: {guidance}"
-    )
-
-
-def _json_data_result(value: str) -> Any:
-    marker = "DATA_RESULT"
-    position = value.find(marker)
-    if position < 0:
-        return None
-    remainder = value[position + len(marker) :]
-    object_position = remainder.find("{")
-    array_position = remainder.find("[")
-    positions = [
-        candidate
-        for candidate in (object_position, array_position)
-        if candidate >= 0
-    ]
-    if not positions:
-        return None
-    candidate = remainder[min(positions) :]
-    try:
-        parsed, _ = json.JSONDecoder().raw_decode(candidate)
-    except (TypeError, ValueError, json.JSONDecodeError):
-        return None
-    return parsed
-
-
-def _evidence_rows(value: Any) -> list[Mapping[str, Any]]:
-    rows: list[Mapping[str, Any]] = []
-    if isinstance(value, Mapping):
-        rows.append(value)
-        for item in value.values():
-            rows.extend(_evidence_rows(item))
-    elif isinstance(value, list):
-        for item in value:
-            rows.extend(_evidence_rows(item))
-    elif isinstance(value, str):
-        parsed = _json_data_result(value)
-        if parsed is not None:
-            rows.extend(_evidence_rows(parsed))
-    return rows
-
-
-def _decimal(value: Any) -> Decimal:
-    if isinstance(value, bool) or value is None:
-        raise InvalidOperation
-    return Decimal(str(value))
-
-
-def _evaluate_contract_expression(
-    expression: str,
-    row: Mapping[str, Any],
-) -> Decimal:
-    tree = ast.parse(expression, mode="eval")
-
-    def evaluate(node: ast.AST) -> Decimal:
-        if isinstance(node, ast.Expression):
-            return evaluate(node.body)
-        if isinstance(node, ast.Name):
-            key = node.id.casefold()
-            if key not in row:
-                raise InvalidOperation
-            return _decimal(row[key])
-        if isinstance(node, ast.Constant):
-            return _decimal(node.value)
-        if isinstance(node, ast.UnaryOp) and isinstance(
-            node.op, (ast.UAdd, ast.USub)
-        ):
-            value = evaluate(node.operand)
-            return value if isinstance(node.op, ast.UAdd) else -value
-        if isinstance(node, ast.BinOp) and isinstance(
-            node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div)
-        ):
-            left = evaluate(node.left)
-            right = evaluate(node.right)
-            if isinstance(node.op, ast.Add):
-                return left + right
-            if isinstance(node.op, ast.Sub):
-                return left - right
-            if isinstance(node.op, ast.Mult):
-                return left * right
-            return left / right
-        raise ValueError("unsupported contract expression")
-
-    return evaluate(tree)
-
-
-def evidence_contract_report(
-    contracts: tuple[Mapping[str, Any], ...],
-    evidence: Any,
-) -> list[dict[str, Any]]:
-    rows = [
-        {str(key).strip().casefold(): value for key, value in row.items()}
-        for row in _evidence_rows(evidence)
-    ]
-    reports: list[dict[str, Any]] = []
-    for contract in contracts:
-        data_contract = contract.get("data_contract")
-        if not isinstance(data_contract, Mapping):
-            continue
-        required = [
-            str(item).strip().casefold()
-            for item in data_contract.get("required_fields", [])
-            if str(item).strip()
-        ]
-        matching_row = next(
-            (row for row in rows if required and all(key in row for key in required)),
-            None,
-        )
-        observed = sorted(
-            {
-                key
-                for row in rows
-                for key in row
-                if not required or key in required
-            }
-        )
-        missing = [
-            key.upper()
-            for key in required
-            if matching_row is None or key not in matching_row
-        ]
-        computed_checks: list[dict[str, Any]] = []
-        computed_fields = data_contract.get("computed_fields")
-        if matching_row is not None and isinstance(computed_fields, Mapping):
-            for field, definition in computed_fields.items():
-                normalized_field = str(field).strip().casefold()
-                expression = (
-                    str(definition.get("expression") or "").strip()
-                    if isinstance(definition, Mapping)
-                    else ""
-                )
-                if not normalized_field or not expression:
-                    continue
-                try:
-                    actual = _decimal(matching_row.get(normalized_field))
-                    expected = _evaluate_contract_expression(
-                        expression,
-                        matching_row,
-                    )
-                    matches = actual == expected
-                    computed_checks.append(
-                        {
-                            "field": normalized_field.upper(),
-                            "expression": expression,
-                            "actual": str(actual),
-                            "expected": str(expected),
-                            "satisfied": matches,
-                        }
-                    )
-                except (InvalidOperation, ValueError, ZeroDivisionError):
-                    computed_checks.append(
-                        {
-                            "field": normalized_field.upper(),
-                            "expression": expression,
-                            "satisfied": False,
-                        }
-                    )
-        calculations_satisfied = all(
-            bool(check.get("satisfied")) for check in computed_checks
-        )
-        temporal_checks: list[dict[str, Any]] = []
-        temporal_contract = contract.get("temporal_contract")
-        if matching_row is not None and isinstance(temporal_contract, Mapping):
-            status_fields = [
-                str(item).strip().casefold()
-                for item in temporal_contract.get("period_status_fields", [])
-                if str(item).strip()
-            ]
-            past_status = str(
-                temporal_contract.get("past_period_status") or ""
-            ).strip()
-            observed_status = next(
-                (
-                    str(matching_row.get(field) or "").strip()
-                    for field in status_fields
-                    if str(matching_row.get(field) or "").strip()
-                ),
-                "",
-            )
-            if observed_status == past_status and past_status:
-                decision_field = str(
-                    temporal_contract.get("past_period_decision_field") or ""
-                ).strip().casefold()
-                decision_value = str(
-                    temporal_contract.get("past_period_decision_value") or ""
-                ).strip()
-                actual_decision = str(
-                    matching_row.get(decision_field) or ""
-                ).strip()
-                temporal_checks.append(
-                    {
-                        "check": "past_period_decision",
-                        "field": decision_field.upper(),
-                        "expected": decision_value,
-                        "actual": actual_decision,
-                        "satisfied": bool(
-                            decision_field
-                            and decision_value
-                            and actual_decision == decision_value
-                        ),
-                    }
-                )
-                forbidden_patterns = [
-                    str(item).strip()
-                    for item in temporal_contract.get(
-                        "forbidden_past_period_decision_field_patterns", []
-                    )
-                    if str(item).strip()
-                ]
-                forbidden_fields = sorted(
-                    key.upper()
-                    for key in matching_row
-                    if any(
-                        re.search(pattern, key, flags=re.IGNORECASE)
-                        for pattern in forbidden_patterns
-                    )
-                )
-                temporal_checks.append(
-                    {
-                        "check": "no_past_period_yes_no_decision",
-                        "forbidden_fields": forbidden_fields,
-                        "satisfied": not forbidden_fields,
-                    }
-                )
-                required_counts = [
-                    str(item).strip().casefold()
-                    for item in temporal_contract.get(
-                        "validate_stated_days_against", []
-                    )
-                    if str(item).strip()
-                ]
-                temporal_checks.append(
-                    {
-                        "check": "date_range_counts",
-                        "required_fields": [
-                            field.upper() for field in required_counts
-                        ],
-                        "missing_fields": [
-                            field.upper()
-                            for field in required_counts
-                            if field not in matching_row
-                        ],
-                        "satisfied": all(
-                            field in matching_row for field in required_counts
-                        ),
-                    }
-                )
-        temporal_satisfied = all(
-            bool(check.get("satisfied")) for check in temporal_checks
-        )
-        reports.append(
-            {
-                "contract_id": str(contract.get("id") or ""),
-                "satisfied": bool(
-                    matching_row is not None
-                    and not missing
-                    and calculations_satisfied
-                    and temporal_satisfied
-                ),
-                "required_fields": [key.upper() for key in required],
-                "observed_required_fields": [key.upper() for key in observed],
-                "missing_fields": missing,
-                "computed_field_checks": computed_checks,
-                "temporal_contract_checks": temporal_checks,
-                "validated_record": (
-                    {
-                        key.upper(): matching_row.get(key)
-                        for key in required
-                    }
-                    if matching_row is not None
-                    else {}
-                ),
-            }
-        )
-    return reports
-
-
-def missing_evidence_message(
-    contracts: tuple[Mapping[str, Any], ...],
-) -> str:
-    for contract in contracts:
-        answer_contract = contract.get("answer_contract")
-        if not isinstance(answer_contract, Mapping):
-            continue
-        message = str(answer_contract.get("missing_evidence_message") or "").strip()
-        if message:
-            return message
-    return "조회 결과가 답변 계약의 필수 근거를 충족하지 않아 결론을 제공할 수 없습니다."
-
-
-__all__ = [
-    "append_query_contract_guidance",
-    "evidence_contract_report",
-    "load_query_contracts",
-    "matching_query_contracts",
-    "missing_evidence_message",
-    "query_contract_guidance",
-]

ai-web-agent-console/ai_web_agent_console/smilegate_demo/__init__.py

@@ -1,5 +0,0 @@
-"""Smilegate demo modules.
-
-The portal is assembled from small modules so each feature can be reviewed and
-released independently.
-"""

ai-web-agent-console/ai_web_agent_console/smilegate_demo/ui/__init__.py

@@ -1 +0,0 @@
-"""Presentation modules for the Smilegate demo."""

ai-web-agent-console/ai_web_agent_console/smilegate_demo/ui/shell.py

@@ -1,28 +0,0 @@
-"""Blank presentation shell.
-
-No authentication, data access, MCP call, persistence, or customer text belongs
-in this module. It exists only to prove the minimal Streamlit runtime path.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def render_blank_shell(st: Any) -> None:
-    """Render the intentionally empty first review screen."""
-    st.set_page_config(page_title="Smilegate Demo", layout="wide")
-    st.markdown(
-        """
-        <style>
-          [data-testid="stHeader"],
-          [data-testid="stToolbar"],
-          #MainMenu,
-          footer { display: none; }
-          [data-testid="stAppViewContainer"],
-          .stApp { background: #ffffff; }
-          .block-container { padding: 0; max-width: none; }
-        </style>
-        """,
-        unsafe_allow_html=True,
-    )

ai-web-agent-console/config/hmm_hr_query_contracts.json

@@ -1,84 +0,0 @@
-{
-  "version": 1,
-  "contracts": [
-    {
-      "id": "leave_balance_eligibility",
-      "description": "연차·휴가 잔여와 신청 가능 여부를 원장 연도 및 구성값으로 검증한다.",
-      "applies_to_tools": [
-        "search_hr_data"
-      ],
-      "intent_match": {
-        "subject_terms_any": [
-          "연차",
-          "휴가"
-        ],
-        "action_terms_any": [
-          "잔여",
-          "가능",
-          "승인",
-          "신청",
-          "사용할 수"
-        ]
-      },
-      "data_contract": {
-        "source_object": "HMM_LEAVE_BALANCES",
-        "identity_fields": [
-          "EMPLOYEE_CODE"
-        ],
-        "required_fields": [
-          "LEAVE_YEAR",
-          "ANNUAL_ENTITLEMENT",
-          "CARRYOVER_DAYS",
-          "USED_DAYS",
-          "PENDING_DAYS",
-          "AVAILABLE_REMAINING_DAYS"
-        ],
-        "computed_fields": {
-          "AVAILABLE_REMAINING_DAYS": {
-            "expression": "ANNUAL_ENTITLEMENT + CARRYOVER_DAYS - USED_DAYS - PENDING_DAYS",
-            "authoritative_source": "DATABASE_VIRTUAL_COLUMN"
-          }
-        },
-        "missing_record_semantics": "NO_BALANCE_DATA_FOR_YEAR",
-        "forbidden_missing_record_fallbacks": [
-          "ZERO",
-          "NVL",
-          "COALESCE",
-          "OUTER_JOIN_DEFAULT",
-          "LITERAL_VALUE"
-        ]
-      },
-      "temporal_contract": {
-        "current_balance_year": "LATEST_AVAILABLE_LEAVE_YEAR",
-        "requested_period_and_current_balance_are_separate": true,
-        "period_status_fields": [
-          "REQUEST_PERIOD_LABEL",
-          "PERIOD_STATUS"
-        ],
-        "past_period_status": "HISTORICAL_REQUEST_PERIOD",
-        "past_period_decision": "DO_NOT_DECIDE_NEW_APPLICATION_FROM_CURRENT_BALANCE",
-        "past_period_decision_field": "APPLICATION_DECISION_STATUS",
-        "past_period_decision_value": "NOT_APPLICABLE_FOR_HISTORICAL_PERIOD",
-        "forbidden_past_period_decision_field_patterns": [
-          "^CAN_",
-          "^APPROVAL_(ALLOWED|DENIED)$"
-        ],
-        "validate_stated_days_against": [
-          "INCLUSIVE_CALENDAR_DAYS",
-          "MONDAY_TO_FRIDAY_DAYS"
-        ],
-        "day_count_mismatch_status": "DATE_COUNT_REQUIRES_VALIDATION"
-      },
-      "answer_contract": {
-        "separate_data_facts_and_policy_requirements": true,
-        "deny_conclusions_without_required_fields": [
-          "ZERO_REMAINING_DAYS",
-          "LEAVE_APPROVAL_ALLOWED",
-          "LEAVE_APPROVAL_DENIED"
-        ],
-        "missing_evidence_response": "STATE_INSUFFICIENT_EVIDENCE_WITHOUT_INVENTING_VALUES",
-        "missing_evidence_message": "조회 결과가 필수 원장 근거나 시간 기준 계약을 충족하지 않아 휴가 가능 여부를 확정할 수 없습니다. 계약 필드가 충족된 원장 결과로 다시 조회해야 합니다."
-      }
-    }
-  ]
-}

ai-web-agent-console/config/mcp_servers.json

@@ -1,58 +0,0 @@
-{
-  "default_server_id": "smilegate_game_data_mcp",
-  "servers": [
-    {
-      "id": "smilegate_game_data_mcp",
-      "enabled": true,
-      "provider": "smilegate_select_ai_mcp",
-      "transport": "http",
-      "endpoint_url": "https://smilegate-backoffice.cloud-handson.com/mcp",
-      "auth_token_env": "SMILEGATE_MCP_BEARER_TOKEN",
-      "timeout_seconds_env": "POC3_MCP_TIMEOUT_SECONDS",
-      "default_tool": "oracle.select_ai.smilegate_fewshot_nl2sql",
-      "router_model_profile": "gpt54_mini_oci",
-      "tool_allowlist": [
-        "oracle.select_ai.fewshot_preflight",
-        "oracle.select_ai.game_query_plan",
-        "oracle.select_ai.game_daily_au_lookup",
-        "oracle.select_ai.smilegate_fewshot_nl2sql",
-        "oracle.select_ai.smilegate_game_text2sql",
-        "oracle.select_ai.qa_vector_search",
-        "oracle.select_ai.qa_vector_store"
-      ],
-      "tool_workflow": [
-        {
-          "tool": "oracle.select_ai.fewshot_preflight",
-          "prelude": true
-        },
-        {
-          "tool": "oracle.select_ai.game_query_plan",
-          "prelude": true
-        },
-        {
-          "tool": "oracle.select_ai.smilegate_fewshot_nl2sql",
-          "arguments_from": [
-            {
-              "argument": "fewShotPreflight",
-              "tool": "oracle.select_ai.fewshot_preflight"
-            },
-            {
-              "argument": "queryPlan",
-              "tool": "oracle.select_ai.game_query_plan"
-            }
-          ]
-        },
-        {
-          "tool": "oracle.select_ai.game_daily_au_lookup",
-          "arguments_from": [
-            {
-              "argument": "queryPlan",
-              "tool": "oracle.select_ai.game_query_plan"
-            }
-          ]
-        }
-      ],
-      "description": "Smilegate game-data Text2SQL MCP server"
-    }
-  ]
-}

ai-web-agent-console/portal_auth_gateway.py

@@ -1,128 +0,0 @@
-"""Small same-origin authentication gateway for the Smilegate Streamlit portal.
-
-The gateway issues a signed HttpOnly cookie after validating the configured
-PBKDF2 password.  The Streamlit application verifies the signature and expiry
-from the incoming request, so browser refreshes and WebSocket reconnects do not
-require a new login.
-"""
-
-from __future__ import annotations
-
-import base64
-import hashlib
-import hmac
-import json
-import os
-import time
-from http import HTTPStatus
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from urllib.parse import parse_qs
-
-
-COOKIE_NAME = "poc4_portal_auth"
-MAX_BODY_BYTES = 8_192
-COOKIE_TTL_SECONDS = int(os.environ.get("POC4_LOGIN_COOKIE_TTL_SECONDS", "43200"))
-
-
-def _password_matches(password: str, encoded_password: str) -> bool:
-    try:
-        scheme, iterations_text, salt_hex, expected_hex = encoded_password.split("$", 3)
-        iterations = int(iterations_text)
-        salt = bytes.fromhex(salt_hex)
-        expected = bytes.fromhex(expected_hex)
-    except (TypeError, ValueError):
-        return False
-    if scheme != "pbkdf2_sha256" or not 100_000 <= iterations <= 2_000_000:
-        return False
-    candidate = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, iterations)
-    return hmac.compare_digest(candidate, expected)
-
-
-def _cookie_value(username: str) -> str:
-    secret = os.environ["POC4_LOGIN_REMEMBER_SECRET"]
-    claims = {"v": 1, "u": username, "e": int(time.time()) + COOKIE_TTL_SECONDS}
-    encoded = base64.urlsafe_b64encode(
-        json.dumps(claims, separators=(",", ":")).encode("utf-8")
-    ).decode("ascii").rstrip("=")
-    signature = hmac.new(secret.encode("utf-8"), encoded.encode("ascii"), hashlib.sha256).hexdigest()
-    return f"{encoded}.{signature}"
-
-
-def _set_cookie(handler: BaseHTTPRequestHandler, value: str, max_age: int) -> None:
-    attributes = [
-        f"{COOKIE_NAME}={value}",
-        "Path=/",
-        f"Max-Age={max_age}",
-        "HttpOnly",
-        "Secure",
-        "SameSite=Lax",
-    ]
-    handler.send_header("Set-Cookie", "; ".join(attributes))
-
-
-class PortalAuthHandler(BaseHTTPRequestHandler):
-    server_version = "SmilegatePortalAuth/1.0"
-
-    def log_message(self, _format: str, *_args: object) -> None:
-        # Do not log form data or authentication details.
-        return
-
-    def _redirect(self, location: str, cookie_value: str | None = None, max_age: int = 0) -> None:
-        self.send_response(HTTPStatus.SEE_OTHER)
-        if cookie_value is not None:
-            _set_cookie(self, cookie_value, max_age)
-        self.send_header("Location", location)
-        self.send_header("Cache-Control", "no-store")
-        self.end_headers()
-
-    def do_GET(self) -> None:  # noqa: N802
-        if self.path == "/health":
-            self.send_response(HTTPStatus.OK)
-            self.send_header("Content-Type", "text/plain; charset=utf-8")
-            self.send_header("Cache-Control", "no-store")
-            self.end_headers()
-            self.wfile.write(b"ok\n")
-            return
-        if self.path == "/logout":
-            self._redirect("/", "", 0)
-            return
-        self.send_error(HTTPStatus.NOT_FOUND)
-
-    def do_POST(self) -> None:  # noqa: N802
-        if self.path != "/login":
-            self.send_error(HTTPStatus.NOT_FOUND)
-            return
-        try:
-            content_length = int(self.headers.get("Content-Length", "0"))
-        except ValueError:
-            content_length = 0
-        if content_length <= 0 or content_length > MAX_BODY_BYTES:
-            self._redirect("/?login=failed")
-            return
-        form = parse_qs(self.rfile.read(content_length).decode("utf-8"), keep_blank_values=True)
-        username = form.get("username", [""])[0].strip()
-        password = form.get("password", [""])[0]
-        expected_username = os.environ.get("POC4_LOGIN_USER", "").strip()
-        encoded_password = os.environ.get("POC4_LOGIN_PASSWORD_PBKDF2", "").strip()
-        if (
-            expected_username
-            and hmac.compare_digest(username, expected_username)
-            and _password_matches(password, encoded_password)
-        ):
-            self._redirect("/", _cookie_value(username), COOKIE_TTL_SECONDS)
-            return
-        self._redirect("/?login=failed")
-
-
-def main() -> None:
-    address = os.environ.get("POC4_AUTH_BIND", "127.0.0.1")
-    port = int(os.environ.get("POC4_AUTH_PORT", "8623"))
-    required = ("POC4_LOGIN_USER", "POC4_LOGIN_PASSWORD_PBKDF2", "POC4_LOGIN_REMEMBER_SECRET")
-    missing = [name for name in required if not os.environ.get(name, "").strip()]
-    if missing:
-        raise RuntimeError("missing required portal auth configuration")
-    ThreadingHTTPServer((address, port), PortalAuthHandler).serve_forever()
-
-
-if __name__ == "__main__":
-    main()

ai-web-agent-console/smilegate_demo.py

@@ -1,20 +0,0 @@
-"""Minimal Smilegate Streamlit demo entrypoint.
-
-This entrypoint intentionally wires only the blank presentation shell. Feature
-modules such as authentication, MCP querying, and history are added separately
-after each review.
-"""
-
-from __future__ import annotations
-
-import streamlit as st
-
-from ai_web_agent_console.smilegate_demo.ui.shell import render_blank_shell
-
-
-def main() -> None:
-    render_blank_shell(st)
-
-
-if __name__ == "__main__":
-    main()

ai-web-agent-console/tests/test_auth_gateway.py

@@ -1,217 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import http.client
-import os
-from pathlib import Path
-import sys
-import threading
-import unittest
-from urllib.parse import urlencode
-
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT))
-
-from ai_web_agent_console.auth_gateway import (  # noqa: E402
-    AuthConfig,
-    LoginAttemptLimiter,
-    SESSION_COOKIE_NAME,
-    SessionTokenCodec,
-    build_handler,
-    clear_session_cookie_header,
-    password_matches,
-    session_cookie_header,
-)
-
-
-class AuthGatewayTest(unittest.TestCase):
-    def setUp(self) -> None:
-        self.secret = "s" * 48
-        self.codec = SessionTokenCodec(self.secret)
-
-    def test_session_token_round_trip_and_tamper_rejection(self) -> None:
-        token = self.codec.issue("demo-admin", 3600, now=1_000)
-
-        session = self.codec.verify(token, "demo-admin", now=1_001)
-
-        self.assertIsNotNone(session)
-        self.assertEqual("demo-admin", session.username)
-        self.assertEqual(4_600, session.expires_at)
-        self.assertIsNone(self.codec.verify(token + "x", "demo-admin", now=1_001))
-        self.assertIsNone(self.codec.verify(token, "other-user", now=1_001))
-
-    def test_expired_session_token_is_rejected(self) -> None:
-        token = self.codec.issue("demo-admin", 300, now=1_000)
-
-        self.assertIsNone(self.codec.verify(token, "demo-admin", now=1_300))
-
-    def test_remember_cookie_has_required_security_attributes(self) -> None:
-        header = session_cookie_header("signed-value", 604_800)
-
-        self.assertIn(f"{SESSION_COOKIE_NAME}=signed-value", header)
-        self.assertIn("Path=/", header)
-        self.assertIn("Secure", header)
-        self.assertIn("HttpOnly", header)
-        self.assertIn("SameSite=Lax", header)
-        self.assertIn("Max-Age=604800", header)
-        self.assertNotIn("Domain=", header)
-
-    def test_session_cookie_omits_persistent_max_age(self) -> None:
-        header = session_cookie_header("signed-value", None)
-
-        self.assertNotIn("Max-Age", header)
-        self.assertIn("HttpOnly", header)
-
-    def test_logout_cookie_expires_immediately(self) -> None:
-        header = clear_session_cookie_header()
-
-        self.assertIn("Max-Age=0", header)
-        self.assertIn("Secure", header)
-        self.assertIn("HttpOnly", header)
-
-    def test_pbkdf2_password_verification(self) -> None:
-        salt = bytes.fromhex("00112233445566778899aabbccddeeff")
-        expected = hashlib.pbkdf2_hmac(
-            "sha256", b"correct-password", salt, 200_000
-        ).hex()
-        encoded = f"pbkdf2_sha256$200000${salt.hex()}${expected}"
-
-        self.assertTrue(password_matches("correct-password", encoded))
-        self.assertFalse(password_matches("wrong-password", encoded))
-
-    def test_rate_limiter_blocks_only_after_threshold(self) -> None:
-        limiter = LoginAttemptLimiter(maximum_failures=2, window_seconds=10)
-
-        limiter.record_failure("client", now=1)
-        self.assertFalse(limiter.blocked("client", now=2))
-        limiter.record_failure("client", now=3)
-        self.assertTrue(limiter.blocked("client", now=4))
-        self.assertFalse(limiter.blocked("client", now=20))
-
-    def test_environment_config_requires_new_cookie_secret(self) -> None:
-        previous = dict(os.environ)
-        try:
-            os.environ["POC4_LOGIN_USER"] = "demo-admin"
-            os.environ["POC4_LOGIN_PASSWORD_PBKDF2"] = "encoded"
-            os.environ.pop("POC4_LOGIN_COOKIE_SECRET", None)
-            with self.assertRaisesRegex(ValueError, "COOKIE_SECRET"):
-                AuthConfig.from_environment()
-        finally:
-            os.environ.clear()
-            os.environ.update(previous)
-
-    def test_http_login_check_and_logout_flow_never_uses_url_token(self) -> None:
-        salt = bytes.fromhex("00112233445566778899aabbccddeeff")
-        expected = hashlib.pbkdf2_hmac(
-            "sha256", b"correct-password", salt, 200_000
-        ).hex()
-        config = AuthConfig(
-            username="demo-admin",
-            password_pbkdf2=(
-                f"pbkdf2_sha256$200000${salt.hex()}${expected}"
-            ),
-            cookie_secret=self.secret,
-            port=8621,
-        )
-        from http.server import ThreadingHTTPServer
-
-        server = ThreadingHTTPServer(("127.0.0.1", 0), build_handler(config))
-        thread = threading.Thread(target=server.serve_forever, daemon=True)
-        thread.start()
-        connection = http.client.HTTPConnection(
-            "127.0.0.1", server.server_address[1], timeout=3
-        )
-        try:
-            connection.request("GET", "/auth/login")
-            login_page = connection.getresponse()
-            body = login_page.read().decode("utf-8")
-            self.assertEqual(200, login_page.status)
-            csrf_header = next(
-                value
-                for name, value in login_page.getheaders()
-                if name.lower() == "set-cookie"
-                and value.startswith("__Host-HMM_LOGIN_CSRF=")
-            )
-            csrf_value = csrf_header.split("=", 1)[1].split(";", 1)[0]
-            self.assertIn(
-                f'name="csrf" value="{csrf_value}"',
-                body,
-            )
-
-            payload = urlencode(
-                {
-                    "csrf": csrf_value,
-                    "username": "demo-admin",
-                    "password": "correct-password",
-                    "remember": "yes",
-                }
-            )
-            connection.request(
-                "POST",
-                "/auth/login",
-                body=payload,
-                headers={
-                    "Content-Type": "application/x-www-form-urlencoded",
-                    "Cookie": f"__Host-HMM_LOGIN_CSRF={csrf_value}",
-                },
-            )
-            logged_in = connection.getresponse()
-            logged_in.read()
-            self.assertEqual(303, logged_in.status)
-            self.assertEqual("/", logged_in.getheader("Location"))
-            self.assertNotRegex(logged_in.getheader("Location"), r"token|remember")
-            session_header = next(
-                value
-                for name, value in logged_in.getheaders()
-                if name.lower() == "set-cookie"
-                and value.startswith(f"{SESSION_COOKIE_NAME}=")
-            )
-            session_value = session_header.split("=", 1)[1].split(";", 1)[0]
-            self.assertIn("Secure", session_header)
-            self.assertIn("HttpOnly", session_header)
-            self.assertIn("SameSite=Lax", session_header)
-
-            connection.request(
-                "GET",
-                "/auth/check",
-                headers={"Cookie": f"{SESSION_COOKIE_NAME}={session_value}"},
-            )
-            check = connection.getresponse()
-            check.read()
-            self.assertEqual(204, check.status)
-            self.assertEqual("demo-admin", check.getheader("X-Auth-User"))
-
-            connection.request(
-                "GET",
-                "/auth/check",
-                headers={"Cookie": f"{SESSION_COOKIE_NAME}={session_value}x"},
-            )
-            tampered = connection.getresponse()
-            tampered.read()
-            self.assertEqual(401, tampered.status)
-
-            connection.request(
-                "GET",
-                "/auth/logout",
-                headers={"Cookie": f"{SESSION_COOKIE_NAME}={session_value}"},
-            )
-            logout = connection.getresponse()
-            logout.read()
-            self.assertEqual(303, logout.status)
-            self.assertEqual("/auth/login", logout.getheader("Location"))
-            self.assertTrue(
-                any(
-                    name.lower() == "set-cookie" and "Max-Age=0" in value
-                    for name, value in logout.getheaders()
-                )
-            )
-        finally:
-            connection.close()
-            server.shutdown()
-            server.server_close()
-            thread.join(timeout=3)
-
-
-if __name__ == "__main__":
-    unittest.main()

ai-web-agent-console/tests/test_query_contracts.py

@@ -1,181 +0,0 @@
-import unittest
-
-from ai_web_agent_console.query_contracts import (
-    append_query_contract_guidance,
-    evidence_contract_report,
-    matching_query_contracts,
-)
-
-
-def test_leave_eligibility_question_selects_external_contract():
-    contracts = matching_query_contracts(
-        "직원 E9999의 연차 잔여와 신청 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-
-    assert [contract["id"] for contract in contracts] == [
-        "leave_balance_eligibility"
-    ]
-
-
-def test_unrelated_tool_does_not_receive_leave_contract():
-    contracts = matching_query_contracts(
-        "직원 E9999의 연차 잔여를 알려줘",
-        "search_carrier_performance",
-    )
-
-    assert contracts == ()
-
-
-def test_incomplete_result_cannot_be_interpreted_as_zero_balance():
-    contracts = matching_query_contracts(
-        "직원 E9999의 연차 사용 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-    evidence = {
-        "result": (
-            'DATA_RESULT: {"items":[{"EMPLOYEE_CODE":"E9999",'
-            '"REMAINING_DAYS":0}]}'
-        )
-    }
-
-    report = evidence_contract_report(contracts, evidence)
-
-    assert report[0]["satisfied"] is False
-    assert "AVAILABLE_REMAINING_DAYS" in report[0]["missing_fields"]
-    assert "LEAVE_YEAR" in report[0]["missing_fields"]
-
-
-def test_complete_database_row_satisfies_contract_without_fixture_values():
-    contracts = matching_query_contracts(
-        "직원 E9999의 연차 신청 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-    evidence = {
-        "result": (
-            'DATA_RESULT\n{"items":[{"EMPLOYEE_CODE":"E9999",'
-            '"LEAVE_YEAR":2031,"ANNUAL_ENTITLEMENT":17,'
-            '"CARRYOVER_DAYS":2,"USED_DAYS":4,"PENDING_DAYS":1,'
-            '"AVAILABLE_REMAINING_DAYS":14}]}'
-        )
-    }
-
-    report = evidence_contract_report(contracts, evidence)
-
-    assert report[0]["satisfied"] is True
-    assert report[0]["validated_record"]["LEAVE_YEAR"] == 2031
-    assert report[0]["validated_record"]["AVAILABLE_REMAINING_DAYS"] == 14
-
-
-def test_conflicting_computed_value_fails_contract():
-    contracts = matching_query_contracts(
-        "직원 E9999의 연차 신청 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-    evidence = {
-        "result": (
-            'DATA_RESULT\n{"items":[{"EMPLOYEE_CODE":"E9999",'
-            '"LEAVE_YEAR":2031,"ANNUAL_ENTITLEMENT":17,'
-            '"CARRYOVER_DAYS":2,"USED_DAYS":4,"PENDING_DAYS":1,'
-            '"AVAILABLE_REMAINING_DAYS":0}]}'
-        )
-    }
-
-    report = evidence_contract_report(contracts, evidence)
-
-    assert report[0]["satisfied"] is False
-    assert report[0]["computed_field_checks"][0]["expected"] == "14"
-    assert report[0]["computed_field_checks"][0]["actual"] == "0"
-
-
-def test_historical_period_rejects_yes_no_decision_and_missing_counts():
-    contracts = matching_query_contracts(
-        "직원 E9999의 과거 연차 신청 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-    evidence = {
-        "result": (
-            'DATA_RESULT\n{"items":[{"EMPLOYEE_CODE":"E9999",'
-            '"LEAVE_YEAR":2031,"ANNUAL_ENTITLEMENT":17,'
-            '"CARRYOVER_DAYS":2,"USED_DAYS":4,"PENDING_DAYS":1,'
-            '"AVAILABLE_REMAINING_DAYS":14,'
-            '"REQUEST_PERIOD_LABEL":"HISTORICAL_REQUEST_PERIOD",'
-            '"CAN_APPLY":"YES","INCLUSIVE_CALENDAR_DAYS":11}]}'
-        )
-    }
-
-    report = evidence_contract_report(contracts, evidence)
-
-    assert report[0]["satisfied"] is False
-    failed = {
-        check["check"]
-        for check in report[0]["temporal_contract_checks"]
-        if not check["satisfied"]
-    }
-    assert failed == {
-        "past_period_decision",
-        "no_past_period_yes_no_decision",
-        "date_range_counts",
-    }
-
-
-def test_historical_period_contract_accepts_non_decision_status():
-    contracts = matching_query_contracts(
-        "직원 E9999의 과거 연차 신청 가능 여부를 알려줘",
-        "search_hr_data",
-    )
-    evidence = {
-        "result": (
-            'DATA_RESULT\n{"items":[{"EMPLOYEE_CODE":"E9999",'
-            '"LEAVE_YEAR":2031,"ANNUAL_ENTITLEMENT":17,'
-            '"CARRYOVER_DAYS":2,"USED_DAYS":4,"PENDING_DAYS":1,'
-            '"AVAILABLE_REMAINING_DAYS":14,'
-            '"REQUEST_PERIOD_LABEL":"HISTORICAL_REQUEST_PERIOD",'
-            '"APPLICATION_DECISION_STATUS":'
-            '"NOT_APPLICABLE_FOR_HISTORICAL_PERIOD",'
-            '"INCLUSIVE_CALENDAR_DAYS":11,'
-            '"MONDAY_TO_FRIDAY_DAYS":7}]}'
-        )
-    }
-
-    report = evidence_contract_report(contracts, evidence)
-
-    assert report[0]["satisfied"] is True
-
-
-def test_guidance_is_appended_from_json_contract():
-    guided = append_query_contract_guidance(
-        "직원 E9999의 휴가 잔여를 조회해줘",
-        original_question="직원 E9999의 휴가 잔여를 조회해줘",
-        tool_name="search_hr_data",
-    )
-
-    assert '"id":"leave_balance_eligibility"' in guided
-    assert "AVAILABLE_REMAINING_DAYS" in guided
-
-
-class QueryContractTest(unittest.TestCase):
-    test_leave_eligibility_question_selects_external_contract = staticmethod(
-        test_leave_eligibility_question_selects_external_contract
-    )
-    test_unrelated_tool_does_not_receive_leave_contract = staticmethod(
-        test_unrelated_tool_does_not_receive_leave_contract
-    )
-    test_incomplete_result_cannot_be_interpreted_as_zero_balance = staticmethod(
-        test_incomplete_result_cannot_be_interpreted_as_zero_balance
-    )
-    test_complete_database_row_satisfies_contract_without_fixture_values = (
-        staticmethod(test_complete_database_row_satisfies_contract_without_fixture_values)
-    )
-    test_conflicting_computed_value_fails_contract = staticmethod(
-        test_conflicting_computed_value_fails_contract
-    )
-    test_historical_period_rejects_yes_no_decision_and_missing_counts = (
-        staticmethod(test_historical_period_rejects_yes_no_decision_and_missing_counts)
-    )
-    test_historical_period_contract_accepts_non_decision_status = staticmethod(
-        test_historical_period_contract_accepts_non_decision_status
-    )
-    test_guidance_is_appended_from_json_contract = staticmethod(
-        test_guidance_is_appended_from_json_contract
-    )

database/adb/100_sgmp_czn05_country_business_au_fewshot.sql

@@ -1,22 +0,0 @@
--- Approve the reviewed customer QA example for a grouped business-AU query.
--- Empty result sets remain valid executed query results.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       answer_text = 'Expected focus: aggregate business AU by the user-master country attribute. '
-                   || 'Join CZN_CUSTOM_BIZ_USER_TXN to CZN_COMN_USER_MST by GUID and BASE_DT; filter BIZ_AU_FLAG=1 and EXPT_USER_YN=''N'', then group by LAST_CONN_COUNTRY_CD. '
-                   || 'A successfully executed query with no country rows is a valid result, not a SQL failure. '
-                   || 'Historical answer: no result rows.',
-       inspection_note = 'Customer QA verified: country business-AU is a grouped join; an empty result is a valid query outcome.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-05';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, source_case_id, answer_text
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-05';

database/adb/101_sgmp_czn06_country_standard_au_fewshot.sql

@@ -1,16 +0,0 @@
--- Approve the reviewed customer QA example for a grouped standard-AU query.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       answer_text = 'Expected focus: aggregate standard AU by user-master country, joining COMN_COUNTRY_BAS only for the country display name. '
-                   || 'Use CZN_COMN_USER_MST with AU_FLAG=1 and EXPT_USER_YN=''N'', grouped by LAST_CONN_COUNTRY_CD and COUNTRY_KR_NM. '
-                   || 'The label standard AU does not imply STD_USER_YN. A successfully executed empty result is valid. '
-                   || 'Historical answer: no result rows.',
-       inspection_note = 'Customer QA verified: country standard-AU is grouped AU_FLAG aggregation; empty output is valid.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-06';
-
-COMMIT;

database/adb/102_sgmp_czn07_crystal_holdings_fewshot.sql

@@ -1,15 +0,0 @@
--- Approve the reviewed customer QA example for daily in-game currency holdings.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       answer_text = 'Expected focus: daily crystal holdings use CZN_CUSTOM_GOODS_HAVE_TXN joined to CZN_COMN_USER_MST and CZN_COMN_SVC_DIM_BAS. '
-                   || 'Filter the goods dimension to crystal, nonzero HAVE_CNT, eligible returning-user population, and the requested date range; group by BASE_DT. '
-                   || 'A successfully executed empty result is valid. Historical answer: no result rows.',
-       inspection_note = 'Customer QA verified: daily crystal holdings are a date-grouped goods/user/dimension join; empty output is valid.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-07';
-
-COMMIT;

database/adb/103_sgmp_czn08_crystal_average_fewshot.sql

@@ -1,15 +0,0 @@
--- Approve the exact customer QA for standard-AU crystal holdings per user.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       answer_text = 'Use the verified customer SQL template for crystal holdings among standard AU. '
-                   || 'The standard-AU population uses AU_FLAG=1 and EXPT_USER_YN=''N''; do not add STD_USER_YN unless explicitly requested. '
-                   || 'Use the template population denominator for the per-user average. Null aggregate values are valid when the qualifying set is empty.',
-       inspection_note = 'Customer QA verified: retain the approved standard-AU population and average denominator semantics.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-08';
-
-COMMIT;

database/adb/104_sgmp_approve_remaining_czn_customer_fewshots.sql

@@ -1,21 +0,0 @@
--- Customer-provided CZN benchmark examples are the approved reference corpus
--- for exact-question Few-shot retrieval.  Their SQL and expected-answer text
--- remain the source of metric semantics; no runtime game/table branching is added.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Customer QA benchmark approved for exact-question Few-shot retrieval.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id LIKE 'CZN-%'
-   AND reference_status <> 'APPROVED';
-
-COMMIT;
-
-SELECT source_case_id, reference_status, inspection_status
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id LIKE 'CZN-%'
- ORDER BY source_case_id;

database/adb/105_sgmp_czn13_zero_aggregate_fewshot.sql

@@ -1,11 +0,0 @@
--- Preserve customer QA output semantics for empty numeric aggregates.
-
-UPDATE sg_qa_vector_example
-   SET answer_text = NVL(answer_text, '') || ' For this approved metric, normalize an empty numeric aggregate to 0 in the returned result. Preserve the template join from CZN_CUSTOM_GOODS_CHANGE_TXN to CZN_COMN_USER_MST, apply u.EXPT_USER_YN=''N'', and count distinct u.GUID.',
-       inspection_note = 'Customer QA verified: empty total Ether usage is reported as numeric zero with the template user-master join, excluded-user filter, and user population.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-13';
-
-COMMIT;

database/adb/106_sgmp_approve_remaining_std_customer_fewshots.sql

@@ -1,21 +0,0 @@
--- Approve the remaining customer-provided standard QA references for exact-question Few-shot retrieval.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Customer QA benchmark approved for exact-question Few-shot retrieval.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id LIKE 'STD-%'
-   AND reference_status <> 'APPROVED';
-
-UPDATE sg_qa_vector_example
-   SET answer_text = NVL(answer_text, '') || ' This unavailable-object case must not fabricate a DUAL/NULL result row. Return no result rows and explain that no approved physical object is available for the resolved game.',
-       inspection_note = 'Customer QA verified: unavailable game objects return no result rows; no synthetic DUAL result.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-01';
-
-COMMIT;

database/adb/107_sgmp_separate_customer_qa_from_fewshot.sql

@@ -1,64 +0,0 @@
--- Customer QA is evaluation data, never production Few-shot context.
--- Preserve it for SG_AI_QA_* baseline/history audit while retiring its vector copies.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       inspection_note = 'Evaluation-only customer QA. Excluded from production Few-shot retrieval.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_EVALUATION_SEPARATION'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK';
-
-COMMIT;
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR
-AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results      SYS_REFCURSOR;
-  v_target_type  VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'target_type must be NONE, SINGLE, MULTI, ALL, or ANY.');
-  END IF;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id,
-           question,
-           answer_sql,
-           answer_text,
-           embedding_model,
-           reference_kind,
-           target_type,
-           object_role,
-           source_case_id,
-           source_type,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     WHERE reference_status = 'APPROVED'
-       AND (source_type IS NULL OR source_type <> 'CUSTOMER_QA_BENCHMARK')
-       AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-     ORDER BY vector_distance(embedding, v_query_vector, COSINE), example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-SELECT source_type, reference_status, COUNT(*) AS example_count
-  FROM sg_qa_vector_example
- GROUP BY source_type, reference_status
- ORDER BY source_type, reference_status;

database/adb/108_sgmp_generate_question_specific_generalized_fewshots.sql

@@ -1,165 +0,0 @@
--- Build one generalized runtime Few-shot pattern for every customer QA case.
--- The source benchmark remains evaluation-only; this derived record contains
--- no customer game name, date literal, expected result, or physical CZN object.
-
-DECLARE
-  v_pattern_question CLOB;
-  v_pattern_sql      CLOB;
-  v_embedding_input  CLOB;
-  v_embedding        VECTOR;
-  v_object_role      VARCHAR2(64);
-  v_exists           NUMBER;
-
-  FUNCTION generalized_question(p_question CLOB) RETURN CLOB IS
-    v_value CLOB := p_question;
-  BEGIN
-    -- Resolved names/aliases become a semantic game placeholder.
-    FOR token IN (
-      SELECT column_value AS value
-        FROM TABLE(sys.odcivarchar2list(
-          '카오스 제로 나이트메어', '카오스제로나이트메어', 'Chaos Zero Nightmare',
-          'STOVE_CHAOSZERO', '카제나', 'CZN', 'Bubblyz', '버블리즈',
-          '로드나인', '로나', '테스트게임', 'BUBBLYZ', 'LORDNINE'
-        ))
-    ) LOOP
-      v_value := REPLACE(v_value, token.value, '<게임>');
-    END LOOP;
-    v_value := REGEXP_REPLACE(v_value, '[0-9]{4}년[[:space:]]*[0-9]{1,2}월[[:space:]]*[0-9]{1,2}일', '<기준일>');
-    v_value := REGEXP_REPLACE(v_value, '[0-9]{4}-[0-9]{2}-[0-9]{2}', '<기준일>');
-    RETURN v_value;
-  END;
-
-  FUNCTION generalized_sql(p_sql CLOB) RETURN CLOB IS
-    v_value CLOB := p_sql;
-  BEGIN
-    -- Physical game objects become logical roles. Common dimensions remain
-    -- logical as well so the current metadata/plan selects real objects.
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_COMN_USER_MST"', '<RESOLVED_GAME_USER_MASTER>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_COMN_CHARACTER_MST"', '<RESOLVED_GAME_CHARACTER_MASTER>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_CUSTOM_GOODS_HAVE_TXN"', '<RESOLVED_GAME_GOODS_HOLDINGS>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_CUSTOM_GOODS_CHANGE_TXN"', '<RESOLVED_GAME_GOODS_CHANGE>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_CUSTOM_BIZ_USER_TXN"', '<RESOLVED_GAME_BUSINESS_USER>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_CUSTOM_USER_GOODS_TXN"', '<RESOLVED_GAME_USER_GOODS>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."COMN_SALES_TXN"', '<APPROVED_SALES_TRANSACTION>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."COMN_REFUND_TXN"', '<APPROVED_REFUND_TRANSACTION>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."COMN_GAME_ALIAS_BAS"', '<GAME_ALIAS_CATALOG>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."COMN_COUNTRY_BAS"', '<COUNTRY_DIMENSION>');
-    v_value := REPLACE(v_value, '"SGMP_POC"."CZN_COMN_SVC_DIM_BAS"', '<RESOLVED_GAME_SERVICE_DIMENSION>');
-    v_value := REPLACE(v_value, 'STOVE_CHAOSZERO', '<RESOLVED_GAME_ID>');
-    v_value := REPLACE(v_value, '''카제나''', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, '''CZN''', '<RESOLVED_GAME_PREFIX>');
-    v_value := REGEXP_REPLACE(v_value, 'CZN_[A-Z0-9_]+', '<RESOLVED_GAME_OBJECT>');
-    v_value := REPLACE(v_value, '카제나', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, '카오스 제로 나이트메어', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, '카오스제로나이트메어', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, 'CZN', '<RESOLVED_GAME_PREFIX>');
-    v_value := REPLACE(v_value, 'BUBBLYZ', '<RESOLVED_GAME_ID>');
-    v_value := REPLACE(v_value, 'Bubblyz', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, '버블리즈', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, 'LORDNINE', '<RESOLVED_GAME_ID>');
-    v_value := REPLACE(v_value, '로드나인', '<RESOLVED_GAME_NAME>');
-    v_value := REPLACE(v_value, '테스트게임', '<RESOLVED_GAME_NAME>');
-    v_value := REGEXP_REPLACE(v_value, 'TO_DATE\(''[0-9]{4}-[0-9]{2}-[0-9]{2}'', ''YYYY-MM-DD''\)', '<BUSINESS_DATE>');
-    v_value := REGEXP_REPLACE(v_value, 'TO_DATE\(''[0-9]{8}'', ''YYYYMMDD''\)', '<BUSINESS_DATE>');
-    v_value := REGEXP_REPLACE(v_value, 'DATE ''[0-9]{4}-[0-9]{2}-[0-9]{2}''', '<BUSINESS_DATE>');
-    RETURN v_value;
-  END;
-
-  FUNCTION role_of(p_sql CLOB) RETURN VARCHAR2 IS
-  BEGIN
-    IF DBMS_LOB.INSTR(p_sql, 'CZN_COMN_CHARACTER_MST') > 0 THEN
-      RETURN 'GAME_CHARACTER_MASTER';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'CZN_CUSTOM_GOODS_HAVE_TXN') > 0 THEN
-      RETURN 'GAME_GOODS_HOLDINGS';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'CZN_CUSTOM_GOODS_CHANGE_TXN') > 0 THEN
-      RETURN 'GAME_GOODS_CHANGE';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'CZN_CUSTOM_BIZ_USER_TXN') > 0 THEN
-      RETURN 'GAME_BUSINESS_USER';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'COMN_SALES_TXN') > 0 THEN
-      RETURN 'SALES_TRANSACTION';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'COMN_REFUND_TXN') > 0 THEN
-      RETURN 'REFUND_TRANSACTION';
-    ELSIF DBMS_LOB.INSTR(p_sql, 'CZN_COMN_USER_MST') > 0 THEN
-      RETURN 'GAME_USER_MASTER';
-    END IF;
-    RETURN 'METADATA_OR_OPERATION';
-  END;
-BEGIN
-  FOR source_row IN (
-    SELECT example_id, source_case_id, question, answer_sql
-      FROM sg_qa_vector_example
-     WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-     ORDER BY source_case_id
-  ) LOOP
-    v_pattern_question := generalized_question(source_row.question);
-    v_pattern_sql := generalized_sql(source_row.answer_sql);
-    v_object_role := role_of(source_row.answer_sql);
-    v_embedding_input := TO_CLOB('Generalized question pattern: ') || v_pattern_question
-      || CHR(10) || 'Logical object role: ' || v_object_role
-      || CHR(10) || 'Structural SQL template: ' || v_pattern_sql
-      || CHR(10) || 'Use only current game scope metadata and replace placeholders from the current request.';
-
-    -- A generalized runtime pattern must not contain known customer answer
-    -- identifiers or fixed business-date literals.
-    IF REGEXP_LIKE(v_pattern_question,
-          '카제나|버블리즈|Bubblyz|로드나인|테스트게임|[0-9]{4}년|[0-9]{4}-[0-9]{2}-[0-9]{2}', 'i')
-       OR REGEXP_LIKE(v_pattern_sql,
-          'CZN_|STOVE_CHAOSZERO|카제나|버블리즈|Bubblyz|[0-9]{4}-[0-9]{2}-[0-9]{2}', 'i') THEN
-      RAISE_APPLICATION_ERROR(-20061, 'Generalization leak in ' || source_row.source_case_id);
-    END IF;
-
-    v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-      v_embedding_input,
-      JSON(sg_qa_vector_params('search_document'))
-    );
-
-    SELECT COUNT(*)
-      INTO v_exists
-      FROM sg_qa_vector_example
-     WHERE source_type = 'GENERALIZED_QUESTION_PATTERN'
-       AND source_case_id = 'PAT-' || source_row.source_case_id;
-
-    IF v_exists = 0 THEN
-      INSERT INTO sg_qa_vector_example (
-        question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-        reference_status, reference_kind, target_type, object_role,
-        inspection_status, inspection_note, verified_at, verified_by,
-        source_case_id, source_type
-      ) VALUES (
-        v_pattern_question,
-        v_pattern_sql,
-        'Question-specific generalized Few-shot. Structural only: it contains no customer game, date, result, or executable answer. First decide whether this pattern is applicable; then apply the authoritative NONE/SINGLE/MULTI/ALL game plan and replace placeholders from current metadata.',
-        v_embedding_input,
-        v_embedding,
-        'cohere.embed-v4.0',
-        'APPROVED', 'SQL_TEMPLATE', 'ANY', v_object_role,
-        'VERIFIED',
-        'Derived from a customer QA structure after game/date/result/object leakage validation; runtime uses this generalized pattern only.',
-        SYSTIMESTAMP, 'SGMP_POC_PATTERN_REVIEW',
-        'PAT-' || source_row.source_case_id, 'GENERALIZED_QUESTION_PATTERN'
-      );
-    ELSE
-      UPDATE sg_qa_vector_example
-         SET question = v_pattern_question,
-             answer_sql = v_pattern_sql,
-             answer_text = 'Question-specific generalized Few-shot. Structural only: it contains no customer game, date, result, or executable answer. First decide whether this pattern is applicable; then apply the authoritative NONE/SINGLE/MULTI/ALL game plan and replace placeholders from current metadata.',
-             embedding_input = v_embedding_input,
-             embedding = v_embedding,
-             object_role = v_object_role,
-             reference_status = 'APPROVED',
-             inspection_status = 'VERIFIED',
-             inspection_note = 'Derived from a customer QA structure after game/date/result/object leakage validation; runtime uses this generalized pattern only.',
-             verified_at = SYSTIMESTAMP,
-             verified_by = 'SGMP_POC_PATTERN_REVIEW'
-       WHERE source_type = 'GENERALIZED_QUESTION_PATTERN'
-         AND source_case_id = 'PAT-' || source_row.source_case_id;
-    END IF;
-  END LOOP;
-  COMMIT;
-END;
-/
-
-SELECT source_type, reference_status, COUNT(*) AS example_count
-  FROM sg_qa_vector_example
- GROUP BY source_type, reference_status
- ORDER BY source_type, reference_status;

database/adb/109_sgmp_genai_question_specific_fewshot_patterns.sql

@@ -1,358 +0,0 @@
--- Generate one reusable, question-specific Few-shot pattern per customer QA
--- benchmark without promoting the benchmark answer itself.  Game identity is
--- deliberately not inferred here: sg_game_query_plan owns that through OCI
--- GenAI chat + the current game catalog.
-
-CREATE OR REPLACE FUNCTION sg_qa_genai_generalize_pattern(
-  p_question   IN CLOB,
-  p_answer_sql IN CLOB,
-  p_target_type IN VARCHAR2
-) RETURN CLOB AUTHID DEFINER
-IS
-  v_prompt CLOB;
-  v_result CLOB;
-BEGIN
-  v_prompt :=
-    'Create one reusable, question-specific Few-shot SQL pattern from the source example. '
-    || 'This is training guidance, never an answer key. Return exactly these tagged sections and nothing else: '
-    || '[[PATTERN_QUESTION]], [[STRUCTURAL_SQL_PATTERN]], [[OBJECT_ROLE]], [[TARGET_TYPE]], '
-    || '[[APPLICABILITY]], [[END]]. '
-    || 'Preserve only the query intent and structural operations such as aggregation, joins, '
-    || 'grouping, ordering, date semantics, and filters. Replace every game name, alias, game ID, '
-    || 'schema name, physical object name, column name, literal date, literal number, user ID, '
-    || 'currency amount, and expected output with semantic placeholders such as <GAME_SCOPE>, '
-    || '<LOGICAL_FACT>, <LOGICAL_DIMENSION>, <METRIC>, <AS_OF_DATE>, <FILTER>, and <GROUPING>. '
-    || 'In STRUCTURAL_SQL_PATTERN, every non-SQL identifier must be an angle-bracket placeholder: '
-    || 'do not retain any source column, alias, table, schema, literal, code, or business value. '
-    || 'Do not include executable SQL. Do not include a game name or a customer answer. '
-    || 'The current game scope is supplied separately at runtime by a database OCI GenAI chat '
-    || 'resolver, therefore never choose or imply a game. The TARGET_TYPE section must be one of NONE, '
-    || 'SINGLE, MULTI, ALL, ANY and must describe applicability, not a game identity. '
-    || 'Source target type from the current resolver: ' || NVL(p_target_type, 'ANY') || CHR(10)
-    || 'Source question:' || CHR(10) || DBMS_LOB.SUBSTR(p_question, 4000, 1) || CHR(10)
-    || 'Source SQL (structure only; do not copy identifiers or values):' || CHR(10)
-    || DBMS_LOB.SUBSTR(p_answer_sql, 12000, 1);
-  v_result := DBMS_CLOUD_AI.GENERATE(
-    prompt => v_prompt,
-    profile_name => 'SGMP_POC_OCI_GPT54MINI',
-    action => 'chat'
-  );
-  RETURN v_result;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_genai_validate_pattern(
-  p_pattern_json IN CLOB
-) RETURN CLOB AUTHID DEFINER
-IS
-  v_prompt CLOB;
-  v_result CLOB;
-BEGIN
-  v_prompt :=
-    'Inspect only concrete-answer leakage in this reusable Few-shot pattern. Return exactly '
-    || '[[CONCRETE_LEAKAGE]] YES or NO, then [[REASON]] and a short reason, then [[END]]. '
-    || 'Return YES only when a customer answer, concrete game identity, physical schema/table/column '
-    || 'identifier, literal date, literal business result, or executable SQL against a real object remains. '
-    || 'Return NO when all such references are semantic angle-bracket placeholders. A pseudo-SQL pattern '
-    || 'using SELECT/FROM/JOIN/GROUP BY, generic game-scope checks, EXISTS, UNION, or equality with '
-    || 'angle-bracket placeholders is not concrete leakage and must return NO. Do not judge usefulness or '
-    || 'completeness; classify leakage only. '
-    || 'Candidate:' || CHR(10) || DBMS_LOB.SUBSTR(p_pattern_json, 16000, 1);
-  v_result := DBMS_CLOUD_AI.GENERATE(
-    prompt => v_prompt,
-    profile_name => 'SGMP_POC_OCI_GPT54MINI',
-    action => 'chat'
-  );
-  RETURN v_result;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_generate_generalized_patterns
-  RETURN NUMBER AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_plan_raw       CLOB;
-  v_plan            JSON_OBJECT_T;
-  v_target_type     VARCHAR2(16);
-  v_pattern_raw     CLOB;
-  v_validation_raw  CLOB;
-  v_status          VARCHAR2(16);
-  v_validation_note CLOB;
-  v_question        CLOB;
-  v_sql_pattern     CLOB;
-  v_answer_text     CLOB;
-  v_object_role     VARCHAR2(64);
-  v_embedding_input CLOB;
-  v_embedding       VECTOR;
-  v_count           NUMBER := 0;
-
-  FUNCTION parse_json_result(p_value CLOB) RETURN JSON_OBJECT_T IS
-    v_text CLOB := TRIM(p_value);
-  BEGIN
-    IF DBMS_LOB.SUBSTR(v_text, 7, 1) = '```json' THEN
-      v_text := REGEXP_REPLACE(v_text, '^```json[[:space:]]*', '');
-      v_text := REGEXP_REPLACE(v_text, '[[:space:]]*```[[:space:]]*$', '');
-    ELSIF DBMS_LOB.SUBSTR(v_text, 3, 1) = '```' THEN
-      v_text := REGEXP_REPLACE(v_text, '^```[[:space:]]*', '');
-      v_text := REGEXP_REPLACE(v_text, '[[:space:]]*```[[:space:]]*$', '');
-    END IF;
-    RETURN JSON_OBJECT_T.parse(v_text);
-  END;
-
-  FUNCTION section_value(
-    p_raw IN CLOB, p_start_tag IN VARCHAR2, p_end_tag IN VARCHAR2
-  ) RETURN CLOB IS
-    v_start PLS_INTEGER;
-    v_end PLS_INTEGER;
-  BEGIN
-    v_start := DBMS_LOB.INSTR(p_raw, p_start_tag, 1, 1);
-    IF v_start = 0 THEN
-      RAISE_APPLICATION_ERROR(-20071, 'OCI GenAI response is missing ' || p_start_tag);
-    END IF;
-    v_start := v_start + LENGTH(p_start_tag);
-    v_end := DBMS_LOB.INSTR(p_raw, p_end_tag, v_start, 1);
-    IF v_end = 0 OR v_end <= v_start THEN
-      RAISE_APPLICATION_ERROR(-20072, 'OCI GenAI response is missing ' || p_end_tag);
-    END IF;
-    RETURN TRIM(DBMS_LOB.SUBSTR(p_raw, LEAST(v_end - v_start, 32767), v_start));
-  END;
-
-  PROCEDURE upsert_pattern(
-    p_case_id IN VARCHAR2,
-    p_status IN VARCHAR2,
-    p_note IN CLOB
-  ) IS
-  BEGIN
-    UPDATE sg_qa_vector_example
-       SET question = v_question,
-           answer_sql = v_sql_pattern,
-           answer_text = v_answer_text,
-           embedding_input = v_embedding_input,
-           embedding = v_embedding,
-           embedding_model = 'cohere.embed-v4.0',
-           reference_status = p_status,
-           reference_kind = 'SQL_PATTERN',
-           target_type = v_target_type,
-           object_role = v_object_role,
-           inspection_status = CASE WHEN p_status = 'APPROVED' THEN 'GENAI_VERIFIED' ELSE 'GENAI_REJECTED' END,
-           inspection_note = p_note,
-           verified_at = SYSTIMESTAMP,
-           verified_by = 'SGMP_POC_OCI_GENAI_PATTERN'
-     WHERE source_type = 'GENERALIZED_QUESTION_PATTERN'
-       AND source_case_id = 'PAT-' || p_case_id;
-
-    IF SQL%ROWCOUNT = 0 THEN
-      INSERT INTO sg_qa_vector_example (
-        question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-        reference_status, reference_kind, target_type, object_role, inspection_status,
-        inspection_note, verified_at, verified_by, source_case_id, source_type
-      ) VALUES (
-        v_question, v_sql_pattern, v_answer_text, v_embedding_input, v_embedding, 'cohere.embed-v4.0',
-        p_status, 'SQL_PATTERN', v_target_type, v_object_role,
-        CASE WHEN p_status = 'APPROVED' THEN 'GENAI_VERIFIED' ELSE 'GENAI_REJECTED' END,
-        p_note, SYSTIMESTAMP, 'SGMP_POC_OCI_GENAI_PATTERN',
-        'PAT-' || p_case_id, 'GENERALIZED_QUESTION_PATTERN'
-      );
-    END IF;
-  END;
-BEGIN
-  FOR source_row IN (
-    SELECT source.source_case_id, source.question, source.answer_sql
-      FROM sg_qa_vector_example source
-     WHERE source.source_type = 'CUSTOMER_QA_BENCHMARK'
-       AND NOT EXISTS (
-         SELECT 1
-           FROM sg_qa_vector_example pattern
-          WHERE pattern.source_type = 'GENERALIZED_QUESTION_PATTERN'
-            AND pattern.source_case_id = 'PAT-' || source.source_case_id
-            AND pattern.reference_status = 'APPROVED'
-       )
-     ORDER BY source_case_id
-  ) LOOP
-    BEGIN
-      -- The target category comes from the existing OCI GenAI game resolver;
-      -- no alias, prefix, table, or name is transformed in this migration.
-      v_plan_raw := sg_game_query_plan(source_row.question, 5);
-      v_plan := parse_json_result(v_plan_raw);
-      v_target_type := UPPER(NVL(v_plan.get_string('targetType'), 'ANY'));
-      IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL') THEN
-        v_target_type := 'ANY';
-      END IF;
-
-      v_pattern_raw := sg_qa_genai_generalize_pattern(
-        source_row.question, source_row.answer_sql, v_target_type
-      );
-      v_question := section_value(v_pattern_raw, '[[PATTERN_QUESTION]]', '[[STRUCTURAL_SQL_PATTERN]]');
-      v_sql_pattern := section_value(v_pattern_raw, '[[STRUCTURAL_SQL_PATTERN]]', '[[OBJECT_ROLE]]');
-      v_object_role := SUBSTR(section_value(v_pattern_raw, '[[OBJECT_ROLE]]', '[[TARGET_TYPE]]'), 1, 64);
-      IF section_value(v_pattern_raw, '[[TARGET_TYPE]]', '[[APPLICABILITY]]')
-          IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-        v_target_type := section_value(v_pattern_raw, '[[TARGET_TYPE]]', '[[APPLICABILITY]]');
-      END IF;
-      v_answer_text := TO_CLOB('Generalized, question-specific structural pattern. '
-        || 'Current game scope must be supplied only by sg_game_query_plan. Applicability: ')
-        || section_value(v_pattern_raw, '[[APPLICABILITY]]', '[[END]]');
-      v_embedding_input := TO_CLOB('Question-specific generalized Few-shot pattern:' || CHR(10))
-        || v_question || CHR(10) || 'Logical role: ' || v_object_role || CHR(10)
-        || 'Structural SQL pattern:' || CHR(10) || v_sql_pattern;
-      v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-        v_embedding_input, JSON(sg_qa_vector_params('search_document'))
-      );
-      v_validation_raw := sg_qa_genai_validate_pattern(v_pattern_raw);
-      v_status := CASE
-        WHEN REGEXP_SUBSTR(
-          UPPER(section_value(v_validation_raw, '[[CONCRETE_LEAKAGE]]', '[[REASON]]')),
-          '[A-Z]+'
-        ) = 'NO'
-          THEN 'APPROVE'
-        ELSE 'REJECT'
-      END;
-      v_validation_note := section_value(v_validation_raw, '[[REASON]]', '[[END]]');
-
-      IF v_status = 'APPROVE' THEN
-        upsert_pattern(source_row.source_case_id, 'APPROVED',
-          'ADB OCI GenAI generated and independently validated a generalized pattern. '
-          || 'The original customer QA remains evaluation-only. ' || v_validation_note);
-        v_count := v_count + 1;
-      ELSE
-        upsert_pattern(source_row.source_case_id, 'DRAFT',
-          'ADB OCI GenAI rejected the generalized pattern: ' || v_validation_note);
-      END IF;
-    EXCEPTION
-      WHEN OTHERS THEN
-        -- Persist an auditable non-runtime draft and continue with the other
-        -- customer questions; one malformed LLM response must not block all 47.
-        v_question := source_row.question;
-        v_sql_pattern := TO_CLOB('<PATTERN_GENERATION_FAILED>');
-        v_answer_text := TO_CLOB('No runtime Few-shot pattern: OCI GenAI generalization failed.');
-        v_object_role := 'UNSPECIFIED';
-        v_target_type := 'ANY';
-        v_embedding_input := TO_CLOB('Failed generalized pattern: ') || source_row.question;
-        v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-          v_embedding_input, JSON(sg_qa_vector_params('search_document'))
-        );
-        upsert_pattern(source_row.source_case_id, 'DRAFT',
-          'OCI GenAI pattern generation error: ' || SQLERRM);
-    END;
-  END LOOP;
-  COMMIT;
-  RETURN v_count;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
--- Re-run only the independent OCI Chat safety review after its policy changes.
--- It never reads a customer benchmark and never changes the generated pattern.
-CREATE OR REPLACE FUNCTION sg_qa_revalidate_generalized_patterns
-  RETURN NUMBER AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_raw CLOB;
-  v_status VARCHAR2(16);
-  v_reason CLOB;
-  v_start PLS_INTEGER;
-  v_end PLS_INTEGER;
-  v_count NUMBER := 0;
-
-  FUNCTION section_value(
-    p_raw IN CLOB, p_start_tag IN VARCHAR2, p_end_tag IN VARCHAR2
-  ) RETURN CLOB IS
-    v_from PLS_INTEGER;
-    v_to PLS_INTEGER;
-  BEGIN
-    v_from := DBMS_LOB.INSTR(p_raw, p_start_tag, 1, 1);
-    IF v_from = 0 THEN RAISE_APPLICATION_ERROR(-20073, 'Missing ' || p_start_tag); END IF;
-    v_from := v_from + LENGTH(p_start_tag);
-    v_to := DBMS_LOB.INSTR(p_raw, p_end_tag, v_from, 1);
-    IF v_to = 0 OR v_to <= v_from THEN RAISE_APPLICATION_ERROR(-20074, 'Missing ' || p_end_tag); END IF;
-    RETURN TRIM(DBMS_LOB.SUBSTR(p_raw, LEAST(v_to - v_from, 32767), v_from));
-  END;
-BEGIN
-  FOR item IN (
-    SELECT example_id, question, answer_sql, answer_text
-      FROM sg_qa_vector_example
-     WHERE source_type = 'GENERALIZED_QUESTION_PATTERN'
-     ORDER BY source_case_id
-  ) LOOP
-    BEGIN
-      v_raw := sg_qa_genai_validate_pattern(
-        TO_CLOB('[[PATTERN_QUESTION]]') || item.question
-        || TO_CLOB(CHR(10) || '[[STRUCTURAL_SQL_PATTERN]]') || item.answer_sql
-        || TO_CLOB(CHR(10) || '[[APPLICABILITY]]') || item.answer_text || CHR(10) || '[[END]]'
-      );
-      v_status := CASE
-        WHEN REGEXP_SUBSTR(
-          UPPER(section_value(v_raw, '[[CONCRETE_LEAKAGE]]', '[[REASON]]')),
-          '[A-Z]+'
-        ) = 'NO'
-          THEN 'APPROVE'
-        ELSE 'REJECT'
-      END;
-      v_reason := section_value(v_raw, '[[REASON]]', '[[END]]');
-      UPDATE sg_qa_vector_example
-         SET reference_status = CASE WHEN v_status = 'APPROVE' THEN 'APPROVED' ELSE 'DRAFT' END,
-             inspection_status = CASE WHEN v_status = 'APPROVE' THEN 'GENAI_VERIFIED' ELSE 'GENAI_REJECTED' END,
-             inspection_note = 'ADB OCI GenAI independent revalidation: ' || v_reason,
-             verified_at = SYSTIMESTAMP,
-             verified_by = 'SGMP_POC_OCI_GENAI_PATTERN'
-       WHERE example_id = item.example_id;
-      IF v_status = 'APPROVE' THEN v_count := v_count + 1; END IF;
-    EXCEPTION
-      WHEN OTHERS THEN
-        v_reason := TO_CLOB('OCI GenAI revalidation error: ' || SQLERRM);
-        UPDATE sg_qa_vector_example
-           SET reference_status = 'DRAFT',
-               inspection_status = 'GENAI_REJECTED',
-               inspection_note = v_reason,
-               verified_at = SYSTIMESTAMP,
-               verified_by = 'SGMP_POC_OCI_GENAI_PATTERN'
-         WHERE example_id = item.example_id;
-    END;
-  END LOOP;
-  COMMIT;
-  RETURN v_count;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
--- Production retrieval accepts only independently generalized patterns or
--- policy templates. Customer QA benchmarks remain evaluation-only forever.
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-BEGIN
-  IF p_question IS NULL THEN RAISE_APPLICATION_ERROR(-20003, 'question is required.'); END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     WHERE reference_status = 'APPROVED'
-       AND source_type IN ('GENERALIZED_QUESTION_PATTERN', 'POLICY_TEMPLATE')
-       AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-     ORDER BY vector_distance(embedding, v_query_vector, COSINE), example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/

database/adb/110_sg_game_query_plan_admin_grants.sql

@@ -1,9 +0,0 @@
--- The MCP DB account owns the OCI GenAI planning functions while the game
--- catalog is owned by the data schema. Definer-rights PL/SQL needs direct
--- object grants; role grants are not sufficient at compile time.
-BEGIN
-  EXECUTE IMMEDIATE 'GRANT SELECT ON SGMP_POC.SG_GAME_CATALOG TO ADMIN';
-  EXECUTE IMMEDIATE 'GRANT SELECT ON SGMP_POC.COMN_GAME_ALIAS_BAS TO ADMIN';
-  EXECUTE IMMEDIATE 'GRANT EXECUTE ON SGMP_POC.SG_GAME_CATALOG_SEARCH TO ADMIN';
-END;
-/

database/adb/111_sg_game_daily_au_lookup.sql

@@ -1,148 +0,0 @@
--- Deterministic daily-AU lookup for an already resolved game query plan.
--- Physical user-master objects are selected only from SG_GAME_CATALOG.
--- No game name, alias, prefix, or object name is embedded in this function.
-
-CREATE OR REPLACE FUNCTION sg_game_daily_au_lookup(
-  p_query_plan IN CLOB,
-  p_base_date  IN DATE DEFAULT NULL
-) RETURN CLOB AUTHID DEFINER IS
-  v_plan             JSON_OBJECT_T;
-  v_targets          JSON_ARRAY_T;
-  v_target           JSON_OBJECT_T;
-  v_result           JSON_OBJECT_T := JSON_OBJECT_T();
-  v_items            JSON_ARRAY_T := JSON_ARRAY_T();
-  v_item             JSON_OBJECT_T;
-  v_game_key         VARCHAR2(128);
-  v_game_id          VARCHAR2(128);
-  v_game_name        VARCHAR2(512);
-  v_object_name      VARCHAR2(128);
-  v_safe_object_name VARCHAR2(128);
-  v_effective_date   DATE;
-  v_au_count         NUMBER;
-  v_column_count     PLS_INTEGER;
-  v_object_count     PLS_INTEGER;
-  v_seen             SYS.ODCIVARCHAR2LIST := SYS.ODCIVARCHAR2LIST();
-  v_target_count     PLS_INTEGER := 0;
-
-  FUNCTION is_seen(p_game_key IN VARCHAR2) RETURN BOOLEAN IS
-  BEGIN
-    FOR i IN 1 .. v_seen.COUNT LOOP
-      IF v_seen(i) = p_game_key THEN
-        RETURN TRUE;
-      END IF;
-    END LOOP;
-    RETURN FALSE;
-  END;
-
-  PROCEDURE add_status(
-    p_game_key IN VARCHAR2,
-    p_status   IN VARCHAR2,
-    p_reason   IN VARCHAR2
-  ) IS
-  BEGIN
-    v_item := JSON_OBJECT_T();
-    v_item.put('gameKey', p_game_key);
-    v_item.put('status', p_status);
-    v_item.put('reason', p_reason);
-    v_items.append(v_item);
-  END;
-BEGIN
-  IF p_query_plan IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20001, 'queryPlan is required');
-  END IF;
-
-  v_plan := JSON_OBJECT_T.parse(p_query_plan);
-  v_targets := v_plan.get_array('dataEligibleTargets');
-  IF v_targets IS NULL THEN
-    v_targets := v_plan.get_array('targets');
-  END IF;
-
-  IF v_targets IS NOT NULL AND v_targets.get_size > 0 THEN
-    FOR i IN 0 .. v_targets.get_size - 1 LOOP
-      v_target := TREAT(v_targets.get(i) AS JSON_OBJECT_T);
-      IF v_target IS NULL OR NOT v_target.has('gameKey') THEN
-        CONTINUE;
-      END IF;
-      v_game_key := v_target.get_string('gameKey');
-      IF v_game_key IS NULL OR is_seen(v_game_key) THEN
-        CONTINUE;
-      END IF;
-      v_seen.EXTEND;
-      v_seen(v_seen.COUNT) := v_game_key;
-      v_target_count := v_target_count + 1;
-
-      BEGIN
-        SELECT game_id, game_nm, user_master_object_name
-          INTO v_game_id, v_game_name, v_object_name
-          FROM sg_game_catalog
-         WHERE game_key = v_game_key
-           AND active_yn = 'Y';
-      EXCEPTION
-        WHEN NO_DATA_FOUND THEN
-          add_status(v_game_key, 'UNAVAILABLE', 'Catalog target is not active.');
-          CONTINUE;
-      END;
-
-      IF v_object_name IS NULL THEN
-        add_status(v_game_key, 'UNAVAILABLE', 'No approved user-master object is registered.');
-        CONTINUE;
-      END IF;
-
-      v_safe_object_name := DBMS_ASSERT.SIMPLE_SQL_NAME(UPPER(v_object_name));
-      SELECT COUNT(*) INTO v_object_count
-        FROM user_objects
-       WHERE object_name = v_safe_object_name
-         AND object_type IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW')
-         AND status = 'VALID';
-      SELECT COUNT(*) INTO v_column_count
-        FROM user_tab_columns
-       WHERE table_name = v_safe_object_name
-         AND column_name IN ('GUID', 'BASE_DT', 'AU_FLAG', 'EXPT_USER_YN');
-      IF v_object_count = 0 OR v_column_count <> 4 THEN
-        add_status(v_game_key, 'UNAVAILABLE', 'Approved user-master object is not query-ready.');
-        CONTINUE;
-      END IF;
-
-      IF p_base_date IS NULL THEN
-        EXECUTE IMMEDIATE 'SELECT MAX(BASE_DT) FROM ' || v_safe_object_name
-          INTO v_effective_date;
-      ELSE
-        v_effective_date := TRUNC(p_base_date);
-      END IF;
-      IF v_effective_date IS NULL THEN
-        add_status(v_game_key, 'NO_DATA', 'No available base date in the selected object.');
-        CONTINUE;
-      END IF;
-
-      EXECUTE IMMEDIATE
-          'SELECT COUNT(DISTINCT GUID) FROM ' || v_safe_object_name
-          || ' WHERE BASE_DT = :1 AND AU_FLAG = 1 AND EXPT_USER_YN = ''N'''
-        INTO v_au_count USING v_effective_date;
-
-      v_item := JSON_OBJECT_T();
-      v_item.put('gameKey', v_game_key);
-      v_item.put('gameId', v_game_id);
-      v_item.put('gameName', v_game_name);
-      v_item.put('objectName', v_safe_object_name);
-      v_item.put('baseDate', TO_CHAR(v_effective_date, 'YYYY-MM-DD'));
-      v_item.put('auCount', v_au_count);
-      v_item.put('status', 'READY');
-      v_item.put('sqlTemplate',
-          'SELECT COUNT(DISTINCT GUID) AS AU_COUNT FROM <catalog_user_master_object> '
-          || 'WHERE BASE_DT = :baseDate AND AU_FLAG = 1 AND EXPT_USER_YN = ''N''');
-      v_items.append(v_item);
-    END LOOP;
-  END IF;
-
-  v_result.put('status', CASE WHEN v_target_count = 0 THEN 'NO_GAME_TARGET' ELSE 'GAME_AU_LOOKUP' END);
-  v_result.put('targetType', NVL(v_plan.get_string('targetType'), 'NONE'));
-  IF p_base_date IS NULL THEN
-    v_result.put_null('requestedBaseDate');
-  ELSE
-    v_result.put('requestedBaseDate', TO_CHAR(TRUNC(p_base_date), 'YYYY-MM-DD'));
-  END IF;
-  v_result.put('targetCount', v_target_count);
-  v_result.put('items', v_items);
-  RETURN v_result.to_clob;
-END;
-/

database/adb/112_sgmp_select_ai_oci_llama4scout_profile.sql

@@ -1,81 +0,0 @@
--- Creates a non-operational comparison profile for Smilegate game-scope chat.
--- The active GPT profile remains unchanged. Provider credentials and profile
--- metadata are copied from it so the only comparison variable is the model.
-
-DECLARE
-  v_exists PLS_INTEGER;
-  v_credential_name VARCHAR2(128);
-  v_region VARCHAR2(128);
-  v_compartment_id VARCHAR2(4000);
-  v_attributes CLOB;
-  v_attribute_json JSON_OBJECT_T := JSON_OBJECT_T();
-BEGIN
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM user_cloud_ai_profiles
-   WHERE profile_name = 'SGMP_POC_OCI_LLAMA4SCOUT';
-
-  IF v_exists > 0 THEN
-    DBMS_CLOUD_AI.DROP_PROFILE(
-      profile_name => 'SGMP_POC_OCI_LLAMA4SCOUT',
-      force        => TRUE
-    );
-  END IF;
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_credential_name
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'credential_name';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_region
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'region';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 4000, 1)
-    INTO v_compartment_id
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'oci_compartment_id';
-
-  v_attribute_json.put('provider', 'oci');
-  v_attribute_json.put('credential_name', v_credential_name);
-  v_attribute_json.put('model', 'meta.llama-4-scout-17b-16e-instruct');
-  v_attribute_json.put('region', v_region);
-  v_attribute_json.put('oci_compartment_id', v_compartment_id);
-  v_attributes := v_attribute_json.to_clob;
-
-  DBMS_CLOUD_AI.CREATE_PROFILE(
-    profile_name => 'SGMP_POC_OCI_LLAMA4SCOUT',
-    attributes   => v_attributes,
-    description  => 'Non-operational Smilegate game-scope latency comparison'
-  );
-
-  FOR source_attribute IN (
-    SELECT attribute_name, attribute_value
-      FROM user_cloud_ai_profile_attributes
-     WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-       AND attribute_name NOT IN (
-         'credential_name', 'model', 'provider', 'provider_endpoint',
-         'region', 'oci_compartment_id', 'oci_endpoint_id',
-         'oci_apiformat', 'oci_runtimetype'
-       )
-  ) LOOP
-    DBMS_CLOUD_AI.SET_ATTRIBUTE(
-      profile_name    => 'SGMP_POC_OCI_LLAMA4SCOUT',
-      attribute_name  => source_attribute.attribute_name,
-      attribute_value => source_attribute.attribute_value
-    );
-  END LOOP;
-END;
-/
-
-SELECT attribute_name, attribute_value
-  FROM user_cloud_ai_profile_attributes
- WHERE profile_name = 'SGMP_POC_OCI_LLAMA4SCOUT'
-   AND attribute_name IN (
-     'provider', 'model', 'credential_name', 'region', 'oci_compartment_id'
-   )
- ORDER BY attribute_name;

database/adb/113_sgmp_game_scope_chat_profile_benchmark.sql

@@ -1,60 +0,0 @@
--- Read-only latency and JSON-shape comparison for the game-mention extraction
--- stage. Korean input is reconstructed from UTF-8 base64 for SQLcl safety.
-
-set serveroutput on size unlimited
-
-DECLARE
-  v_question CLOB := utl_i18n.raw_to_char(
-    utl_encode.base64_decode(utl_raw.cast_to_raw(
-      '66Gc65Oc64KY7J247J20656RIOy5tOygnOuCmOydmCAyMDI264WEIDfsm5QgMTXsnbwgQVXrpbwg6rCB6rCBIOyVjOugpOykmC4='
-    )),
-    'AL32UTF8'
-  );
-  v_prompt CLOB;
-  v_result CLOB;
-  v_json JSON_OBJECT_T;
-  v_started PLS_INTEGER;
-  v_elapsed_seconds NUMBER;
-
-  PROCEDURE run_profile(p_profile_name IN VARCHAR2) IS
-  BEGIN
-    v_started := DBMS_UTILITY.GET_TIME;
-    v_result := DBMS_CLOUD_AI.GENERATE(
-      prompt => v_prompt,
-      profile_name => p_profile_name,
-      action => 'chat'
-    );
-    v_elapsed_seconds := (DBMS_UTILITY.GET_TIME - v_started) / 100;
-    v_json := JSON_OBJECT_T.parse(v_result);
-    DBMS_OUTPUT.PUT_LINE(
-      p_profile_name
-      || '|elapsed_seconds=' || TO_CHAR(v_elapsed_seconds, 'FM9990D00')
-      || '|scope_hint=' || NVL(v_json.get_string('scope_hint'), 'NULL')
-      || '|mention_count=' || v_json.get_array('game_mentions').get_size
-    );
-  EXCEPTION
-    WHEN OTHERS THEN
-      DBMS_OUTPUT.PUT_LINE(
-        p_profile_name || '|elapsed_seconds='
-        || TO_CHAR(v_elapsed_seconds, 'FM9990D00')
-        || '|ERROR|' || SQLCODE || '|' || SUBSTR(SQLERRM, 1, 300)
-      );
-      DBMS_OUTPUT.PUT_LINE(
-        p_profile_name || '|raw_response=' || DBMS_LOB.SUBSTR(v_result, 1000, 1)
-      );
-  END;
-BEGIN
-  v_prompt := 'Extract only game-name mentions from the user question. '
-    || 'Metrics, acronyms, dates, filters, and database object or column names are not game names unless they are themselves an explicit game title. '
-    || 'When a title-like noun directly qualifies a game data request such as user master, character, sales, AU, NRU, server, or game log, preserve that noun as a game-name mention even when it is not in a catalog. '
-    || 'Do not discard an unknown title merely because it cannot be resolved. General scope words such as common, overall, all, total, or every are not game-name mentions unless they are part of an explicit title. '
-    || 'Return exactly one JSON object with keys game_mentions (array of strings) '
-    || 'and scope_hint (GLOBAL, SINGLE_GAME, MULTI_GAME, ALL_GAMES, UNKNOWN). '
-    || 'Do not resolve names to IDs and do not generate SQL. '
-    || 'Return raw JSON only: no prose, no Markdown, and no code fence. Question: '
-    || v_question;
-
-  run_profile('SGMP_POC_OCI_GPT54MINI');
-  run_profile('SGMP_POC_OCI_LLAMA4SCOUT');
-END;
-/

database/adb/114_sgmp_create_scope_chat_candidate_profiles.sql

@@ -1,90 +0,0 @@
--- Creates non-operational OCI profiles for game-scope extraction benchmarks.
--- Every profile inherits the active GPT profile's OCI credential, region,
--- object list, and metadata. Only model is varied.
-
-DECLARE
-  v_credential_name VARCHAR2(128);
-  v_region VARCHAR2(128);
-  v_compartment_id VARCHAR2(4000);
-  v_attributes CLOB;
-  v_attribute_json JSON_OBJECT_T;
-  v_exists PLS_INTEGER;
-
-  PROCEDURE create_candidate(
-    p_profile_name IN VARCHAR2,
-    p_model IN VARCHAR2
-  ) IS
-  BEGIN
-    SELECT COUNT(*)
-      INTO v_exists
-      FROM user_cloud_ai_profiles
-     WHERE profile_name = p_profile_name;
-
-    IF v_exists > 0 THEN
-      DBMS_CLOUD_AI.DROP_PROFILE(profile_name => p_profile_name, force => TRUE);
-    END IF;
-
-    v_attribute_json := JSON_OBJECT_T();
-    v_attribute_json.put('provider', 'oci');
-    v_attribute_json.put('credential_name', v_credential_name);
-    v_attribute_json.put('model', p_model);
-    v_attribute_json.put('region', v_region);
-    v_attribute_json.put('oci_compartment_id', v_compartment_id);
-    v_attributes := v_attribute_json.to_clob;
-
-    DBMS_CLOUD_AI.CREATE_PROFILE(
-      profile_name => p_profile_name,
-      attributes   => v_attributes,
-      description  => 'Non-operational Smilegate game-scope benchmark profile'
-    );
-
-    FOR source_attribute IN (
-      SELECT attribute_name, attribute_value
-        FROM user_cloud_ai_profile_attributes
-       WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-         AND attribute_name NOT IN (
-           'credential_name', 'model', 'provider', 'provider_endpoint',
-           'region', 'oci_compartment_id', 'oci_endpoint_id',
-           'oci_apiformat', 'oci_runtimetype'
-         )
-    ) LOOP
-      DBMS_CLOUD_AI.SET_ATTRIBUTE(
-        profile_name    => p_profile_name,
-        attribute_name  => source_attribute.attribute_name,
-        attribute_value => source_attribute.attribute_value
-      );
-    END LOOP;
-  END;
-BEGIN
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_credential_name
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'credential_name';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_region
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'region';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 4000, 1)
-    INTO v_compartment_id
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'oci_compartment_id';
-
-  create_candidate('SGMP_SCOPE_COHERE_VISION', 'cohere.command-a-vision');
-  create_candidate('SGMP_SCOPE_COHERE_COMMAND', 'cohere.command-latest');
-  create_candidate('SGMP_SCOPE_COHERE_PLUS', 'cohere.command-plus-latest');
-  create_candidate('SGMP_SCOPE_GEMINI_FLASH', 'google.gemini-2.5-flash-lite');
-  create_candidate('SGMP_SCOPE_LLAMA_MAV', 'meta.llama-4-maverick-17b-128e-instruct-fp8');
-  create_candidate('SGMP_SCOPE_GROK_NONR', 'xai.grok-4.20-non-reasoning');
-END;
-/
-
-SELECT profile_name, attribute_value AS model
-  FROM user_cloud_ai_profile_attributes
- WHERE profile_name LIKE 'SGMP_SCOPE_%'
-   AND attribute_name = 'model'
- ORDER BY profile_name;

database/adb/115_sgmp_scope_chat_candidate_benchmark.sql

@@ -1,112 +0,0 @@
--- Read-only benchmark for candidate game-scope extraction profiles.
--- Korean test questions use UTF-8 base64 reconstruction for SQLcl safety.
-
-set serveroutput on size unlimited
-prompt SG_SCOPE_PROFILE_BENCHMARK_LOADED
-
-DECLARE
-  TYPE t_case IS RECORD (
-    case_name VARCHAR2(12),
-    question CLOB,
-    expected_scope VARCHAR2(20),
-    expected_mentions PLS_INTEGER
-  );
-  TYPE t_cases IS TABLE OF t_case INDEX BY PLS_INTEGER;
-  v_cases t_cases;
-  v_prompt_prefix CLOB :=
-    'Extract only game-name mentions from the user question. '
-    || 'Metrics, acronyms, dates, filters, and database object or column names are not game names unless they are themselves an explicit game title. '
-    || 'When a title-like noun directly qualifies a game data request such as user master, character, sales, AU, NRU, server, or game log, preserve that noun as a game-name mention even when it is not in a catalog. '
-    || 'Do not discard an unknown title merely because it cannot be resolved. General scope words such as common, overall, all, total, or every are not game-name mentions unless they are part of an explicit title. '
-    || 'Return exactly one JSON object with keys game_mentions (array of strings) '
-    || 'and scope_hint (GLOBAL, SINGLE_GAME, MULTI_GAME, ALL_GAMES, UNKNOWN). '
-    || 'Do not resolve names to IDs and do not generate SQL. '
-    || 'Return raw JSON only: no prose, no Markdown, and no code fence. Question: ';
-  v_result CLOB;
-  v_json JSON_OBJECT_T;
-  v_started PLS_INTEGER;
-  v_elapsed NUMBER;
-  v_scope VARCHAR2(20);
-  v_mentions PLS_INTEGER;
-  v_raw_json VARCHAR2(5);
-
-  PROCEDURE run_case(
-    p_profile_name IN VARCHAR2,
-    p_case t_case
-  ) IS
-  BEGIN
-    v_started := DBMS_UTILITY.GET_TIME;
-    v_result := DBMS_CLOUD_AI.GENERATE(
-      prompt => v_prompt_prefix || p_case.question,
-      profile_name => p_profile_name,
-      action => 'chat'
-    );
-    v_elapsed := (DBMS_UTILITY.GET_TIME - v_started) / 100;
-    v_json := JSON_OBJECT_T.parse(v_result);
-    v_raw_json := 'TRUE';
-    v_scope := v_json.get_string('scope_hint');
-    v_mentions := v_json.get_array('game_mentions').get_size;
-    DBMS_OUTPUT.PUT_LINE(
-      p_profile_name || '|' || p_case.case_name
-      || '|seconds=' || TO_CHAR(v_elapsed, 'FM9990D00')
-      || '|raw_json=' || v_raw_json
-      || '|scope=' || NVL(v_scope, 'NULL')
-      || '|mentions=' || v_mentions
-      || '|expected=' || p_case.expected_scope || '/' || p_case.expected_mentions
-    );
-  EXCEPTION
-    WHEN OTHERS THEN
-      DBMS_OUTPUT.PUT_LINE(
-        p_profile_name || '|' || p_case.case_name
-        || '|seconds=' || TO_CHAR(v_elapsed, 'FM9990D00')
-        || '|ERROR=' || SQLCODE || '|' || SUBSTR(SQLERRM, 1, 180)
-      );
-  END;
-BEGIN
-  DBMS_OUTPUT.PUT_LINE('benchmark_started');
-  v_cases(1).case_name := 'NONE';
-  v_cases(1).question := utl_i18n.raw_to_char(utl_encode.base64_decode(
-    utl_raw.cast_to_raw('7KCE7LK0IOunpOy2nCDslYzroKTspJgu')), 'AL32UTF8');
-  v_cases(1).expected_scope := 'GLOBAL';
-  v_cases(1).expected_mentions := 0;
-
-  v_cases(2).case_name := 'SINGLE';
-  v_cases(2).question := utl_i18n.raw_to_char(utl_encode.base64_decode(
-    utl_raw.cast_to_raw('7Lm07KCc64KYIOy1nOyLoCBBVSDslYzroKTspJgu')), 'AL32UTF8');
-  v_cases(2).expected_scope := 'SINGLE_GAME';
-  v_cases(2).expected_mentions := 1;
-
-  v_cases(3).case_name := 'MULTI';
-  v_cases(3).question := utl_i18n.raw_to_char(utl_encode.base64_decode(
-    utl_raw.cast_to_raw('66Gc65Oc64KY7J247J20656RIOy5tOygnOuCmOydmCAyMDI264WEIDfsm5QgMTXsnbwgQVXrpbwg6rCB6rCBIOyVjOugpOykmC4=')), 'AL32UTF8');
-  v_cases(3).expected_scope := 'MULTI_GAME';
-  v_cases(3).expected_mentions := 2;
-
-  v_cases(4).case_name := 'ALL';
-  v_cases(4).question := utl_i18n.raw_to_char(utl_encode.base64_decode(
-    utl_raw.cast_to_raw('7KCE7LK0IOqyjOyehOydmCDrp6Tstpwg7JWM66Ck7KSYLg==')), 'AL32UTF8');
-  v_cases(4).expected_scope := 'ALL_GAMES';
-  v_cases(4).expected_mentions := 0;
-
-  FOR profile_row IN (
-    SELECT profile_name
-      FROM user_cloud_ai_profiles
-     WHERE profile_name IN (
-       'SGMP_POC_OCI_GPT54MINI',
-       'SGMP_SCOPE_COHERE_VISION',
-       'SGMP_SCOPE_COHERE_COMMAND',
-       'SGMP_SCOPE_COHERE_PLUS',
-       'SGMP_SCOPE_GEMINI_FLASH',
-       'SGMP_SCOPE_LLAMA_MAV',
-       'SGMP_SCOPE_GROK_NONR'
-     )
-     ORDER BY profile_name
-  ) LOOP
-    DBMS_OUTPUT.PUT_LINE('profile=' || profile_row.profile_name);
-    FOR i IN 1 .. 4 LOOP
-      run_case(profile_row.profile_name, v_cases(i));
-    END LOOP;
-  END LOOP;
-END;
-/
-prompt SG_SCOPE_PROFILE_BENCHMARK_COMPLETED

database/adb/116_sg_game_catalog_alias_embeddings.sql

@@ -1,122 +0,0 @@
--- Store all game-name variants as one JSON array per game and embed that JSON
--- as the canonical game-search vector. No customer game name is hardcoded.
-
-DECLARE
-  v_column_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_column_count
-    FROM user_tab_columns
-   WHERE table_name = 'SG_GAME_CATALOG'
-     AND column_name = 'ALIASES_JSON';
-
-  IF v_column_count = 0 THEN
-    EXECUTE IMMEDIATE 'ALTER TABLE sg_game_catalog ADD (aliases_json CLOB)';
-  END IF;
-END;
-/
-
-UPDATE sg_game_catalog
-   SET aliases_json = '[]'
- WHERE aliases_json IS NULL;
-/
-
-DECLARE
-  v_constraint_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_constraint_count
-    FROM user_constraints
-   WHERE table_name = 'SG_GAME_CATALOG'
-     AND constraint_name = 'SG_GAME_CATALOG_ALIASES_JS_CK';
-
-  IF v_constraint_count = 0 THEN
-    EXECUTE IMMEDIATE
-      'ALTER TABLE sg_game_catalog ADD CONSTRAINT sg_game_catalog_aliases_js_ck '
-      || 'CHECK (aliases_json IS JSON)';
-  END IF;
-END;
-/
-
-MERGE INTO sg_game_catalog c
-USING (
-  WITH source_alias AS (
-    SELECT game_id AS game_key, game_nm AS alias_name
-      FROM comn_game_alias_bas
-     WHERE use_yn = 'Y' AND game_nm IS NOT NULL
-    UNION ALL
-    SELECT game_id, game_alias_nm
-      FROM comn_game_alias_bas
-     WHERE use_yn = 'Y' AND game_alias_nm IS NOT NULL
-    UNION ALL
-    SELECT game_id, game_id
-      FROM comn_game_alias_bas
-     WHERE use_yn = 'Y' AND game_id IS NOT NULL
-    UNION ALL
-    SELECT game_id, game_prefix
-      FROM comn_game_alias_bas
-     WHERE use_yn = 'Y' AND game_prefix IS NOT NULL
-    UNION ALL
-    SELECT game_key, display_name
-      FROM sg_game_scope_registry
-     WHERE active_yn = 'Y' AND display_name IS NOT NULL
-    UNION ALL
-    SELECT game_key, game_alias
-      FROM sg_game_scope_registry
-     WHERE active_yn = 'Y' AND game_alias IS NOT NULL
-  ),
-  deduplicated_alias AS (
-    SELECT game_key, alias_name
-      FROM source_alias
-     WHERE TRIM(alias_name) IS NOT NULL
-     GROUP BY game_key, alias_name
-  )
-  SELECT game_key,
-         JSON_ARRAYAGG(alias_name ORDER BY alias_name RETURNING CLOB) AS aliases_json
-    FROM deduplicated_alias
-   GROUP BY game_key
-) s
-ON (c.game_key = s.game_key)
-WHEN MATCHED THEN UPDATE SET
-  c.aliases_json = s.aliases_json,
-  c.updated_at = SYSTIMESTAMP;
-/
-
--- A game has one canonical vector made from its complete JSON alias array.
-UPDATE sg_game_catalog c
-   SET c.embedding = DBMS_VECTOR.UTL_TO_EMBEDDING(
-         c.aliases_json,
-         JSON(sg_qa_vector_params('search_document'))
-       ),
-       c.updated_at = SYSTIMESTAMP
- WHERE c.active_yn = 'Y';
-/
-
-COMMENT ON COLUMN sg_game_catalog.aliases_json IS
-  'Canonical JSON string array of every game-name variant used as the embedding input.';
-COMMENT ON COLUMN sg_game_catalog.embedding IS
-  'One vector per game, generated from the complete aliases_json array.';
-/
-
-CREATE OR REPLACE FUNCTION sg_game_catalog_search(
-  p_question IN CLOB,
-  p_top_k IN PLS_INTEGER DEFAULT 5
-) RETURN SYS_REFCURSOR AUTHID DEFINER IS
-  v_query VECTOR;
-  v_result SYS_REFCURSOR;
-BEGIN
-  v_query := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-  OPEN v_result FOR
-    SELECT game_key, game_id, game_prefix, game_nm, game_alias_nm,
-           user_master_object_name,
-           VECTOR_DISTANCE(embedding, v_query, COSINE) AS cosine_distance
-      FROM sg_game_catalog
-     WHERE active_yn = 'Y' AND embedding IS NOT NULL
-     ORDER BY VECTOR_DISTANCE(embedding, v_query, COSINE), priority, game_key
-     FETCH FIRST LEAST(GREATEST(NVL(p_top_k, 5), 1), 20) ROWS ONLY;
-  RETURN v_result;
-END;
-/

database/adb/117_sg_game_scope_policy.sql

@@ -1,68 +0,0 @@
--- Customer-managed score policy for vector-only game identity resolution.
-
-BEGIN
-  EXECUTE IMMEDIATE q'[
-    CREATE TABLE sg_game_scope_policy (
-      policy_key   VARCHAR2(128) PRIMARY KEY,
-      number_value NUMBER,
-      text_value   VARCHAR2(4000),
-      description  VARCHAR2(1000) NOT NULL,
-      active_yn    CHAR(1) DEFAULT 'Y' NOT NULL,
-      updated_at   TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL,
-      CONSTRAINT sg_game_scope_policy_active_ck CHECK (active_yn IN ('Y', 'N'))
-    )]';
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -955 THEN RAISE; END IF;
-END;
-/
-
-MERGE INTO sg_game_scope_policy t
-USING (
-  SELECT 'GAME_ALIAS_MAX_COSINE_DISTANCE' AS policy_key,
-         0.500000 AS number_value,
-         CAST(NULL AS VARCHAR2(4000)) AS text_value,
-         'Maximum cosine distance for accepting the closest independently embedded game alias.' AS description
-    FROM dual
-  UNION ALL
-  SELECT 'SCOPE_GUIDANCE_NONE', NULL,
-         '{"mode":"GAME_UNSPECIFIED","allowGameScopedObjects":false,"targetExecution":"COMMON_OBJECTS_OR_ZERO_ROW","instruction":"No game was selected. Do not use a game-scoped object. Use only a game-neutral common object when it answers the question; otherwise return a zero-row result."}',
-         'Prompt guidance for a question without a selected game.'
-    FROM dual
-  UNION ALL
-  SELECT 'SCOPE_GUIDANCE_SINGLE', NULL,
-         '{"mode":"EXACT_TARGETS","allowGameScopedObjects":true,"targetExecution":"ONLY_RESOLVED_TARGETS","instruction":"Use only the resolved target in targets. Do not select another game-scoped object."}',
-         'Prompt guidance for exactly one resolved game target.'
-    FROM dual
-  UNION ALL
-  SELECT 'SCOPE_GUIDANCE_MULTI', NULL,
-         '{"mode":"MULTIPLE_TARGETS","allowGameScopedObjects":true,"targetExecution":"ALL_RESOLVED_TARGETS","instruction":"Return results for all resolved available targets. Preserve unresolved targets as unavailable; do not replace them with another game."}',
-         'Prompt guidance for multiple game targets.'
-    FROM dual
-  UNION ALL
-  SELECT 'SCOPE_GUIDANCE_ALL', NULL,
-         '{"mode":"ALL_CATALOG_TARGETS","allowGameScopedObjects":true,"targetExecution":"ALL_AVAILABLE_CATALOG_TARGETS","instruction":"Use all available catalog targets. Do not invent games or game-scoped objects outside the catalog."}',
-         'Prompt guidance for every catalog game.'
-    FROM dual
-) s
-ON (t.policy_key = s.policy_key)
-WHEN MATCHED THEN UPDATE SET
-  t.text_value = CASE
-    WHEN s.policy_key LIKE 'SCOPE_GUIDANCE_%' THEN s.text_value
-    ELSE t.text_value
-  END,
-  t.description = s.description,
-  t.active_yn = 'Y',
-  t.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  policy_key, number_value, text_value, description, active_yn
-) VALUES (
-  s.policy_key, s.number_value, s.text_value, s.description, 'Y'
-);
-/
-
-COMMENT ON TABLE sg_game_scope_policy IS
-  'Customer-managed game scope policy values; changing a value requires no application deployment.';
-COMMENT ON COLUMN sg_game_scope_policy.number_value IS
-  'Numeric policy value. GAME_ALIAS_MAX_COSINE_DISTANCE applies to the closest alias vector.';
-/

database/adb/118_sgmp_qa_vector_quality_threshold.sql

@@ -1,82 +0,0 @@
--- Customer-managed quality floor for runtime Few-shot retrieval.
--- Lower cosine distance is more similar.  The value is data, not application code.
-MERGE INTO sg_game_scope_policy t
-USING (
-  SELECT 'QA_VECTOR_MAX_COSINE_DISTANCE' AS policy_key,
-         0.650000 AS number_value,
-         'Maximum cosine distance accepted for a runtime approved Few-shot example.' AS description
-    FROM dual
-) s
-ON (t.policy_key = s.policy_key)
-WHEN MATCHED THEN UPDATE SET
-  t.number_value = s.number_value,
-  t.description = s.description,
-  t.active_yn = 'Y',
-  t.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  policy_key, number_value, text_value, description, active_yn
-) VALUES (
-  s.policy_key, s.number_value, NULL, s.description, 'Y'
-);
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-  v_max_cosine_distance NUMBER;
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-
-  SELECT number_value
-    INTO v_max_cosine_distance
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_MAX_COSINE_DISTANCE'
-     AND active_yn = 'Y'
-     AND number_value IS NOT NULL;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           cosine_distance
-      FROM (
-        SELECT example_id, question, answer_sql, answer_text, embedding_model,
-               reference_kind, target_type, object_role, source_case_id, source_type,
-               VECTOR_DISTANCE(embedding, v_query_vector, COSINE) AS cosine_distance
-         FROM sg_qa_vector_example
-         WHERE reference_status = 'APPROVED'
-           -- A generated structural pattern is review material, not a runtime
-           -- Few-shot. Runtime examples must have human verification and an
-           -- executable SQL body rather than unresolved logical placeholders.
-           AND inspection_status = 'VERIFIED'
-           AND answer_sql IS NOT NULL
-           AND NOT REGEXP_LIKE(answer_sql, '<[A-Z][A-Z0-9_]*>', 'i')
-           AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-      )
-     WHERE cosine_distance <= v_max_cosine_distance
-     ORDER BY cosine_distance, example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-COMMENT ON TABLE sg_game_scope_policy IS
-  'Customer-managed game scope and runtime retrieval policy values; changing a value requires no application deployment.';
-/

database/adb/118_sgmp_scope_command_profile.sql

@@ -1,78 +0,0 @@
--- Operational OCI Cohere profile for short game-name and scope extraction.
--- It inherits the active GPT profile's OCI credential, region, and metadata.
-
-DECLARE
-  v_credential_name VARCHAR2(128);
-  v_region VARCHAR2(128);
-  v_compartment_id VARCHAR2(4000);
-  v_attributes CLOB;
-  v_attribute_json JSON_OBJECT_T;
-  v_exists PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM user_cloud_ai_profiles
-   WHERE profile_name = 'SGMP_POC_OCI_COHERE_COMMAND';
-
-  IF v_exists > 0 THEN
-    DBMS_CLOUD_AI.DROP_PROFILE(
-      profile_name => 'SGMP_POC_OCI_COHERE_COMMAND',
-      force => TRUE
-    );
-  END IF;
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_credential_name
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'credential_name';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 128, 1)
-    INTO v_region
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'region';
-
-  SELECT DBMS_LOB.SUBSTR(attribute_value, 4000, 1)
-    INTO v_compartment_id
-    FROM user_cloud_ai_profile_attributes
-   WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-     AND attribute_name = 'oci_compartment_id';
-
-  v_attribute_json := JSON_OBJECT_T();
-  v_attribute_json.put('provider', 'oci');
-  v_attribute_json.put('credential_name', v_credential_name);
-  v_attribute_json.put('model', 'cohere.command-latest');
-  v_attribute_json.put('region', v_region);
-  v_attribute_json.put('oci_compartment_id', v_compartment_id);
-  v_attributes := v_attribute_json.to_clob;
-
-  DBMS_CLOUD_AI.CREATE_PROFILE(
-    profile_name => 'SGMP_POC_OCI_COHERE_COMMAND',
-    attributes => v_attributes,
-    description => 'Smilegate operational OCI Cohere Command profile for game scope extraction'
-  );
-
-  FOR source_attribute IN (
-    SELECT attribute_name, attribute_value
-      FROM user_cloud_ai_profile_attributes
-     WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-       AND attribute_name NOT IN (
-         'credential_name', 'model', 'provider', 'provider_endpoint',
-         'region', 'oci_compartment_id', 'oci_endpoint_id',
-         'oci_apiformat', 'oci_runtimetype'
-       )
-  ) LOOP
-    DBMS_CLOUD_AI.SET_ATTRIBUTE(
-      profile_name => 'SGMP_POC_OCI_COHERE_COMMAND',
-      attribute_name => source_attribute.attribute_name,
-      attribute_value => source_attribute.attribute_value
-    );
-  END LOOP;
-END;
-/
-
-SELECT profile_name, attribute_value AS model
-  FROM user_cloud_ai_profile_attributes
- WHERE profile_name = 'SGMP_POC_OCI_COHERE_COMMAND'
-   AND attribute_name = 'model';

database/adb/119_sgmp_remove_invalid_std12_fewshot.sql

@@ -1,38 +0,0 @@
--- STD-12 is a multi-target orchestration case, not a reusable SQL few-shot.
--- Preserve SG_AI_QA_QUESTION as the customer benchmark; remove only its
--- invalid vector-example row so it cannot be managed as a few-shot.
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_count
-    FROM sg_qa_vector_example
-   WHERE example_id = 51
-     AND source_case_id = 'STD-12'
-     AND source_type = 'CUSTOMER_QA_BENCHMARK';
-
-  IF v_count <> 1 THEN
-    RAISE_APPLICATION_ERROR(-20051, 'Expected exactly one invalid STD-12 few-shot row.');
-  END IF;
-
-  DELETE FROM sg_qa_vector_example
-   WHERE example_id = 51
-     AND source_case_id = 'STD-12'
-     AND source_type = 'CUSTOMER_QA_BENCHMARK';
-
-  IF SQL%ROWCOUNT <> 1 THEN
-    RAISE_APPLICATION_ERROR(-20052, 'Invalid STD-12 few-shot row was not deleted.');
-  END IF;
-
-  COMMIT;
-END;
-/
-
-SELECT COUNT(*) AS remaining_fewshot_rows
-  FROM sg_qa_vector_example
- WHERE example_id = 51;
-
-SELECT COUNT(*) AS preserved_question_rows
-  FROM sg_ai_qa_question
- WHERE question_code = 'STD-12';

database/adb/121_sg_game_catalog_identity_duality_view.sql

@@ -1,84 +0,0 @@
--- One DB-owned JSON identity document per game. No game value is hardcoded.
--- The relational alias child makes aliases a nested Duality View array.
-
-BEGIN
-  EXECUTE IMMEDIATE q'[
-    CREATE TABLE sg_game_catalog_identity_alias (
-      game_key    VARCHAR2(128) NOT NULL,
-      alias_value VARCHAR2(512) NOT NULL,
-      CONSTRAINT sg_game_catalog_identity_alias_pk PRIMARY KEY (game_key, alias_value),
-      CONSTRAINT sg_game_catalog_identity_alias_fk FOREIGN KEY (game_key)
-        REFERENCES sg_game_catalog (game_key)
-    )]';
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -955 THEN RAISE; END IF;
-END;
-/
-
-MERGE INTO sg_game_catalog_identity_alias target
-USING (
-  SELECT c.game_key, aliases.alias_value
-    FROM sg_game_catalog c,
-         JSON_TABLE(
-           c.aliases_json,
-           '$[*]' COLUMNS (alias_value VARCHAR2(512) PATH '$')
-         ) aliases
-   WHERE c.active_yn = 'Y'
-) source
-ON (target.game_key = source.game_key AND target.alias_value = source.alias_value)
-WHEN NOT MATCHED THEN INSERT (game_key, alias_value)
-VALUES (source.game_key, source.alias_value);
-/
-
-DELETE FROM sg_game_catalog_identity_alias target
- WHERE NOT EXISTS (
-   SELECT 1
-     FROM sg_game_catalog c,
-          JSON_TABLE(
-            c.aliases_json,
-            '$[*]' COLUMNS (alias_value VARCHAR2(512) PATH '$')
-          ) aliases
-    WHERE c.game_key = target.game_key
-      AND c.active_yn = 'Y'
-      AND aliases.alias_value = target.alias_value
- );
-/
-
-CREATE OR REPLACE JSON RELATIONAL DUALITY VIEW sg_game_catalog_identity_dv AS
-  SELECT JSON {
-    '_id' : c.game_key,
-    'gameId' : c.game_id,
-    'gamePrefix' : c.game_prefix,
-    'gameName' : c.game_nm,
-    'gameAliases' : [
-      SELECT JSON {
-        '_id' : { 'gameKey' : a.game_key, 'value' : a.alias_value }
-      }
-        FROM sg_game_catalog_identity_alias a
-       WHERE a.game_key = c.game_key
-    ]
-  }
-  FROM sg_game_catalog c
-  WHERE c.active_yn = 'Y'
-  WITH CHECK OPTION;
-/
-
--- Serialize the DB JSON document itself before embedding. GAME_ID, GAME_PREFIX,
--- names and every alias therefore share one vector search document.
-UPDATE sg_game_catalog c
-   SET c.embedding = DBMS_VECTOR.UTL_TO_EMBEDDING(
-         (
-           SELECT JSON_SERIALIZE(d.data RETURNING CLOB)
-             FROM sg_game_catalog_identity_dv d
-            WHERE JSON_VALUE(d.data, '$._id') = c.game_key
-         ),
-         JSON(sg_qa_vector_params('search_document'))
-       ),
-       c.updated_at = SYSTIMESTAMP
- WHERE c.active_yn = 'Y';
-/
-
-COMMENT ON TABLE sg_game_catalog_identity_dv IS
-  'DB JSON identity document for each active game; the canonical embedding source for game-name, alias, GAME_ID and GAME_PREFIX resolution.';
-/

database/adb/122_sgmp_std18_filtered_sales_aggregate_fewshot.sql

@@ -1,144 +0,0 @@
--- STD-18 asks for an aggregate over qualifying orders, not an individual
--- transaction list. Remove the invalid customer-derived references and keep
--- one reusable, data-neutral aggregate pattern for runtime retrieval.
-
-DELETE FROM sg_qa_vector_example
- WHERE source_case_id IN ('STD-18', 'PAT-STD-18')
-   AND source_type IN ('CUSTOMER_QA_BENCHMARK', 'GENERALIZED_QUESTION_PATTERN');
-/
-
-DECLARE
-  v_input     CLOB;
-  v_embedding VECTOR;
-  v_exists    NUMBER;
-BEGIN
-  v_input := TO_CLOB('질문 패턴: 전체 매출에서 금액 조건을 만족하는 주문을 집계해줘.')
-    || CHR(10) || 'Question pattern: summarize whole-scope sales after a payment amount filter.'
-    || CHR(10) || 'Logical object role: SALES_TRANSACTION'
-    || CHR(10) || 'Required result grain: one aggregate row with total sales amount, distinct buyer count, and order count.'
-    || CHR(10) || 'A reference to orders does not by itself request individual order detail.';
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM sg_qa_vector_example
-   WHERE source_type = 'POLICY_TEMPLATE'
-     AND source_case_id = 'FILTERED_SALES_AGGREGATE';
-
-  IF v_exists = 0 THEN
-    INSERT INTO sg_qa_vector_example (
-      question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-      reference_status, reference_kind, target_type, object_role,
-      inspection_status, inspection_note, verified_at, verified_by,
-      source_case_id, source_type
-    ) VALUES (
-      '전체 매출에서 금액 조건을 만족하는 주문을 집계해줘.',
-      TO_CLOB('SELECT SUM(CAST(s."PAYMT_AMT" AS NUMBER)) AS "TOTAL_SALES_AMOUNT",' || CHR(10)
-        || '       COUNT(DISTINCT s."GUID") AS "BUYER_COUNT",' || CHR(10)
-        || '       COUNT(*) AS "ORDER_COUNT"' || CHR(10)
-        || 'FROM "SGMP_POC"."COMN_SALES_TXN" s' || CHR(10)
-        || 'WHERE s."PAYMT_DTM" >= <BUSINESS_DATE_START>' || CHR(10)
-        || '  AND s."PAYMT_DTM" < <BUSINESS_DATE_END>' || CHR(10)
-        || '  AND CAST(s."PAYMT_AMT" AS NUMBER) <AMOUNT_CONDITION>' || CHR(10)
-        || '  AND s."EXPT_USER_YN" = ''N'''),
-      'Structural Few-shot: return one aggregate row containing total sales amount, distinct buyer count, and order count after the requested payment-amount filter. Do not return individual orders unless the user explicitly asks for a list or detail rows.',
-      v_input,
-      v_embedding,
-      'cohere.embed-v4.0',
-      'APPROVED', 'SQL_TEMPLATE', 'NONE', 'SALES_TRANSACTION',
-      'VERIFIED',
-      'Reusable whole-scope filtered-sales aggregate. No customer date, amount, game, or expected result is stored.',
-      SYSTIMESTAMP, 'SGMP_POC_METADATA_REVIEW',
-      'FILTERED_SALES_AGGREGATE', 'POLICY_TEMPLATE'
-    );
-  ELSE
-    UPDATE sg_qa_vector_example
-       SET question = '전체 매출에서 금액 조건을 만족하는 주문을 집계해줘.',
-           answer_sql = TO_CLOB('SELECT SUM(CAST(s."PAYMT_AMT" AS NUMBER)) AS "TOTAL_SALES_AMOUNT",' || CHR(10)
-             || '       COUNT(DISTINCT s."GUID") AS "BUYER_COUNT",' || CHR(10)
-             || '       COUNT(*) AS "ORDER_COUNT"' || CHR(10)
-             || 'FROM "SGMP_POC"."COMN_SALES_TXN" s' || CHR(10)
-             || 'WHERE s."PAYMT_DTM" >= <BUSINESS_DATE_START>' || CHR(10)
-             || '  AND s."PAYMT_DTM" < <BUSINESS_DATE_END>' || CHR(10)
-             || '  AND CAST(s."PAYMT_AMT" AS NUMBER) <AMOUNT_CONDITION>' || CHR(10)
-             || '  AND s."EXPT_USER_YN" = ''N'''),
-           answer_text = 'Structural Few-shot: return one aggregate row containing total sales amount, distinct buyer count, and order count after the requested payment-amount filter. Do not return individual orders unless the user explicitly asks for a list or detail rows.',
-           embedding_input = v_input,
-           embedding = v_embedding,
-           reference_status = 'APPROVED',
-           reference_kind = 'SQL_TEMPLATE',
-           target_type = 'NONE',
-           object_role = 'SALES_TRANSACTION',
-           inspection_status = 'VERIFIED',
-           inspection_note = 'Reusable whole-scope filtered-sales aggregate. No customer date, amount, game, or expected result is stored.',
-           verified_at = SYSTIMESTAMP,
-           verified_by = 'SGMP_POC_METADATA_REVIEW'
-     WHERE source_type = 'POLICY_TEMPLATE'
-       AND source_case_id = 'FILTERED_SALES_AGGREGATE';
-  END IF;
-  COMMIT;
-END;
-/
-
--- A SQL template is prompt context, never an executable statement. Permit
--- reviewed policy templates to retain logical placeholders while continuing
--- to require executable SQL for automatically generalized patterns.
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-  v_max_cosine_distance NUMBER;
-BEGIN
-  IF p_question IS NULL THEN RAISE_APPLICATION_ERROR(-20003, 'question is required.'); END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-
-  SELECT number_value INTO v_max_cosine_distance
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_MAX_COSINE_DISTANCE'
-     AND active_yn = 'Y'
-     AND number_value IS NOT NULL;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           cosine_distance
-      FROM (
-        SELECT example_id, question, answer_sql, answer_text, embedding_model,
-               reference_kind, target_type, object_role, source_case_id, source_type,
-               VECTOR_DISTANCE(embedding, v_query_vector, COSINE) AS cosine_distance
-          FROM sg_qa_vector_example
-         WHERE reference_status = 'APPROVED'
-           AND inspection_status = 'VERIFIED'
-           AND answer_sql IS NOT NULL
-           AND (source_type = 'POLICY_TEMPLATE'
-                OR NOT REGEXP_LIKE(answer_sql, '<[A-Z][A-Z0-9_]*>', 'i'))
-           AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-      )
-     WHERE cosine_distance <= v_max_cosine_distance
-     ORDER BY cosine_distance, example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-SELECT example_id, source_case_id, source_type, reference_status, inspection_status
-  FROM sg_qa_vector_example
- WHERE source_case_id IN ('STD-18', 'PAT-STD-18', 'FILTERED_SALES_AGGREGATE')
- ORDER BY example_id;

database/adb/123_sgmp_filtered_sales_aggregate_any_scope.sql

@@ -1,33 +0,0 @@
--- This customer question is game-unscoped. Keep the existing NONE-compatible
--- Few-shot path; game_query_plan remains responsible for scope resolution.
-UPDATE sg_qa_vector_example
-   SET question = '매출에서 금액 조건을 만족하는 주문의 총액, 구매자 수, 주문 수를 집계해줘.',
-       answer_sql = TO_CLOB('SELECT' || CHR(10)
-         || '    SUM(CAST(s."PAYMT_AMT" AS NUMBER)) AS "TOTAL_SALES_AMOUNT",' || CHR(10)
-         || '    COUNT(DISTINCT s."GUID") AS "BUYER_COUNT",' || CHR(10)
-         || '    COUNT(*) AS "ORDER_COUNT"' || CHR(10)
-         || '  FROM <COMMON_SALES_TRANSACTION> s' || CHR(10)
-         || '  WHERE s."PAYMT_DTM" >= <BUSINESS_DATE_START>' || CHR(10)
-         || '    AND s."PAYMT_DTM" < <BUSINESS_DATE_END>' || CHR(10)
-         || '    AND CAST(s."PAYMT_AMT" AS NUMBER) <AMOUNT_CONDITION>' || CHR(10)
-         || '    AND s."EXPT_USER_YN" = ''N'''),
-       answer_text = 'Aggregate result-shape reference: return one row with total sales amount, distinct buyer count, and order count. The game plan separately supplies any game scope; use this pattern only when the question is semantically similar.',
-       embedding_input = TO_CLOB('Question pattern: summarize sales after a payment amount condition.' || CHR(10)
-         || 'Logical object role: SALES_TRANSACTION' || CHR(10)
-         || 'Result grain: one aggregate row with total sales amount, distinct buyer count, and order count.'),
-       embedding = DBMS_VECTOR.UTL_TO_EMBEDDING(
-         TO_CLOB('Question pattern: summarize sales after a payment amount condition.' || CHR(10)
-           || 'Logical object role: SALES_TRANSACTION' || CHR(10)
-           || 'Result grain: one aggregate row with total sales amount, distinct buyer count, and order count.'),
-         JSON(sg_qa_vector_params('search_document'))),
-       target_type = 'NONE',
-       source_case_id = 'PORTAL-STD-18',
-       inspection_note = 'Generalized aggregate pattern for the current game-unscoped question; game_query_plan controls scope separately.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE example_id = 141
-   AND source_type = 'POLICY_TEMPLATE';
-/
-
-COMMIT;
-/

database/adb/124_sgmp_std18_expected_answer_fewshot.sql

@@ -1,23 +0,0 @@
--- The reviewed customer benchmark answer is part of this Few-shot guidance.
--- It clarifies that the requested result is one aggregate row, not detail rows.
-UPDATE sg_qa_vector_example
-   SET answer_text = TO_CLOB('Expected answer shape: return exactly one aggregate row, not individual order rows.' || CHR(10)
-         || 'Expected answer:' || CHR(10)
-         || 'TOTAL_SALES_AMOUNT BUYER_COUNT ORDER_COUNT' || CHR(10)
-         || '------------------ ----------- -----------' || CHR(10)
-         || '            204720           6           6'),
-       embedding_input = TO_CLOB('Question pattern: summarize sales after a payment amount condition.' || CHR(10)
-         || 'Expected output: TOTAL_SALES_AMOUNT, BUYER_COUNT, ORDER_COUNT as one aggregate row.' || CHR(10)
-         || 'Expected result example: 204720, 6, 6.'),
-       embedding = DBMS_VECTOR.UTL_TO_EMBEDDING(
-         TO_CLOB('Question pattern: summarize sales after a payment amount condition.' || CHR(10)
-           || 'Expected output: TOTAL_SALES_AMOUNT, BUYER_COUNT, ORDER_COUNT as one aggregate row.' || CHR(10)
-           || 'Expected result example: 204720, 6, 6.'),
-         JSON(sg_qa_vector_params('search_document'))),
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE example_id = 141
-   AND source_type = 'POLICY_TEMPLATE';
-/
-COMMIT;
-/

database/adb/129_sgmp_std25_weekly_au_evaluation_criteria.sql

@@ -1,29 +0,0 @@
--- STD-25 is a period AU metric, not the daily AU_FLAG metric.
--- Keep the evaluation evidence explicit so the LLM judge accepts the valid
--- weekly result shape produced by the NL2SQL tool.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = 'Weekly AU: use one as-of snapshot (BASE_DT=2026-07-15), '
-       || 'count DISTINCT GUID whose LAST_CONN_DT is in the inclusive seven-day window '
-       || '(2026-07-09 through 2026-07-15), with STD_USER_YN=''Y'' and EXPT_USER_YN=''N''. '
-       || 'This is one aggregate result, not daily rows. Do not substitute daily AU_FLAG=1 for the period definition.',
-       baseline_sql = TO_CLOB('SELECT COUNT(DISTINCT u."GUID") AS "RECENT_7DAY_AU"' || CHR(10)
-         || 'FROM "SGMP_POC"."CZN_COMN_USER_MST" u' || CHR(10)
-         || 'WHERE u."BASE_DT" = DATE ''2026-07-15''' || CHR(10)
-         || '  AND u."LAST_CONN_DT" BETWEEN DATE ''2026-07-09'' AND DATE ''2026-07-15''' || CHR(10)
-         || '  AND u."STD_USER_YN" = ''Y''' || CHR(10)
-         || '  AND u."EXPT_USER_YN" = ''N'''),
-       baseline_answer = 'RECENT_7DAY_AU=0',
-       evaluation_rule_json = '{"required_sql_terms":["CZN_COMN_USER_MST","LAST_CONN_DT","STD_USER_YN","EXPT_USER_YN","COUNT"],"recommended_sql_terms":["BASE_DT"],"forbidden_sql_terms":["AU_FLAG"],"required_result_shape":"SINGLE_AGGREGATE"}',
-       updated_at = SYSTIMESTAMP
- WHERE question_code = 'STD-25';
-
-/
-
-COMMIT;
-
-/
-
-SELECT question_code, expected_focus, baseline_sql, baseline_answer, evaluation_rule_json
-  FROM sg_ai_qa_question
- WHERE question_code = 'STD-25';

database/adb/130_sgmp_czn02_standard_au_optional_std_user_criteria.sql

@@ -1,40 +0,0 @@
--- CZN-02 customer sample marks STD_USER_YN='Y' as optional for daily
--- standard-AU reporting. It must not turn an otherwise correct AU query into
--- a failure merely because the condition is present.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = 'Daily standard AU: COUNT(DISTINCT GUID) from CZN_COMN_USER_MST '
-       || 'for BASE_DT=2026-07-15 with AU_FLAG=1 and EXPT_USER_YN=''N''. '
-       || 'STD_USER_YN=''Y'' is an allowed optional cohort filter in the customer sample; '
-       || 'its presence or absence is not a contradiction to this baseline.',
-       evaluation_rule_json = '{"required_sql_terms":["CZN_COMN_USER_MST","AU_FLAG","EXPT_USER_YN","COUNT"],"recommended_sql_terms":["BASE_DT","STD_USER_YN"],"optional_sql_terms":["STD_USER_YN"]}',
-       updated_at = SYSTIMESTAMP
- WHERE question_code = 'CZN-02';
-
-/
-
-UPDATE sg_qa_vector_example
-   SET answer_text = 'Expected focus: daily standard AU uses CZN_COMN_USER_MST, BASE_DT=2026-07-15, '
-                   || 'AU_FLAG=1 and EXPT_USER_YN=''N''. The customer sample permits STD_USER_YN=''Y'' '
-                   || 'as an optional standard-user cohort filter; do not treat its presence as a conflicting condition. '
-                   || 'Historical answer: STD_AU_COUNT=0',
-       inspection_note = 'Customer sample permits optional STD_USER_YN filtering for daily standard AU; AU_FLAG and excluded-user filtering remain mandatory.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-02'
-   AND reference_status = 'APPROVED';
-
-/
-
-COMMIT;
-
-/
-
-SELECT q.question_code, q.expected_focus, q.evaluation_rule_json,
-       e.example_id, e.answer_text
-  FROM sg_ai_qa_question q
-  LEFT JOIN sg_qa_vector_example e
-    ON e.source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND e.source_case_id = q.question_code
- WHERE q.question_code = 'CZN-02';

database/adb/131_sgmp_independent_au_comparison_pattern.sql

@@ -1,90 +0,0 @@
--- Reusable SINGLE-scope pattern: two AU populations must be aggregated
--- independently before comparison. A user-master LEFT JOIN may erase valid
--- business-user rows and must not define the business population.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = 'Compare standard AU and business AU as two independent single-row aggregates for the same as-of date. '
-       || 'Standard AU uses the resolved game user master with AU_FLAG=1 and EXPT_USER_YN=''N''. '
-       || 'Business AU uses the resolved game business-user fact with BIZ_AU_FLAG=1 and EXPT_USER_YN=''N''. '
-       || 'Do not make the business count depend on a LEFT JOIN from the user-master population. '
-       || 'STD_USER_YN=''Y'' is an allowed optional cohort filter, not a reason to reject the result.',
-       evaluation_rule_json = '{"required_sql_terms":["CZN_COMN_USER_MST","CZN_CUSTOM_BIZ_USER_TXN","AU_FLAG","BIZ_AU_FLAG","EXPT_USER_YN","COUNT"],"recommended_sql_terms":["BASE_DT","STD_USER_YN"],"optional_sql_terms":["STD_USER_YN"],"required_result_shape":"SINGLE_COMPARISON"}',
-       updated_at = SYSTIMESTAMP
- WHERE question_code = 'CZN-03';
-
-/
-
-DECLARE
-  v_input     CLOB;
-  v_embedding VECTOR;
-  v_exists    NUMBER;
-BEGIN
-  v_input := TO_CLOB('Question pattern: compare daily standard active users and business active users for one resolved game and one business date.')
-    || CHR(10) || 'Question pattern Korean: 한 게임의 기준일 일간 표준 AU와 사업 AU를 비교해줘.'
-    || CHR(10) || 'Logical object role: USER_BUSINESS_AU_COMPARISON'
-    || CHR(10) || 'Required result shape: one row with two independent aggregate metrics.'
-    || CHR(10) || 'Business population must be aggregated independently; a LEFT JOIN from the user-master population may not define it.';
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input, JSON(sg_qa_vector_params('search_document'))
-  );
-
-  SELECT COUNT(*) INTO v_exists
-    FROM sg_qa_vector_example
-   WHERE source_type = 'POLICY_TEMPLATE'
-     AND source_case_id = 'STD_BIZ_AU_COMPARE';
-
-  IF v_exists = 0 THEN
-    INSERT INTO sg_qa_vector_example (
-      question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-      reference_status, reference_kind, target_type, object_role,
-      inspection_status, inspection_note, verified_at, verified_by,
-      source_case_id, source_type
-    ) VALUES (
-      '한 게임의 기준일 일간 표준 AU와 사업 AU를 비교해줘.',
-      TO_CLOB('SELECT' || CHR(10)
-        || '  (SELECT COUNT(DISTINCT u."GUID")' || CHR(10)
-        || '     FROM <RESOLVED_GAME_USER_MASTER> u' || CHR(10)
-        || '    WHERE u."BASE_DT" = <BUSINESS_DATE>' || CHR(10)
-        || '      AND u."AU_FLAG" = 1' || CHR(10)
-        || '      AND u."EXPT_USER_YN" = ''N'') AS "STANDARD_AU_COUNT",' || CHR(10)
-        || '  (SELECT COUNT(DISTINCT b."GUID")' || CHR(10)
-        || '     FROM <RESOLVED_GAME_BUSINESS_USER> b' || CHR(10)
-        || '    WHERE b."BASE_DT" = <BUSINESS_DATE>' || CHR(10)
-        || '      AND b."BIZ_AU_FLAG" = 1' || CHR(10)
-        || '      AND b."EXPT_USER_YN" = ''N'') AS "BUSINESS_AU_COUNT"' || CHR(10)
-        || 'FROM DUAL'),
-      'Applicable metric reference: for this daily AU comparison, the standard metric must use AU_FLAG=1 and EXPT_USER_YN=''N''; do not replace it with LAST_CONN_DT period logic or STD_USER_YN alone. The business metric must use BIZ_AU_FLAG=1 and EXPT_USER_YN=''N''. Produce one row from two independent aggregate subqueries, and do not count business users through a LEFT JOIN from the standard-user population. STD_USER_YN may be added only as an optional cohort filter.',
-      v_input, v_embedding, 'cohere.embed-v4.0',
-      'APPROVED', 'SQL_TEMPLATE', 'SINGLE', 'USER_BUSINESS_AU_COMPARISON',
-      'VERIFIED',
-      'Reusable comparison pattern with logical placeholders only; no customer game, date, result, or physical object is embedded.',
-      SYSTIMESTAMP, 'SGMP_POC_METADATA_REVIEW',
-      'STD_BIZ_AU_COMPARE', 'POLICY_TEMPLATE'
-    );
-  ELSE
-    UPDATE sg_qa_vector_example
-       SET question = '한 게임의 기준일 일간 표준 AU와 사업 AU를 비교해줘.',
-           answer_sql = TO_CLOB('SELECT' || CHR(10)
-             || '  (SELECT COUNT(DISTINCT u."GUID")' || CHR(10)
-             || '     FROM <RESOLVED_GAME_USER_MASTER> u' || CHR(10)
-             || '    WHERE u."BASE_DT" = <BUSINESS_DATE>' || CHR(10)
-             || '      AND u."AU_FLAG" = 1' || CHR(10)
-             || '      AND u."EXPT_USER_YN" = ''N'') AS "STANDARD_AU_COUNT",' || CHR(10)
-             || '  (SELECT COUNT(DISTINCT b."GUID")' || CHR(10)
-             || '     FROM <RESOLVED_GAME_BUSINESS_USER> b' || CHR(10)
-             || '    WHERE b."BASE_DT" = <BUSINESS_DATE>' || CHR(10)
-             || '      AND b."BIZ_AU_FLAG" = 1' || CHR(10)
-             || '      AND b."EXPT_USER_YN" = ''N'') AS "BUSINESS_AU_COUNT"' || CHR(10)
-             || 'FROM DUAL'),
-           answer_text = 'Applicable metric reference: for this daily AU comparison, the standard metric must use AU_FLAG=1 and EXPT_USER_YN=''N''; do not replace it with LAST_CONN_DT period logic or STD_USER_YN alone. The business metric must use BIZ_AU_FLAG=1 and EXPT_USER_YN=''N''. Produce one row from two independent aggregate subqueries, and do not count business users through a LEFT JOIN from the standard-user population. STD_USER_YN may be added only as an optional cohort filter.',
-           embedding_input = v_input,
-           embedding = v_embedding,
-           reference_status = 'APPROVED', inspection_status = 'VERIFIED',
-           verified_at = SYSTIMESTAMP, verified_by = 'SGMP_POC_METADATA_REVIEW'
-     WHERE source_type = 'POLICY_TEMPLATE'
-       AND source_case_id = 'STD_BIZ_AU_COMPARE';
-  END IF;
-  COMMIT;
-END;
-
-/

database/adb/132_sgmp_country_daily_au_pattern.sql

@@ -1,58 +0,0 @@
--- Reusable SINGLE-scope pattern for country-grouped daily AU.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = 'Country-grouped daily standard AU uses the resolved game user master with BASE_DT, AU_FLAG=1 and EXPT_USER_YN=''N''. '
-       || 'Group by LAST_CONN_COUNTRY_CD and use the approved country dimension only for display/classification. '
-       || 'STD_USER_YN is optional and cannot replace AU_FLAG for the daily metric.',
-       evaluation_rule_json = '{"required_sql_terms":["CZN_COMN_USER_MST","AU_FLAG","EXPT_USER_YN","LAST_CONN_COUNTRY_CD","COUNT"],"recommended_sql_terms":["BASE_DT","COMN_COUNTRY_BAS","STD_USER_YN"],"optional_sql_terms":["STD_USER_YN"],"required_result_shape":"COUNTRY_GROUPED"}',
-       updated_at = SYSTIMESTAMP
- WHERE question_code = 'CZN-06';
-
-/
-
-DECLARE
-  v_input CLOB;
-  v_embedding VECTOR;
-  v_exists NUMBER;
-BEGIN
-  v_input := TO_CLOB('Question pattern: show daily active-user counts by country for one resolved game and one business date.')
-    || CHR(10) || 'Question pattern Korean: 한 게임의 기준일 주요 국가별 표준 AU 수를 알려줘.'
-    || CHR(10) || 'Logical object role: COUNTRY_GROUPED_DAILY_AU'
-    || CHR(10) || 'Required metric: AU_FLAG=1 and excluded-user filtering; group by the last connection country.';
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(v_input, JSON(sg_qa_vector_params('search_document')));
-  SELECT COUNT(*) INTO v_exists FROM sg_qa_vector_example
-   WHERE source_type = 'POLICY_TEMPLATE' AND source_case_id = 'COUNTRY_DAILY_AU';
-  IF v_exists = 0 THEN
-    INSERT INTO sg_qa_vector_example (
-      question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-      reference_status, reference_kind, target_type, object_role,
-      inspection_status, inspection_note, verified_at, verified_by, source_case_id, source_type
-    ) VALUES (
-      '한 게임의 기준일 주요 국가별 표준 AU 수를 알려줘.',
-      TO_CLOB('SELECT u."LAST_CONN_COUNTRY_CD" AS "COUNTRY_CD",' || CHR(10)
-        || '       c."COUNTRY_KR_NM" AS "COUNTRY_NAME",' || CHR(10)
-        || '       COUNT(DISTINCT u."GUID") AS "STANDARD_AU_COUNT"' || CHR(10)
-        || 'FROM <RESOLVED_GAME_USER_MASTER> u' || CHR(10)
-        || 'LEFT JOIN <APPROVED_COUNTRY_DIMENSION> c' || CHR(10)
-        || '  ON c."COUNTRY_2CHAR_CD" = u."LAST_CONN_COUNTRY_CD"' || CHR(10)
-        || 'WHERE u."BASE_DT" = <BUSINESS_DATE>' || CHR(10)
-        || '  AND u."AU_FLAG" = 1' || CHR(10)
-        || '  AND u."EXPT_USER_YN" = ''N''' || CHR(10)
-        || 'GROUP BY u."LAST_CONN_COUNTRY_CD", c."COUNTRY_KR_NM"'),
-      'Applicable metric reference: country-grouped daily AU must use AU_FLAG=1 and EXPT_USER_YN=''N''; do not replace AU_FLAG with STD_USER_YN alone. Group by LAST_CONN_COUNTRY_CD. Use an approved country dimension for country display or a current approved major-country classification when the request requires it.',
-      v_input, v_embedding, 'cohere.embed-v4.0',
-      'APPROVED', 'SQL_TEMPLATE', 'SINGLE', 'COUNTRY_GROUPED_DAILY_AU',
-      'VERIFIED', 'Reusable country-grouped daily-AU pattern; no customer game, date, result, or physical object is embedded.',
-      SYSTIMESTAMP, 'SGMP_POC_METADATA_REVIEW', 'COUNTRY_DAILY_AU', 'POLICY_TEMPLATE'
-    );
-  ELSE
-    UPDATE sg_qa_vector_example
-       SET embedding_input = v_input, embedding = v_embedding,
-           reference_status = 'APPROVED', inspection_status = 'VERIFIED',
-           verified_at = SYSTIMESTAMP, verified_by = 'SGMP_POC_METADATA_REVIEW'
-     WHERE source_type = 'POLICY_TEMPLATE' AND source_case_id = 'COUNTRY_DAILY_AU';
-  END IF;
-  COMMIT;
-END;
-
-/

database/adb/133_sgmp_restore_czn06_exact_fewshot.sql

@@ -1,17 +0,0 @@
--- CZN-06 is a verified, exact customer question/SQL pair. It must be a
--- runtime Few-shot when approved; RETIRED is the DB switch that excludes it.
--- This is a single-game reference, so keep the retrieval scope explicit.
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'COUNTRY_GROUPED_DAILY_AU',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified exact CZN-06 Few-shot restored for runtime retrieval. Daily country AU requires AU_FLAG=1 and EXPT_USER_YN=''N''; STD_USER_YN alone is insufficient.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-06'
-/
-
-COMMIT

database/adb/135_sgmp_semantic_fewshot_retrieval.sql

@@ -1,69 +0,0 @@
--- Runtime Few-shots remain semantic vector retrieval. Customer examples are
--- governed by their DB approval state, not restricted to exact text matches.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'GAME_GOODS_HOLDINGS',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified CZN-07 semantic Few-shot. Use goods holdings, crystal dimension, RU_FLAG=1, excluded-user filter, nonzero holdings, and daily grouping.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-07'
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-  v_max_cosine_distance NUMBER;
-BEGIN
-  IF p_question IS NULL THEN RAISE_APPLICATION_ERROR(-20003, 'question is required.'); END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-
-  SELECT number_value INTO v_max_cosine_distance
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_MAX_COSINE_DISTANCE'
-     AND active_yn = 'Y'
-     AND number_value IS NOT NULL;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           cosine_distance
-      FROM (
-        SELECT example_id, question, answer_sql, answer_text, embedding_model,
-               reference_kind, target_type, object_role, source_case_id, source_type,
-               VECTOR_DISTANCE(embedding, v_query_vector, COSINE) AS cosine_distance
-          FROM sg_qa_vector_example
-         WHERE reference_status = 'APPROVED'
-           AND inspection_status = 'VERIFIED'
-           AND answer_sql IS NOT NULL
-           AND (source_type = 'POLICY_TEMPLATE'
-                OR NOT REGEXP_LIKE(answer_sql, '<[A-Z][A-Z0-9_]*>', 'i'))
-           AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-      )
-     WHERE cosine_distance <= v_max_cosine_distance
-     ORDER BY cosine_distance, example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-COMMIT

database/adb/136_sgmp_fewshot_neighbor_margin.sql

@@ -1,87 +0,0 @@
--- Keep semantic vector retrieval, but do not inject weak trailing neighbours
--- when a materially stronger example has already been found.
-MERGE INTO sg_game_scope_policy t
-USING (
-  SELECT 'QA_VECTOR_NEIGHBOR_DISTANCE_MARGIN' AS policy_key,
-         0.120000 AS number_value,
-         'Maximum additional cosine distance from the best runtime Few-shot candidate.' AS description
-    FROM dual
-) s
-ON (t.policy_key = s.policy_key)
-WHEN MATCHED THEN UPDATE SET
-  t.number_value = s.number_value,
-  t.description = s.description,
-  t.active_yn = 'Y',
-  t.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  policy_key, number_value, text_value, description, active_yn
-) VALUES (
-  s.policy_key, s.number_value, NULL, s.description, 'Y'
-)
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-  v_max_cosine_distance NUMBER;
-  v_neighbor_margin NUMBER;
-BEGIN
-  IF p_question IS NULL THEN RAISE_APPLICATION_ERROR(-20003, 'question is required.'); END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-
-  SELECT number_value INTO v_max_cosine_distance
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_MAX_COSINE_DISTANCE'
-     AND active_yn = 'Y'
-     AND number_value IS NOT NULL;
-
-  SELECT number_value INTO v_neighbor_margin
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_NEIGHBOR_DISTANCE_MARGIN'
-     AND active_yn = 'Y'
-     AND number_value IS NOT NULL;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           cosine_distance
-      FROM (
-        SELECT c.*,
-               MIN(c.cosine_distance) OVER () AS best_cosine_distance
-          FROM (
-            SELECT example_id, question, answer_sql, answer_text, embedding_model,
-                   reference_kind, target_type, object_role, source_case_id, source_type,
-                   VECTOR_DISTANCE(embedding, v_query_vector, COSINE) AS cosine_distance
-              FROM sg_qa_vector_example
-             WHERE reference_status = 'APPROVED'
-               AND inspection_status = 'VERIFIED'
-               AND answer_sql IS NOT NULL
-               AND (source_type = 'POLICY_TEMPLATE'
-                    OR NOT REGEXP_LIKE(answer_sql, '<[A-Z][A-Z0-9_]*>', 'i'))
-               AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-          ) c
-         WHERE c.cosine_distance <= v_max_cosine_distance
-      )
-     WHERE cosine_distance <= best_cosine_distance + v_neighbor_margin
-     ORDER BY cosine_distance, example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-COMMIT

database/adb/137_sgmp_restore_czn08_crystal_average_fewshot.sql

@@ -1,16 +0,0 @@
--- CZN-08 is the reviewed semantic reference for daily standard-AU crystal
--- total and per-user average holdings.
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'GAME_GOODS_HOLDINGS',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified CZN-08 Few-shot. Standard-AU crystal holdings require AU_FLAG=1, excluded-user filtering, and per-user average as SUM(HAVE_CNT) / COUNT(DISTINCT GUID), not AVG(HAVE_CNT).',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-08'
-/
-
-COMMIT

database/adb/138_sgmp_tighten_fewshot_neighbor_margin.sql

@@ -1,11 +0,0 @@
--- Calibrate the semantic-neighbour window using reviewed CZN patterns:
--- retain close paraphrases, exclude adjacent metric shapes.
-UPDATE sg_game_scope_policy
-   SET number_value = 0.100000,
-       description = 'Maximum additional cosine distance from the best runtime Few-shot candidate.',
-       active_yn = 'Y',
-       updated_at = SYSTIMESTAMP
- WHERE policy_key = 'QA_VECTOR_NEIGHBOR_DISTANCE_MARGIN'
-/
-
-COMMIT

database/adb/139_sgmp_restore_czn05_country_business_au_fewshot.sql

@@ -1,15 +0,0 @@
--- CZN-05 is the reviewed reference for country-grouped business AU.
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'COUNTRY_GROUPED_BUSINESS_AU',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified CZN-05 Few-shot. Join business-user data to user master on GUID and BASE_DT before grouping by user country; filter BIZ_AU_FLAG=1 and EXPT_USER_YN=''N''.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-05'
-/
-
-COMMIT

database/adb/140_sgmp_hybrid_fewshot_reranking.sql

@@ -1,95 +0,0 @@
--- Hybrid retrieval remains database-driven: dense vector similarity handles
--- paraphrases, while lexical similarity distinguishes decisive request terms.
-MERGE INTO sg_game_scope_policy t
-USING (
-  SELECT 'QA_VECTOR_LEXICAL_WEIGHT' AS policy_key, 0.350000 AS number_value,
-         'Weight of normalized lexical question similarity in runtime Few-shot reranking.' AS description
-    FROM dual
-  UNION ALL
-  SELECT 'QA_VECTOR_HYBRID_SCORE_MARGIN', 0.050000,
-         'Maximum hybrid-score difference from the best runtime Few-shot candidate.'
-    FROM dual
-) s
-ON (t.policy_key = s.policy_key)
-WHEN MATCHED THEN UPDATE SET
-  t.number_value = s.number_value,
-  t.description = s.description,
-  t.active_yn = 'Y',
-  t.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  policy_key, number_value, text_value, description, active_yn
-) VALUES (
-  s.policy_key, s.number_value, NULL, s.description, 'Y'
-)
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results SYS_REFCURSOR;
-  v_target_type VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-  v_max_cosine_distance NUMBER;
-  v_lexical_weight NUMBER;
-  v_hybrid_margin NUMBER;
-BEGIN
-  IF p_question IS NULL THEN RAISE_APPLICATION_ERROR(-20003, 'question is required.'); END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'invalid target type.');
-  END IF;
-
-  SELECT number_value INTO v_max_cosine_distance FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_MAX_COSINE_DISTANCE' AND active_yn = 'Y';
-  SELECT number_value INTO v_lexical_weight FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_LEXICAL_WEIGHT' AND active_yn = 'Y';
-  SELECT number_value INTO v_hybrid_margin FROM sg_game_scope_policy
-   WHERE policy_key = 'QA_VECTOR_HYBRID_SCORE_MARGIN' AND active_yn = 'Y';
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question, JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id, question, answer_sql, answer_text, embedding_model,
-           reference_kind, target_type, object_role, source_case_id, source_type,
-           cosine_distance
-      FROM (
-        SELECT s.*,
-               MAX(s.hybrid_score) OVER () AS best_hybrid_score
-          FROM (
-            SELECT c.*,
-                   ((1 - v_lexical_weight) * (1 - c.cosine_distance)
-                    + v_lexical_weight * c.lexical_similarity) AS hybrid_score
-              FROM (
-                SELECT example_id, question, answer_sql, answer_text, embedding_model,
-                       reference_kind, target_type, object_role, source_case_id, source_type,
-                       VECTOR_DISTANCE(embedding, v_query_vector, COSINE) AS cosine_distance,
-                       UTL_MATCH.JARO_WINKLER_SIMILARITY(
-                         DBMS_LOB.SUBSTR(question, 4000, 1),
-                         DBMS_LOB.SUBSTR(p_question, 4000, 1)
-                       ) / 100 AS lexical_similarity
-                  FROM sg_qa_vector_example
-                 WHERE reference_status = 'APPROVED'
-                   AND inspection_status = 'VERIFIED'
-                   AND answer_sql IS NOT NULL
-                   AND (source_type = 'POLICY_TEMPLATE'
-                        OR NOT REGEXP_LIKE(answer_sql, '<[A-Z][A-Z0-9_]*>', 'i'))
-                   AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-              ) c
-             WHERE c.cosine_distance <= v_max_cosine_distance
-          ) s
-      )
-     WHERE hybrid_score >= best_hybrid_score - v_hybrid_margin
-     ORDER BY hybrid_score DESC, cosine_distance, example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-COMMIT

database/adb/141_sgmp_restore_czn13_ether_usage_fewshot.sql

@@ -1,15 +0,0 @@
--- CZN-13 is the reviewed reference for Ether usage and distinct users.
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'GAME_GOODS_CHANGE',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified CZN-13 Few-shot. Ether usage requires goods-change data joined to the goods dimension and user master by GUID and BASE_DT, CHANGE_TYPE_CD=''USE'', active Ether dimension, excluded-user filter, and GOODS_CHANGE_CNT aggregation.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-13'
-/
-
-COMMIT

database/adb/142_sgmp_restore_czn16_product_buyer_fewshot.sql

@@ -1,15 +0,0 @@
--- CZN-16 is the reviewed reference for purchasers of a named package.
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'SALES_PRODUCT_PURCHASER',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Verified CZN-16 Few-shot. Join sales transactions to product display by GAME_ID and PRODUCT_ID, filter the resolved package name and excluded users, and use the payment business date when counting distinct purchasers.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-16'
-/
-
-COMMIT

database/adb/72_hmm_leave_team_vpd.sql

@@ -1,597 +0,0 @@
--- ============================================================
--- 72_hmm_leave_team_vpd.sql
---
--- HMM HR leave row security:
---   * HMM_HR_MANAGER -> self and directly managed employees
---   * HMM_HR_VIEWER  -> self only
---   * HMM_HR_ADMIN   -> all rows when the role is explicitly assigned
---
--- Run as ADMIN after the HMM access-management schema is installed.
--- This script is idempotent and never stores a plain bearer token.
--- ============================================================
-WHENEVER SQLERROR EXIT SQL.SQLCODE
-SET ECHO OFF
-SET FEEDBACK ON
-SET DEFINE OFF
-
-ALTER SESSION DISABLE PARALLEL DML;
-
-PROMPT === 1. Ensuring HMM roles and demo role assignments ===
-MERGE INTO hmm_access_roles dst
-USING (
-  SELECT 1 role_id, 'HMM_HR_VIEWER' role_name,
-         'HMM employee self-service leave access' description,
-         'PUBLIC' max_sensitivity_level FROM dual
-  UNION ALL
-  SELECT 2, 'HMM_HR_MANAGER',
-         'HMM manager access to self and direct reports',
-         'INTERNAL' FROM dual
-  UNION ALL
-  SELECT 3, 'HMM_HR_ADMIN',
-         'HMM HR administrator full leave access',
-         'CONFIDENTIAL' FROM dual
-) src
-ON (dst.role_name = src.role_name)
-WHEN MATCHED THEN UPDATE SET
-  dst.description = src.description,
-  dst.max_sensitivity_level = src.max_sensitivity_level,
-  dst.active_yn = 'Y',
-  dst.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  role_id, role_name, description, max_sensitivity_level,
-  active_yn, created_at, updated_at
-) VALUES (
-  src.role_id, src.role_name, src.description, src.max_sensitivity_level,
-  'Y', SYSTIMESTAMP, SYSTIMESTAMP
-);
-
-MERGE INTO hmm_employee_access_roles dst
-USING (
-  SELECT e.employee_id, r.role_id
-  FROM hmm_hr_employees e
-  JOIN hmm_access_roles r ON r.role_name = 'HMM_HR_MANAGER'
-  WHERE e.employee_code = 'E1001'
-    AND e.employment_status = 'ACTIVE'
-) src
-ON (dst.employee_id = src.employee_id AND dst.role_id = src.role_id)
-WHEN NOT MATCHED THEN INSERT (employee_id, role_id, created_at)
-VALUES (src.employee_id, src.role_id, SYSTIMESTAMP);
-
-MERGE INTO hmm_employee_access_roles dst
-USING (
-  SELECT e.employee_id, r.role_id
-  FROM hmm_hr_employees e
-  JOIN hmm_access_roles r ON r.role_name = 'HMM_HR_VIEWER'
-  WHERE e.manager_employee_id = (
-    SELECT manager.employee_id
-    FROM hmm_hr_employees manager
-    WHERE manager.employee_code = 'E1001'
-  )
-    AND e.employment_status = 'ACTIVE'
-) src
-ON (dst.employee_id = src.employee_id AND dst.role_id = src.role_id)
-WHEN NOT MATCHED THEN INSERT (employee_id, role_id, created_at)
-VALUES (src.employee_id, src.role_id, SYSTIMESTAMP);
-
-COMMIT;
-
-PROMPT === 2. Ensuring protected leave objects and columns ===
-DECLARE
-  PROCEDURE ensure_object(
-    p_object_name IN VARCHAR2,
-    p_description IN VARCHAR2
-  ) AS
-    v_object_id NUMBER;
-  BEGIN
-    BEGIN
-      SELECT object_id
-      INTO v_object_id
-      FROM hmm_access_objects
-      WHERE owner = 'ADMIN'
-        AND object_name = p_object_name;
-
-      UPDATE hmm_access_objects
-      SET enabled_yn = 'Y',
-          description = p_description,
-          ords_path = 'cb-ords/cb-object-query/admin/' || LOWER(p_object_name)
-      WHERE object_id = v_object_id;
-    EXCEPTION
-      WHEN NO_DATA_FOUND THEN
-        SELECT NVL(MAX(object_id), 0) + 1
-        INTO v_object_id
-        FROM hmm_access_objects;
-
-        INSERT INTO hmm_access_objects (
-          object_id, owner, object_name, ords_path, enabled_yn, description
-        ) VALUES (
-          v_object_id,
-          'ADMIN',
-          p_object_name,
-          'cb-ords/cb-object-query/admin/' || LOWER(p_object_name),
-          'Y',
-          p_description
-        );
-    END;
-
-    FOR c IN (
-      SELECT column_name
-      FROM user_tab_columns
-      WHERE table_name = p_object_name
-      ORDER BY column_id
-    ) LOOP
-      MERGE INTO hmm_access_object_columns dst
-      USING (
-        SELECT v_object_id object_id, c.column_name column_name
-        FROM dual
-      ) src
-      ON (
-        dst.object_id = src.object_id
-        AND dst.column_name = src.column_name
-      )
-      WHEN NOT MATCHED THEN INSERT (
-        column_id, object_id, column_name, sensitive_yn,
-        sensitivity_level, redaction_method
-      ) VALUES (
-        (SELECT NVL(MAX(column_id), 0) + 1 FROM hmm_access_object_columns),
-        src.object_id,
-        src.column_name,
-        'N',
-        'PUBLIC',
-        'NONE'
-      );
-    END LOOP;
-  END;
-BEGIN
-  ensure_object(
-    'HMM_LEAVE_BALANCES',
-    'HMM employee leave balance protected by employee hierarchy'
-  );
-  ensure_object(
-    'HMM_LEAVE_REQUESTS',
-    'HMM employee leave requests protected by employee hierarchy'
-  );
-END;
-/
-
-COMMIT;
-
-PROMPT === 3. Ensuring role permission rules ===
-DECLARE
-  PROCEDURE ensure_permission(
-    p_role_name   IN VARCHAR2,
-    p_target_name IN VARCHAR2,
-    p_rule_type   IN VARCHAR2
-  ) AS
-    v_role_id NUMBER;
-    v_perm_id NUMBER;
-  BEGIN
-    SELECT role_id
-    INTO v_role_id
-    FROM hmm_access_roles
-    WHERE role_name = p_role_name
-      AND active_yn = 'Y';
-
-    BEGIN
-      SELECT perm_id
-      INTO v_perm_id
-      FROM hmm_access_permissions
-      WHERE role_id = v_role_id
-        AND target_name = p_target_name
-        AND action_name = 'SELECT';
-
-      UPDATE hmm_access_permissions
-      SET permission_effect = 'ALLOW'
-      WHERE perm_id = v_perm_id;
-    EXCEPTION
-      WHEN NO_DATA_FOUND THEN
-        SELECT cb_permission_seq.NEXTVAL
-        INTO v_perm_id
-        FROM dual;
-
-        INSERT INTO hmm_access_permissions (
-          perm_id, role_id, target_name, action_name, permission_effect
-        ) VALUES (
-          v_perm_id, v_role_id, p_target_name, 'SELECT', 'ALLOW'
-        );
-    END;
-
-    DELETE FROM hmm_access_permission_rules
-    WHERE perm_id = v_perm_id;
-
-    INSERT INTO hmm_access_permission_rules (
-      rule_id, perm_id, rule_column, rule_type, rule_value
-    ) VALUES (
-      cb_permission_rule_seq.NEXTVAL,
-      v_perm_id,
-      'EMPLOYEE_ID',
-      p_rule_type,
-      NULL
-    );
-  END;
-BEGIN
-  ensure_permission('HMM_HR_VIEWER',  'HMM_LEAVE_BALANCES', 'SELF');
-  ensure_permission('HMM_HR_VIEWER',  'HMM_LEAVE_REQUESTS', 'SELF');
-  ensure_permission('HMM_HR_MANAGER', 'HMM_LEAVE_BALANCES', 'MANAGED_TEAM');
-  ensure_permission('HMM_HR_MANAGER', 'HMM_LEAVE_REQUESTS', 'MANAGED_TEAM');
-  ensure_permission('HMM_HR_ADMIN',   'HMM_LEAVE_BALANCES', 'ALL');
-  ensure_permission('HMM_HR_ADMIN',   'HMM_LEAVE_REQUESTS', 'ALL');
-END;
-/
-
-COMMIT;
-
-PROMPT === 4. Creating secure HMM access context ===
-CREATE OR REPLACE PACKAGE hmm_access_ctx_pkg AUTHID DEFINER AS
-  PROCEDURE clear_user;
-  PROCEDURE set_user_by_bearer(p_bearer_token IN VARCHAR2);
-END;
-/
-
-CREATE OR REPLACE PACKAGE BODY hmm_access_ctx_pkg AS
-  PROCEDURE clear_user AS
-  BEGIN
-    DBMS_SESSION.SET_CONTEXT('HMM_ACCESS_CTX', 'EMPLOYEE_ID', NULL);
-    DBMS_SESSION.SET_CONTEXT('HMM_ACCESS_CTX', 'EMPLOYEE_CODE', NULL);
-    DBMS_SESSION.SET_CONTEXT('HMM_ACCESS_CTX', 'TEAM_ID', NULL);
-  END;
-
-  PROCEDURE set_user_by_bearer(p_bearer_token IN VARCHAR2) AS
-    v_employee_id   hmm_hr_employees.employee_id%TYPE;
-    v_employee_code hmm_hr_employees.employee_code%TYPE;
-    v_team_id       hmm_hr_employees.team_id%TYPE;
-  BEGIN
-    IF p_bearer_token IS NULL OR TRIM(p_bearer_token) IS NULL THEN
-      clear_user;
-      RAISE_APPLICATION_ERROR(-20101, 'Bearer token is required');
-    END IF;
-
-    SELECT e.employee_id,
-           e.employee_code,
-           e.team_id
-    INTO v_employee_id,
-         v_employee_code,
-         v_team_id
-    FROM hmm_access_bearer_tokens t
-    JOIN hmm_hr_employees e
-      ON e.employee_id = t.employee_id
-    WHERE t.key_hash = STANDARD_HASH(p_bearer_token, 'SHA256')
-      AND t.revoked_at IS NULL
-      AND t.expires_at > CAST(SYSTIMESTAMP AS TIMESTAMP)
-      AND e.employment_status = 'ACTIVE';
-
-    DBMS_SESSION.SET_CONTEXT(
-      'HMM_ACCESS_CTX', 'EMPLOYEE_ID', TO_CHAR(v_employee_id)
-    );
-    DBMS_SESSION.SET_CONTEXT(
-      'HMM_ACCESS_CTX', 'EMPLOYEE_CODE', v_employee_code
-    );
-    DBMS_SESSION.SET_CONTEXT(
-      'HMM_ACCESS_CTX', 'TEAM_ID', TO_CHAR(v_team_id)
-    );
-  EXCEPTION
-    WHEN NO_DATA_FOUND THEN
-      clear_user;
-      RAISE_APPLICATION_ERROR(-20102, 'Invalid or expired bearer token');
-    WHEN TOO_MANY_ROWS THEN
-      clear_user;
-      RAISE_APPLICATION_ERROR(-20103, 'Bearer token mapping is not unique');
-  END;
-END;
-/
-
-CREATE OR REPLACE CONTEXT hmm_access_ctx USING hmm_access_ctx_pkg;
-
-PROMPT === 5. Creating the HMM leave VPD filter ===
-CREATE OR REPLACE FUNCTION hmm_leave_vpd_filter(
-  p_schema IN VARCHAR2,
-  p_object IN VARCHAR2
-) RETURN VARCHAR2
-AUTHID DEFINER
-AS
-  v_employee_id         NUMBER;
-  v_target              VARCHAR2(128);
-  v_allow_predicate     VARCHAR2(32767);
-  v_deny_predicate      VARCHAR2(32767);
-  v_permission_clause   VARCHAR2(32767);
-
-  FUNCTION quote_literal(p_value IN VARCHAR2) RETURN VARCHAR2 IS
-  BEGIN
-    RETURN '''' || REPLACE(NVL(p_value, ''), '''', '''''') || '''';
-  END;
-
-  FUNCTION safe_column(p_column_name IN VARCHAR2) RETURN VARCHAR2 IS
-    v_column VARCHAR2(128);
-    v_count  NUMBER;
-  BEGIN
-    v_column := DBMS_ASSERT.SIMPLE_SQL_NAME(UPPER(TRIM(p_column_name)));
-
-    SELECT COUNT(*)
-    INTO v_count
-    FROM all_tab_columns
-    WHERE owner = UPPER(p_schema)
-      AND table_name = UPPER(p_object)
-      AND column_name = v_column;
-
-    RETURN CASE WHEN v_count = 1 THEN v_column ELSE NULL END;
-  EXCEPTION
-    WHEN OTHERS THEN
-      RETURN NULL;
-  END;
-
-  PROCEDURE append_and(p_clause IN VARCHAR2) IS
-  BEGIN
-    IF p_clause IS NULL THEN
-      v_permission_clause := NULL;
-    ELSIF v_permission_clause IS NULL THEN
-      v_permission_clause := '(' || p_clause || ')';
-    ELSE
-      v_permission_clause := v_permission_clause || ' AND (' || p_clause || ')';
-    END IF;
-  END;
-
-  PROCEDURE append_permission(
-    p_effect IN VARCHAR2,
-    p_clause IN VARCHAR2
-  ) IS
-  BEGIN
-    IF p_clause IS NULL THEN
-      RETURN;
-    END IF;
-
-    IF p_effect = 'DENY' THEN
-      IF v_deny_predicate IS NULL THEN
-        v_deny_predicate := '(' || p_clause || ')';
-      ELSE
-        v_deny_predicate := v_deny_predicate || ' OR (' || p_clause || ')';
-      END IF;
-    ELSIF v_allow_predicate IS NULL THEN
-      v_allow_predicate := '(' || p_clause || ')';
-    ELSE
-      v_allow_predicate := v_allow_predicate || ' OR (' || p_clause || ')';
-    END IF;
-  END;
-BEGIN
-  BEGIN
-    v_employee_id := TO_NUMBER(
-      SYS_CONTEXT('HMM_ACCESS_CTX', 'EMPLOYEE_ID')
-    );
-  EXCEPTION
-    WHEN OTHERS THEN
-      RETURN '1 = 0';
-  END;
-
-  IF v_employee_id IS NULL OR p_schema IS NULL OR p_object IS NULL THEN
-    RETURN '1 = 0';
-  END IF;
-
-  v_target := UPPER(TRIM(p_object));
-  IF v_target NOT IN ('HMM_LEAVE_BALANCES', 'HMM_LEAVE_REQUESTS') THEN
-    RETURN '1 = 0';
-  END IF;
-
-  FOR permission_row IN (
-    SELECT DISTINCT
-           p.perm_id,
-           NVL(UPPER(TRIM(p.permission_effect)), 'ALLOW') permission_effect
-    FROM (
-      SELECT er.role_id
-      FROM hmm_employee_access_roles er
-      WHERE er.employee_id = v_employee_id
-      UNION
-      SELECT gr.role_id
-      FROM hmm_access_group_members gm
-      JOIN hmm_access_groups g
-        ON g.group_id = gm.group_id
-       AND g.active_yn = 'Y'
-      JOIN hmm_group_access_roles gr
-        ON gr.group_id = gm.group_id
-      WHERE gm.employee_id = v_employee_id
-    ) effective_role
-    JOIN hmm_access_roles role
-      ON role.role_id = effective_role.role_id
-     AND role.active_yn = 'Y'
-    JOIN hmm_access_permissions p
-      ON p.role_id = role.role_id
-     AND p.target_name = v_target
-     AND p.action_name = 'SELECT'
-    ORDER BY p.perm_id
-  ) LOOP
-    v_permission_clause := NULL;
-
-    FOR rule_row IN (
-      SELECT UPPER(TRIM(rule_type)) rule_type,
-             UPPER(TRIM(rule_column)) rule_column,
-             rule_value
-      FROM hmm_access_permission_rules
-      WHERE perm_id = permission_row.perm_id
-      ORDER BY rule_id
-    ) LOOP
-      DECLARE
-        v_column VARCHAR2(128);
-        v_clause VARCHAR2(32767);
-      BEGIN
-        v_column := safe_column(NVL(rule_row.rule_column, 'EMPLOYEE_ID'));
-        v_clause := NULL;
-
-        IF rule_row.rule_type = 'ALL' THEN
-          v_clause := '1 = 1';
-        ELSIF rule_row.rule_type = 'SELF' AND v_column IS NOT NULL THEN
-          v_clause := v_column
-            || ' = TO_NUMBER(SYS_CONTEXT(''HMM_ACCESS_CTX'', ''EMPLOYEE_ID''))';
-        ELSIF rule_row.rule_type = 'MANAGED_TEAM' AND v_column IS NOT NULL THEN
-          v_clause := v_column || ' IN ('
-            || 'SELECT employee.employee_id '
-            || 'FROM ADMIN.HMM_HR_EMPLOYEES employee '
-            || 'WHERE employee.employee_id = '
-            || 'TO_NUMBER(SYS_CONTEXT(''HMM_ACCESS_CTX'', ''EMPLOYEE_ID'')) '
-            || 'OR employee.manager_employee_id = '
-            || 'TO_NUMBER(SYS_CONTEXT(''HMM_ACCESS_CTX'', ''EMPLOYEE_ID''))'
-            || ')';
-        ELSIF rule_row.rule_type = '='
-              AND v_column IS NOT NULL
-              AND rule_row.rule_value IS NOT NULL THEN
-          v_clause := 'TO_CHAR(' || v_column || ') = '
-            || quote_literal(rule_row.rule_value);
-        ELSIF rule_row.rule_type IN ('!=', '<>')
-              AND v_column IS NOT NULL
-              AND rule_row.rule_value IS NOT NULL THEN
-          v_clause := 'TO_CHAR(' || v_column || ') <> '
-            || quote_literal(rule_row.rule_value);
-        END IF;
-
-        IF v_clause IS NULL THEN
-          v_permission_clause := NULL;
-          EXIT;
-        END IF;
-        append_and(v_clause);
-      END;
-    END LOOP;
-
-    append_permission(
-      permission_row.permission_effect,
-      v_permission_clause
-    );
-  END LOOP;
-
-  IF v_allow_predicate IS NULL THEN
-    RETURN '1 = 0';
-  END IF;
-
-  IF v_deny_predicate IS NULL THEN
-    RETURN v_allow_predicate;
-  END IF;
-
-  RETURN '((' || v_allow_predicate || ') AND NOT ('
-    || v_deny_predicate || '))';
-EXCEPTION
-  WHEN OTHERS THEN
-    RETURN '1 = 0';
-END;
-/
-
-SHOW ERRORS PACKAGE hmm_access_ctx_pkg
-SHOW ERRORS PACKAGE BODY hmm_access_ctx_pkg
-SHOW ERRORS FUNCTION hmm_leave_vpd_filter
-
-PROMPT === 6. Attaching context-sensitive VPD policies ===
-DECLARE
-  PROCEDURE replace_policy(p_object_name IN VARCHAR2) AS
-  BEGIN
-    BEGIN
-      DBMS_RLS.DROP_POLICY(
-        object_schema => 'ADMIN',
-        object_name => p_object_name,
-        policy_name => 'HMM_LEAVE_SCOPE_POLICY'
-      );
-    EXCEPTION
-      WHEN OTHERS THEN
-        IF SQLCODE != -28102 THEN
-          RAISE;
-        END IF;
-    END;
-
-    DBMS_RLS.ADD_POLICY(
-      object_schema => 'ADMIN',
-      object_name => p_object_name,
-      policy_name => 'HMM_LEAVE_SCOPE_POLICY',
-      function_schema => 'ADMIN',
-      policy_function => 'HMM_LEAVE_VPD_FILTER',
-      statement_types => 'SELECT',
-      update_check => FALSE,
-      enable => TRUE,
-      policy_type => DBMS_RLS.CONTEXT_SENSITIVE
-    );
-  END;
-BEGIN
-  replace_policy('HMM_LEAVE_BALANCES');
-  replace_policy('HMM_LEAVE_REQUESTS');
-END;
-/
-
-PROMPT === 7. Recording backoffice descriptions ===
-MERGE INTO hmm_access_vpd_filter_notes dst
-USING (
-  SELECT 'ADMIN' function_owner,
-         'HMM_LEAVE_VPD_FILTER' function_name,
-         'Builds self, managed-team, and administrator leave predicates from HMM roles and access rules.'
-           description
-  FROM dual
-) src
-ON (
-  dst.function_owner = src.function_owner
-  AND dst.function_name = src.function_name
-)
-WHEN MATCHED THEN UPDATE SET
-  dst.description = src.description,
-  dst.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  function_owner, function_name, description, updated_at
-) VALUES (
-  src.function_owner, src.function_name, src.description, SYSTIMESTAMP
-);
-
-MERGE INTO hmm_access_vpd_policy_notes dst
-USING (
-  SELECT 'ADMIN' object_owner,
-         object_name,
-         'HMM_LEAVE_SCOPE_POLICY' policy_name,
-         'Restricts leave rows to self, direct reports, or explicit HR administrator access.'
-           description
-  FROM (
-    SELECT 'HMM_LEAVE_BALANCES' object_name FROM dual
-    UNION ALL
-    SELECT 'HMM_LEAVE_REQUESTS' FROM dual
-  )
-) src
-ON (
-  dst.object_owner = src.object_owner
-  AND dst.object_name = src.object_name
-  AND dst.policy_name = src.policy_name
-)
-WHEN MATCHED THEN UPDATE SET
-  dst.description = src.description,
-  dst.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  object_owner, object_name, policy_name, description, updated_at
-) VALUES (
-  src.object_owner, src.object_name, src.policy_name,
-  src.description, SYSTIMESTAMP
-);
-
-COMMIT;
-
-PROMPT === 8. Deployment inventory ===
-SELECT object_name, object_type, status
-FROM user_objects
-WHERE object_name IN (
-  'HMM_ACCESS_CTX',
-  'HMM_ACCESS_CTX_PKG',
-  'HMM_LEAVE_VPD_FILTER'
-)
-ORDER BY object_name, object_type;
-
-SELECT object_name, policy_name, function, sel, enable, policy_type
-FROM all_policies
-WHERE object_owner = 'ADMIN'
-  AND object_name IN ('HMM_LEAVE_BALANCES', 'HMM_LEAVE_REQUESTS')
-  AND policy_name = 'HMM_LEAVE_SCOPE_POLICY'
-ORDER BY object_name;
-
-SELECT e.employee_code, r.role_name
-FROM hmm_employee_access_roles er
-JOIN hmm_hr_employees e ON e.employee_id = er.employee_id
-JOIN hmm_access_roles r ON r.role_id = er.role_id
-WHERE r.role_name IN ('HMM_HR_VIEWER', 'HMM_HR_MANAGER')
-ORDER BY e.employee_code, r.role_name;
-
-SELECT r.role_name,
-       p.target_name,
-       pr.rule_column,
-       pr.rule_type
-FROM hmm_access_permissions p
-JOIN hmm_access_roles r ON r.role_id = p.role_id
-JOIN hmm_access_permission_rules pr ON pr.perm_id = p.perm_id
-WHERE p.target_name IN ('HMM_LEAVE_BALANCES', 'HMM_LEAVE_REQUESTS')
-ORDER BY r.role_name, p.target_name;
-
-PROMPT === HMM leave team VPD ready ===

database/adb/73_hmm_mcp_vpd_runtime.sql

@@ -1,159 +0,0 @@
--- #740 HMM MCP VPD execution boundary
--- Run as ADMIN with SQLcl. The password is prompted without echo and is used
--- only when CB_ORDS does not already exist.
-set define on verify off echo off feedback on serveroutput on
-whenever sqlerror exit sql.sqlcode rollback
-
-accept hmm_cb_ords_password char prompt 'CB_ORDS initial password: ' hide
-
-declare
-  v_user_count number;
-  v_password varchar2(4000) := q'~&hmm_cb_ords_password~';
-begin
-  select count(*)
-    into v_user_count
-    from dba_users
-   where username = 'CB_ORDS';
-
-  if v_user_count = 0 then
-    if length(v_password) < 16
-       or instr(v_password, '"') > 0
-       or instr(v_password, chr(10)) > 0
-       or instr(v_password, chr(13)) > 0
-       or not regexp_like(v_password, '[A-Z]')
-       or not regexp_like(v_password, '[a-z]')
-       or not regexp_like(v_password, '[0-9]')
-       or not regexp_like(v_password, '[^A-Za-z0-9]') then
-      raise_application_error(
-          -20001,
-          'CB_ORDS password must be 16+ chars with upper/lower/digit/special and no quote/newline.');
-    end if;
-    execute immediate
-        'create user CB_ORDS identified by "' || v_password || '" '
-        || 'default tablespace DATA temporary tablespace TEMP quota 0 on DATA';
-    dbms_output.put_line('Created CB_ORDS.');
-  else
-    dbms_output.put_line('CB_ORDS already exists; password was not changed.');
-  end if;
-end;
-/
-
-alter user CB_ORDS account unlock;
-grant create session to CB_ORDS;
-
-create or replace package CB_ORDS_HANDLER_PKG
-authid definer
-as
-  procedure SET_VPD_CONTEXT(p_authorization in varchar2);
-  procedure CLEAR_VPD_CONTEXT;
-end CB_ORDS_HANDLER_PKG;
-/
-
-create or replace package body CB_ORDS_HANDLER_PKG
-as
-  c_bearer_prefix constant varchar2(7) := 'Bearer ';
-
-  procedure CLEAR_VPD_CONTEXT
-  is
-  begin
-    HMM_ACCESS_CTX_PKG.CLEAR_USER;
-    dbms_session.clear_identifier;
-  end CLEAR_VPD_CONTEXT;
-
-  procedure SET_VPD_CONTEXT(p_authorization in varchar2)
-  is
-    v_authorization varchar2(2048) := trim(p_authorization);
-    v_token varchar2(512);
-  begin
-    CLEAR_VPD_CONTEXT;
-    if v_authorization is null
-       or length(v_authorization) > 2048
-       or upper(substr(v_authorization, 1, length(c_bearer_prefix)))
-          <> upper(c_bearer_prefix) then
-      raise_application_error(-20002, 'A valid Bearer authorization header is required.');
-    end if;
-
-    v_token := trim(substr(v_authorization, length(c_bearer_prefix) + 1));
-    if v_token is null or length(v_token) > 512 then
-      raise_application_error(-20003, 'A valid Bearer token is required.');
-    end if;
-
-    HMM_ACCESS_CTX_PKG.SET_USER_BY_BEARER(v_token);
-    dbms_session.set_identifier(
-        sys_context('HMM_ACCESS_CTX', 'EMPLOYEE_CODE'));
-  exception
-    when others then
-      CLEAR_VPD_CONTEXT;
-      raise;
-  end SET_VPD_CONTEXT;
-end CB_ORDS_HANDLER_PKG;
-/
-
-grant execute on CB_ORDS_HANDLER_PKG to CB_ORDS;
-
-grant select on HMM_ORG_TEAMS to CB_ORDS;
-grant select on HMM_HR_EMPLOYEES to CB_ORDS;
-grant select on HMM_LEAVE_BALANCES to CB_ORDS;
-grant select on HMM_LEAVE_REQUESTS to CB_ORDS;
-grant select on HMM_ATTENDANCE_DAILY to CB_ORDS;
-grant select on HMM_HR_TERMS to CB_ORDS;
-
-create or replace synonym CB_ORDS.CB_ORDS_HANDLER_PKG
-  for ADMIN.CB_ORDS_HANDLER_PKG;
-create or replace synonym CB_ORDS.HMM_ORG_TEAMS
-  for ADMIN.HMM_ORG_TEAMS;
-create or replace synonym CB_ORDS.HMM_HR_EMPLOYEES
-  for ADMIN.HMM_HR_EMPLOYEES;
-create or replace synonym CB_ORDS.HMM_LEAVE_BALANCES
-  for ADMIN.HMM_LEAVE_BALANCES;
-create or replace synonym CB_ORDS.HMM_LEAVE_REQUESTS
-  for ADMIN.HMM_LEAVE_REQUESTS;
-create or replace synonym CB_ORDS.HMM_ATTENDANCE_DAILY
-  for ADMIN.HMM_ATTENDANCE_DAILY;
-create or replace synonym CB_ORDS.HMM_HR_TERMS
-  for ADMIN.HMM_HR_TERMS;
-
-declare
-  v_exempt_count number;
-  v_policy_count number;
-begin
-  select count(*)
-    into v_exempt_count
-    from dba_sys_privs
-   where grantee = 'CB_ORDS'
-     and privilege = 'EXEMPT ACCESS POLICY';
-  if v_exempt_count <> 0 then
-    raise_application_error(-20004, 'CB_ORDS must not have EXEMPT ACCESS POLICY.');
-  end if;
-
-  select count(*)
-    into v_policy_count
-    from dba_policies
-   where object_owner = 'ADMIN'
-     and object_name in ('HMM_LEAVE_BALANCES', 'HMM_LEAVE_REQUESTS')
-     and policy_name = 'HMM_LEAVE_SCOPE_POLICY'
-     and enable = 'YES'
-     and sel = 'YES';
-  if v_policy_count <> 2 then
-    raise_application_error(-20005, 'Both HMM leave VPD policies must be enabled.');
-  end if;
-end;
-/
-
-select username, account_status
-  from dba_users
- where username = 'CB_ORDS';
-
-select privilege
-  from dba_sys_privs
- where grantee = 'CB_ORDS'
- order by privilege;
-
-select object_name, object_type, status
-  from dba_objects
- where owner = 'ADMIN'
-   and object_name = 'CB_ORDS_HANDLER_PKG'
- order by object_type;
-
-undefine hmm_cb_ords_password
-prompt HMM MCP VPD runtime boundary is ready.

database/adb/73_hmm_rds_pg_00_precheck.sql

@@ -1,32 +0,0 @@
--- ============================================================
--- HMM ADB -> AWS RDS PostgreSQL federation demo
--- Step 0: precheck
--- Run in Database Actions SQL Worksheet as ADMIN.
--- Redmine: #730
--- ============================================================
-
-SELECT
-  USER AS session_user,
-  SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') AS current_schema,
-  SYS_CONTEXT('USERENV', 'DB_NAME') AS database_name
-FROM dual;
-
-SELECT credential_name, username
-FROM all_credentials
-WHERE credential_name = 'HMM_RDS_PG_CRED';
-
-SELECT db_link, username, host, created
-FROM user_db_links
-WHERE db_link = 'HMM_RDS_PG_LINK';
-
-SELECT object_name, object_type, status
-FROM user_objects
-WHERE object_name IN (
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-)
-ORDER BY object_name;
-
--- First recording: the last three queries should return no rows.
--- If objects already exist, run 80_hmm_rds_pg_99_cleanup.sql first.

database/adb/74_hmm_rds_pg_01_credential.sql

@@ -1,20 +0,0 @@
--- ============================================================
--- Step 1: create the PostgreSQL credential.
--- Run only this statement after replacing <RDS_PASSWORD> in the
--- Worksheet. Never save the actual password in this file.
--- Redmine: #730
--- ============================================================
-
-BEGIN
-  DBMS_CLOUD.CREATE_CREDENTIAL(
-    credential_name => 'HMM_RDS_PG_CRED',
-    username        => 'postgres',
-    password        => '<RDS_PASSWORD>'
-  );
-END;
-/
-
--- Passwords are never returned by ALL_CREDENTIALS.
-SELECT credential_name, username
-FROM all_credentials
-WHERE credential_name = 'HMM_RDS_PG_CRED';

database/adb/75_hmm_rds_pg_02_acl.sql

@@ -1,61 +0,0 @@
--- ============================================================
--- Step 2: register and verify the host-specific ACL.
--- Run as ADMIN.
---
--- Important:
--- Oracle-managed heterogeneous Database Link traffic uses the
--- managed gateway. This ACL records SQL-user host permissions;
--- it does not replace the AWS RDS Security Group rule.
--- Redmine: #730
--- ============================================================
-
--- DNS resolution privilege must not have a port range.
-BEGIN
-  DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
-    host => 'database-1.czaaygccsncp.ap-northeast-2.rds.amazonaws.com',
-    ace  => XS$ACE_TYPE(
-      privilege_list => XS$NAME_LIST('resolve'),
-      principal_name => SYS_CONTEXT('USERENV', 'SESSION_USER'),
-      principal_type => XS_ACL.PTYPE_DB
-    )
-  );
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -24243 THEN
-      RAISE;
-    END IF;
-END;
-/
-
--- Permit only the PostgreSQL service port.
-BEGIN
-  DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
-    host       => 'database-1.czaaygccsncp.ap-northeast-2.rds.amazonaws.com',
-    lower_port => 5432,
-    upper_port => 5432,
-    ace        => XS$ACE_TYPE(
-      privilege_list => XS$NAME_LIST('connect'),
-      principal_name => SYS_CONTEXT('USERENV', 'SESSION_USER'),
-      principal_type => XS_ACL.PTYPE_DB
-    )
-  );
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -24243 THEN
-      RAISE;
-    END IF;
-END;
-/
-
-SELECT
-  host,
-  lower_port,
-  upper_port,
-  principal,
-  privilege,
-  grant_type
-FROM dba_host_aces
-WHERE host = 'database-1.czaaygccsncp.ap-northeast-2.rds.amazonaws.com'
-  AND principal = USER
-  AND privilege IN ('resolve', 'connect')
-ORDER BY privilege, lower_port;

database/adb/75_sgmp_qa_vector_retrieval.sql

@@ -1,199 +0,0 @@
--- SGMP QA example vector store.
---
--- Run as SGMP_POC after scripts/setup-sgmp-qa-vector.sh has registered the
--- DBMS_VECTOR credential and granted the HTTPS ACL.  No API key material is
--- stored in this file.
---
--- Cohere Embed 4 is intentionally fixed to 1536 dimensions.  Stored examples
--- use search_document; incoming questions use search_query.
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*) INTO v_count
-    FROM user_tables
-   WHERE table_name = 'SG_QA_VECTOR_CONFIG';
-
-  IF v_count = 0 THEN
-    EXECUTE IMMEDIATE q'[
-      CREATE TABLE sg_qa_vector_config (
-        config_key   VARCHAR2(64) PRIMARY KEY,
-        config_value VARCHAR2(4000) NOT NULL,
-        updated_at   TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL
-      )]';
-  END IF;
-END;
-/
-
-MERGE INTO sg_qa_vector_config c
-USING (
-  SELECT 'CREDENTIAL_NAME' AS config_key, 'SGMP_POC_QA_VECTOR_CRED' AS config_value FROM dual
-  UNION ALL SELECT 'ENDPOINT_URL', 'https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/20231130/actions/embedText' FROM dual
-  UNION ALL SELECT 'MODEL_NAME', 'cohere.embed-v4.0' FROM dual
-  UNION ALL SELECT 'DIMENSION', '1536' FROM dual
-) s
-ON (c.config_key = s.config_key)
-WHEN MATCHED THEN UPDATE SET c.config_value = s.config_value, c.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (config_key, config_value) VALUES (s.config_key, s.config_value);
-/
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*) INTO v_count
-    FROM user_tables
-   WHERE table_name = 'SG_QA_VECTOR_EXAMPLE';
-
-  IF v_count = 0 THEN
-    EXECUTE IMMEDIATE q'[
-      CREATE TABLE sg_qa_vector_example (
-        example_id       NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
-        question         CLOB NOT NULL,
-        answer_sql       CLOB NOT NULL,
-        answer_text      CLOB,
-        embedding_input  CLOB NOT NULL,
-        embedding        VECTOR(1536, FLOAT32) NOT NULL,
-        embedding_model  VARCHAR2(128) DEFAULT 'cohere.embed-v4.0' NOT NULL,
-        created_at       TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL,
-        updated_at       TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL
-      )]';
-  END IF;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_params(p_input_type IN VARCHAR2)
-  RETURN CLOB
-AUTHID DEFINER
-IS
-  v_credential VARCHAR2(4000);
-  v_endpoint   VARCHAR2(4000);
-  v_model      VARCHAR2(4000);
-BEGIN
-  SELECT MAX(CASE WHEN config_key = 'CREDENTIAL_NAME' THEN config_value END),
-         MAX(CASE WHEN config_key = 'ENDPOINT_URL' THEN config_value END),
-         MAX(CASE WHEN config_key = 'MODEL_NAME' THEN config_value END)
-    INTO v_credential, v_endpoint, v_model
-    FROM sg_qa_vector_config;
-
-  IF v_credential IS NULL OR v_endpoint IS NULL OR v_model IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20001, 'SG QA vector configuration is incomplete.');
-  END IF;
-
-  RETURN TO_CLOB('{"provider":"ocigenai","credential_name":"')
-      || v_credential
-      || '","url":"' || v_endpoint
-      || '","model":"' || v_model
-      || '","truncate":"END"}';
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_store(
-  p_question   IN CLOB,
-  p_answer_sql IN CLOB,
-  p_answer     IN CLOB DEFAULT NULL
-) RETURN NUMBER
-AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_input      CLOB;
-  v_embedding  VECTOR;
-  v_example_id NUMBER;
-BEGIN
-  IF p_question IS NULL OR p_answer_sql IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20002, 'question and answer_sql are required.');
-  END IF;
-
-  v_input := TO_CLOB('Question: ') || p_question
-          || TO_CLOB(CHR(10) || 'Answer SQL: ') || p_answer_sql
-          || CASE WHEN p_answer IS NULL THEN NULL ELSE TO_CLOB(CHR(10) || 'Answer: ') || p_answer END;
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  INSERT INTO sg_qa_vector_example (
-    question, answer_sql, answer_text, embedding_input, embedding, embedding_model
-  ) VALUES (
-    p_question, p_answer_sql, p_answer, v_input, v_embedding, 'cohere.embed-v4.0'
-  ) RETURNING example_id INTO v_example_id;
-
-  COMMIT;
-  RETURN v_example_id;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question IN CLOB,
-  p_top_k    IN PLS_INTEGER DEFAULT 3
-) RETURN SYS_REFCURSOR
-AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results      SYS_REFCURSOR;
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id,
-           question,
-           answer_sql,
-           answer_text,
-           embedding_model,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     ORDER BY vector_distance(embedding, v_query_vector, COSINE), example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_context(
-  p_question IN CLOB,
-  p_top_k    IN PLS_INTEGER DEFAULT 3
-) RETURN CLOB
-AUTHID DEFINER
-IS
-  v_results SYS_REFCURSOR;
-  v_id      NUMBER;
-  v_q       CLOB;
-  v_sql     CLOB;
-  v_answer  CLOB;
-  v_model   VARCHAR2(128);
-  v_dist    NUMBER;
-  v_context CLOB := EMPTY_CLOB();
-BEGIN
-  v_results := sg_qa_vector_search(p_question, p_top_k);
-  LOOP
-    FETCH v_results INTO v_id, v_q, v_sql, v_answer, v_model, v_dist;
-    EXIT WHEN v_results%NOTFOUND;
-    v_context := v_context
-      || CASE WHEN DBMS_LOB.GETLENGTH(v_context) = 0 THEN NULL ELSE CHR(10) || CHR(10) END
-      || '[Example ' || v_id || ', cosine_distance=' || TO_CHAR(v_dist, 'FM0D000000') || ']' || CHR(10)
-      || 'Question: ' || v_q || CHR(10)
-      || 'Answer SQL: ' || v_sql
-      || CASE WHEN v_answer IS NULL THEN NULL ELSE CHR(10) || 'Answer: ' || v_answer END;
-  END LOOP;
-  CLOSE v_results;
-  RETURN v_context;
-END;
-/
-
-COMMENT ON TABLE sg_qa_vector_example IS
-  'Question-to-SQL QA examples embedded with OCI GenAI Cohere Embed 4 for retrieval-augmented prompt context.';
-
-COMMENT ON COLUMN sg_qa_vector_example.embedding IS
-  '1536-dimensional Cohere Embed 4 document embedding; generated through the dedicated SGMP vector API credential.';

database/adb/76_hmm_rds_pg_03_dblink.sql

@@ -1,24 +0,0 @@
--- ============================================================
--- Step 3: create an Oracle-managed PostgreSQL Database Link.
--- Based on FY26 internal training, section 3.2.3.
--- Run as ADMIN.
--- Redmine: #730
--- ============================================================
-
-BEGIN
-  DBMS_CLOUD_ADMIN.CREATE_DATABASE_LINK(
-    db_link_name       => 'HMM_RDS_PG_LINK',
-    hostname           => 'database-1.czaaygccsncp.ap-northeast-2.rds.amazonaws.com',
-    port               => 5432,
-    service_name       => 'postgres',
-    credential_name    => 'HMM_RDS_PG_CRED',
-    ssl_server_cert_dn => NULL,
-    private_target     => FALSE,
-    gateway_params     => JSON_OBJECT('db_type' VALUE 'postgres')
-  );
-END;
-/
-
-SELECT db_link, username, host, created
-FROM user_db_links
-WHERE db_link = 'HMM_RDS_PG_LINK';

database/adb/76_sgmp_annotation_api.sql

@@ -1,148 +0,0 @@
--- SGMP PoC: validated table/view and column annotation API
--- Issue: #734
-
-CREATE OR REPLACE FUNCTION sgmp_set_annotation(
-    p_schema_name    IN VARCHAR2,
-    p_target_kind    IN VARCHAR2,
-    p_object_name    IN VARCHAR2,
-    p_column_name    IN VARCHAR2 DEFAULT NULL,
-    p_change_text    IN VARCHAR2 DEFAULT NULL,
-    p_annotation_name IN VARCHAR2 DEFAULT 'AI_GUIDANCE'
-) RETURN VARCHAR2
-AUTHID DEFINER
-IS
-    l_schema_name     VARCHAR2(128);
-    l_object_name     VARCHAR2(128);
-    l_column_name     VARCHAR2(128);
-    l_annotation_name VARCHAR2(128);
-    l_target_kind     VARCHAR2(20);
-    l_object_type     VARCHAR2(30);
-    l_exists          PLS_INTEGER := 0;
-    l_action          VARCHAR2(20);
-    l_sql             VARCHAR2(32767);
-
-    FUNCTION simple_name(p_value VARCHAR2, p_label VARCHAR2) RETURN VARCHAR2 IS
-        l_value VARCHAR2(128) := UPPER(TRIM(p_value));
-    BEGIN
-        IF l_value IS NULL OR NOT REGEXP_LIKE(l_value, '^[A-Z][A-Z0-9_$#]{0,127}$') THEN
-            RAISE_APPLICATION_ERROR(-20001, p_label || ' has an invalid format.');
-        END IF;
-        RETURN l_value;
-    END;
-
-    FUNCTION qname(p_value VARCHAR2) RETURN VARCHAR2 IS
-    BEGIN
-        RETURN DBMS_ASSERT.ENQUOTE_NAME(p_value, FALSE);
-    END;
-
-    FUNCTION literal(p_value VARCHAR2) RETURN VARCHAR2 IS
-    BEGIN
-        RETURN DBMS_ASSERT.ENQUOTE_LITERAL(p_value);
-    END;
-BEGIN
-    l_schema_name := simple_name(p_schema_name, 'schema_name');
-    l_object_name := simple_name(p_object_name, 'object_name');
-    l_target_kind := UPPER(TRIM(p_target_kind));
-    IF l_target_kind NOT IN ('TABLE', 'COLUMN') THEN
-        RAISE_APPLICATION_ERROR(-20002, 'target_kind must be TABLE or COLUMN.');
-    END IF;
-    l_annotation_name := simple_name(p_annotation_name, 'annotation_name');
-    IF p_change_text IS NULL OR LENGTH(p_change_text) = 0 THEN
-        RAISE_APPLICATION_ERROR(-20003, 'change_text must not be empty.');
-    END IF;
-    IF LENGTH(p_change_text) > 4000 THEN
-        RAISE_APPLICATION_ERROR(-20004, 'change_text must be 4000 characters or less.');
-    END IF;
-
-    BEGIN
-        SELECT object_type
-          INTO l_object_type
-          FROM all_objects
-         WHERE owner = l_schema_name
-           AND object_name = l_object_name
-           AND object_type IN ('TABLE', 'VIEW')
-           AND ROWNUM = 1;
-    EXCEPTION
-        WHEN NO_DATA_FOUND THEN
-            RAISE_APPLICATION_ERROR(-20005, 'TABLE or VIEW object was not found.');
-    END;
-
-    IF l_target_kind = 'COLUMN' THEN
-        IF p_column_name IS NULL THEN
-            RAISE_APPLICATION_ERROR(-20006, 'column_name is required for COLUMN target.');
-        END IF;
-        IF l_object_type = 'VIEW' THEN
-            RAISE_APPLICATION_ERROR(-20007, 'VIEW column annotations cannot be altered by Oracle.');
-        END IF;
-        l_column_name := simple_name(p_column_name, 'column_name');
-        BEGIN
-            SELECT 1 INTO l_exists
-              FROM all_tab_columns
-             WHERE owner = l_schema_name
-               AND table_name = l_object_name
-               AND column_name = l_column_name
-               AND ROWNUM = 1;
-        EXCEPTION
-            WHEN NO_DATA_FOUND THEN
-                RAISE_APPLICATION_ERROR(-20008, 'column_name does not exist on the table.');
-        END;
-    ELSIF p_column_name IS NOT NULL THEN
-        RAISE_APPLICATION_ERROR(-20009, 'column_name is not allowed for TABLE target.');
-    END IF;
-
-    SELECT COUNT(*)
-      INTO l_exists
-      FROM all_annotations_usage
-     WHERE annotation_owner = l_schema_name
-       AND object_name = l_object_name
-       AND object_type = l_object_type
-       AND annotation_name = l_annotation_name
-       AND (l_target_kind = 'TABLE' AND column_name IS NULL
-            OR l_target_kind = 'COLUMN' AND column_name = l_column_name);
-
-    IF l_exists > 0 THEN
-        IF l_target_kind = 'COLUMN' THEN
-            l_sql := 'ALTER TABLE ' || qname(l_schema_name) || '.' || qname(l_object_name)
-                  || ' MODIFY ' || qname(l_column_name) || ' ANNOTATIONS (DROP '
-                  || qname(l_annotation_name) || ')';
-        ELSIF l_object_type = 'VIEW' THEN
-            l_sql := 'ALTER VIEW ' || qname(l_schema_name) || '.' || qname(l_object_name)
-                  || ' ANNOTATIONS (DROP ' || qname(l_annotation_name) || ')';
-        ELSE
-            l_sql := 'ALTER TABLE ' || qname(l_schema_name) || '.' || qname(l_object_name)
-                  || ' ANNOTATIONS (DROP ' || qname(l_annotation_name) || ')';
-        END IF;
-        EXECUTE IMMEDIATE l_sql;
-        l_action := 'REPLACED';
-    ELSE
-        l_action := 'ADDED';
-    END IF;
-
-    IF l_target_kind = 'COLUMN' THEN
-        l_sql := 'ALTER TABLE ' || qname(l_schema_name) || '.' || qname(l_object_name)
-              || ' MODIFY ' || qname(l_column_name) || ' ANNOTATIONS (ADD '
-              || qname(l_annotation_name) || ' ' || literal(p_change_text) || ')';
-    ELSIF l_object_type = 'VIEW' THEN
-        l_sql := 'ALTER VIEW ' || qname(l_schema_name) || '.' || qname(l_object_name)
-              || ' ANNOTATIONS (ADD ' || qname(l_annotation_name) || ' '
-              || literal(p_change_text) || ')';
-    ELSE
-        l_sql := 'ALTER TABLE ' || qname(l_schema_name) || '.' || qname(l_object_name)
-              || ' ANNOTATIONS (ADD ' || qname(l_annotation_name) || ' '
-              || literal(p_change_text) || ')';
-    END IF;
-    EXECUTE IMMEDIATE l_sql;
-
-    RETURN l_action || ': ' || l_schema_name || '.' || l_object_name
-        || CASE WHEN l_column_name IS NULL THEN '' ELSE '.' || l_column_name END
-        || ' [' || l_annotation_name || ']';
-EXCEPTION
-    WHEN OTHERS THEN
-        IF SQLCODE BETWEEN -20099 AND -20000 THEN
-            RAISE;
-        END IF;
-        RAISE_APPLICATION_ERROR(-20099, 'annotation change failed: ' || SQLERRM);
-END;
-/
-
-SHOW ERRORS FUNCTION sgmp_set_annotation;

database/adb/77_hmm_rds_pg_04_remote_query.sql

@@ -1,34 +0,0 @@
--- ============================================================
--- Step 4: query PostgreSQL directly through the Database Link.
--- PostgreSQL schema, table, view, and column identifiers are
--- lower-case and must be double quoted.
--- Redmine: #730
--- ============================================================
-
-SELECT COUNT(*) AS carrier_count
-FROM "hmm_demo"."carriers"@HMM_RDS_PG_LINK;
-
-SELECT
-  COUNT(*) AS performance_count,
-  MIN("performance_month") AS first_month,
-  MAX("performance_month") AS latest_month
-FROM "hmm_demo"."carrier_monthly_performance"@HMM_RDS_PG_LINK;
-
-SELECT
-  "carrier_code",
-  "carrier_name",
-  "service_region",
-  "performance_tier"
-FROM "hmm_demo"."carriers"@HMM_RDS_PG_LINK
-ORDER BY "carrier_code";
-
-SELECT
-  "carrier_code",
-  "carrier_name",
-  "performance_month",
-  "shipped_teu",
-  "revenue_usd",
-  "schedule_reliability_pct",
-  "risk_level"
-FROM "hmm_demo"."carrier_performance_latest_v"@HMM_RDS_PG_LINK
-ORDER BY "carrier_code";

database/adb/77_sgmp_game_scope_resolver.sql

@@ -1,175 +0,0 @@
--- DB-backed game query scope contract for MCP orchestration.
---
--- This script deliberately keeps game facts in database rows, not in application
--- code or Select AI instructions.  The view combines the active game alias source
--- with an operator-maintained registry for known games that currently have no
--- approved query object.  A zero-row business result is still queryable; only the
--- absence of an approved object makes a game scope unavailable.
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*) INTO v_count
-    FROM user_tables
-   WHERE table_name = 'SG_GAME_SCOPE_REGISTRY';
-
-  IF v_count = 0 THEN
-    EXECUTE IMMEDIATE q'[
-      CREATE TABLE sg_game_scope_registry (
-        game_key       VARCHAR2(128) NOT NULL,
-        display_name   VARCHAR2(200) NOT NULL,
-        game_alias     VARCHAR2(200) NOT NULL,
-        game_prefix    VARCHAR2(30),
-        active_yn      VARCHAR2(1) DEFAULT 'Y' NOT NULL,
-        alias_priority NUMBER(10) DEFAULT 100 NOT NULL,
-        source_type    VARCHAR2(30) DEFAULT 'OPERATOR' NOT NULL,
-        work_dtm       TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL,
-        CONSTRAINT sg_game_scope_registry_pk PRIMARY KEY (game_key, game_alias),
-        CONSTRAINT sg_game_scope_registry_active_ck CHECK (active_yn IN ('Y', 'N'))
-      )]';
-  END IF;
-END;
-/
-
--- Seed only database facts needed to recognise currently unavailable games in
--- the customer QA catalogue.  Customer game-master synchronization can replace
--- these rows without an application deployment.
-MERGE INTO sg_game_scope_registry t
-USING (
-  SELECT 'LORDNINE' AS game_key,
-         utl_i18n.raw_to_char(
-           utl_encode.base64_decode(utl_raw.cast_to_raw('66Gc65Oc64KY7J24')),
-           'AL32UTF8'
-         ) AS display_name,
-         utl_i18n.raw_to_char(
-           utl_encode.base64_decode(utl_raw.cast_to_raw('66Gc65Oc64KY7J24')),
-           'AL32UTF8'
-         ) AS game_alias,
-         CAST(NULL AS VARCHAR2(30)) AS game_prefix,
-         100 AS alias_priority
-    FROM dual
-  UNION ALL
-  SELECT 'BUBBLYZ', 'Bubblyz', 'Bubblyz', CAST(NULL AS VARCHAR2(30)), 100 FROM dual
-) s
-ON (t.game_key = s.game_key AND t.game_alias = s.game_alias)
-WHEN MATCHED THEN UPDATE SET
-  t.display_name = s.display_name,
-  t.game_prefix = s.game_prefix,
-  t.active_yn = 'Y',
-  t.alias_priority = s.alias_priority,
-  t.source_type = 'OPERATOR',
-  t.work_dtm = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  game_key, display_name, game_alias, game_prefix, active_yn, alias_priority, source_type
-) VALUES (
-  s.game_key, s.display_name, s.game_alias, s.game_prefix, 'Y', s.alias_priority, 'OPERATOR'
-);
-/
-
-CREATE OR REPLACE VIEW sg_game_query_scope_v AS
-WITH existing_query_objects AS (
-  -- USER_OBJECTS is the authoritative current-schema inventory.  The profile
-  -- object list alone is not enough because a stale entry must not make a game
-  -- executable after its table or view has been removed or invalidated.
-  SELECT object_name
-    FROM user_objects
-   WHERE object_type IN ('TABLE', 'VIEW')
-     AND status = 'VALID'
-),
-profile_names AS (
-  SELECT DISTINCT profile_name
-    FROM user_cloud_ai_profile_attributes
-   WHERE attribute_name = 'object_list'
-),
-profile_objects AS (
-  SELECT DISTINCT p.profile_name, o.object_name
-    FROM user_cloud_ai_profile_attributes p,
-         JSON_TABLE(
-           p.attribute_value,
-           '$[*]' COLUMNS (object_name VARCHAR2(128) PATH '$.name')
-         ) o
-    INNER JOIN existing_query_objects e
-      ON e.object_name = o.object_name
-   WHERE p.attribute_name = 'object_list'
-),
-source_alias AS (
-  SELECT game_id AS game_key,
-         game_nm AS display_name,
-         game_alias_nm AS game_alias,
-         game_prefix,
-         use_yn AS active_yn,
-         NVL(sort_order, 100) AS alias_priority,
-         'GAME_ALIAS' AS source_type
-    FROM comn_game_alias_bas
-),
-all_alias AS (
-  SELECT game_key, display_name, game_alias, game_prefix, active_yn, alias_priority, source_type
-    FROM source_alias
-  UNION ALL
-  SELECT r.game_key, r.display_name, r.game_alias, r.game_prefix,
-         r.active_yn, r.alias_priority, r.source_type
-    FROM sg_game_scope_registry r
-   WHERE NOT EXISTS (
-     SELECT 1
-       FROM source_alias a
-      WHERE a.game_key = r.game_key
-        AND a.game_alias = r.game_alias
-   )
-),
-scope_object AS (
-  SELECT n.profile_name,
-         a.game_key,
-         a.game_alias,
-         COUNT(p.object_name) AS approved_object_count
-    FROM profile_names n
-    CROSS JOIN all_alias a
-    LEFT JOIN profile_objects p
-     ON p.profile_name = n.profile_name
-     AND a.game_prefix IS NOT NULL
-     AND SUBSTR(p.object_name, 1, LENGTH(a.game_prefix) + 1) = a.game_prefix || '_'
-   GROUP BY n.profile_name, a.game_key, a.game_alias
-)
-SELECT o.profile_name,
-       a.game_key,
-       a.display_name,
-       a.game_alias,
-       a.game_prefix,
-       a.active_yn,
-       NVL(o.approved_object_count, 0) AS approved_object_count,
-       CASE
-         WHEN a.active_yn <> 'Y' THEN 'N'
-         WHEN NVL(o.approved_object_count, 0) > 0 THEN 'Y'
-         ELSE 'N'
-       END AS query_allowed_yn,
-       CASE
-         WHEN a.active_yn <> 'Y' THEN 'GAME_INACTIVE'
-         WHEN NVL(o.approved_object_count, 0) > 0 THEN 'APPROVED_OBJECT_AVAILABLE'
-         ELSE 'OBJECT_LIST_NOT_AVAILABLE'
-       END AS reason_code,
-       a.alias_priority,
-       a.source_type,
-       TO_CHAR(MAX(a.alias_priority) OVER (PARTITION BY a.game_key), 'FM999999990') AS scope_version
-  FROM all_alias a
-  LEFT JOIN scope_object o
-    ON o.game_key = a.game_key
-   AND o.game_alias = a.game_alias;
-/
-
-COMMENT ON TABLE sg_game_scope_registry IS
-  'Operator-managed game aliases retained for scope resolution when a game has no approved query object.';
-COMMENT ON COLUMN sg_game_scope_registry.game_key IS
-  'Stable game identifier used only by the DB-backed scope contract.';
-COMMENT ON COLUMN sg_game_scope_registry.game_alias IS
-  'Question text alias matched by the resolver before any SQL worker is called.';
-COMMENT ON COLUMN sg_game_scope_registry.game_prefix IS
-  'Optional data-object prefix. The scope view derives approved object availability from it.';
-COMMENT ON COLUMN sg_game_scope_registry.active_yn IS
-  'Whether the game is eligible for scope resolution; inactive games are never executable.';
-COMMENT ON COLUMN sg_game_scope_registry.alias_priority IS
-  'Database-defined ordering used to resolve overlapping aliases without application constants.';
-COMMENT ON COLUMN sg_game_query_scope_v.profile_name IS
-  'Select AI profile whose current approved object list was used for this scope decision.';
-COMMENT ON COLUMN sg_game_query_scope_v.query_allowed_yn IS
-  'Y only when the active game has at least one current Select AI approved and valid prefix-specific table or view.';
-COMMENT ON COLUMN sg_game_query_scope_v.reason_code IS
-  'Database-derived explanation for scope availability returned to the MCP agent.';

database/adb/78_hmm_rds_pg_05_views.sql

@@ -1,109 +0,0 @@
--- ============================================================
--- Step 5: create local Oracle Views and Select AI metadata.
--- Explicit aliases normalize PostgreSQL lower-case identifiers
--- into ordinary Oracle identifiers.
--- Redmine: #730
--- ============================================================
-
-CREATE OR REPLACE VIEW HMM_RDS_CARRIERS_V AS
-SELECT
-  "carrier_code"      AS carrier_code,
-  "carrier_name"      AS carrier_name,
-  "country_code"      AS country_code,
-  "alliance_name"     AS alliance_name,
-  "service_region"    AS service_region,
-  "performance_tier" AS performance_tier
-FROM "hmm_demo"."carriers"@HMM_RDS_PG_LINK;
-
-COMMENT ON TABLE HMM_RDS_CARRIERS_V IS
-  'HMM federation demo fictional carrier master. Primary Key: CARRIER_CODE. Referenced by HMM_RDS_CARRIER_PERF_V(CARRIER_CODE).';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.CARRIER_CODE IS
-  'Primary Key. Fictional carrier identifier such as C001.';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.CARRIER_NAME IS
-  'Fictional carrier display name; not an actual carrier.';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.COUNTRY_CODE IS
-  'Two-letter demo country code.';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.ALLIANCE_NAME IS
-  'Fictional carrier cooperation network.';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.SERVICE_REGION IS
-  'Primary service region for the demo carrier.';
-COMMENT ON COLUMN HMM_RDS_CARRIERS_V.PERFORMANCE_TIER IS
-  'Demo portfolio tier: CORE, GROWTH, or WATCH.';
-
-CREATE OR REPLACE VIEW HMM_RDS_CARRIER_PERF_V AS
-SELECT
-  "carrier_code"             AS carrier_code,
-  "performance_month"        AS performance_month,
-  "contracted_teu"           AS contracted_teu,
-  "shipped_teu"              AS shipped_teu,
-  "revenue_usd"              AS revenue_usd,
-  "gross_margin_usd"         AS gross_margin_usd,
-  "schedule_reliability_pct" AS schedule_reliability_pct,
-  "vessel_utilization_pct"   AS vessel_utilization_pct,
-  "claim_rate_pct"           AS claim_rate_pct,
-  "yoy_growth_pct"           AS yoy_growth_pct,
-  "risk_level"               AS risk_level
-FROM "hmm_demo"."carrier_monthly_performance"@HMM_RDS_PG_LINK;
-
-COMMENT ON TABLE HMM_RDS_CARRIER_PERF_V IS
-  'HMM federation demo monthly carrier KPI. Composite Primary Key: CARRIER_CODE and PERFORMANCE_MONTH. Foreign Key: CARRIER_CODE references HMM_RDS_CARRIERS_V(CARRIER_CODE). All values are fictional.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.CARRIER_CODE IS
-  'Foreign Key referencing HMM_RDS_CARRIERS_V(CARRIER_CODE).';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.PERFORMANCE_MONTH IS
-  'First calendar day of the KPI month; part of the composite Primary Key.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.CONTRACTED_TEU IS
-  'Contracted container volume in TEU.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.SHIPPED_TEU IS
-  'Actually shipped container volume in TEU.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.REVENUE_USD IS
-  'Fictional monthly revenue in USD.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.GROSS_MARGIN_USD IS
-  'Fictional monthly gross margin in USD; negative values indicate a loss.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.SCHEDULE_RELIABILITY_PCT IS
-  'Schedule reliability percentage from 0 through 100.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.VESSEL_UTILIZATION_PCT IS
-  'Vessel capacity utilization percentage from 0 through 100.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.CLAIM_RATE_PCT IS
-  'Cargo claim rate percentage from 0 through 100.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.YOY_GROWTH_PCT IS
-  'Year-over-year performance growth percentage.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_PERF_V.RISK_LEVEL IS
-  'Derived demo risk category: GREEN, AMBER, or RED.';
-
-CREATE OR REPLACE VIEW HMM_RDS_CARRIER_LATEST_V AS
-SELECT
-  "carrier_code"             AS carrier_code,
-  "carrier_name"             AS carrier_name,
-  "country_code"             AS country_code,
-  "alliance_name"            AS alliance_name,
-  "service_region"           AS service_region,
-  "performance_tier"        AS performance_tier,
-  "performance_month"        AS performance_month,
-  "contracted_teu"           AS contracted_teu,
-  "shipped_teu"              AS shipped_teu,
-  "revenue_usd"              AS revenue_usd,
-  "gross_margin_usd"         AS gross_margin_usd,
-  "schedule_reliability_pct" AS schedule_reliability_pct,
-  "vessel_utilization_pct"   AS vessel_utilization_pct,
-  "claim_rate_pct"           AS claim_rate_pct,
-  "yoy_growth_pct"           AS yoy_growth_pct,
-  "risk_level"               AS risk_level
-FROM "hmm_demo"."carrier_performance_latest_v"@HMM_RDS_PG_LINK;
-
-COMMENT ON TABLE HMM_RDS_CARRIER_LATEST_V IS
-  'Latest fictional monthly KPI for each HMM federation demo carrier. Primary Key: CARRIER_CODE.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_LATEST_V.CARRIER_CODE IS
-  'Primary Key for the latest carrier KPI row.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_LATEST_V.PERFORMANCE_MONTH IS
-  'Latest KPI month available in the PostgreSQL source.';
-COMMENT ON COLUMN HMM_RDS_CARRIER_LATEST_V.RISK_LEVEL IS
-  'Latest derived risk category: GREEN, AMBER, or RED.';
-
-SELECT object_name, object_type, status
-FROM user_objects
-WHERE object_name IN (
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-)
-ORDER BY object_name;

database/adb/78_sgmp_game_alias_logical_joins.sql

@@ -1,36 +0,0 @@
--- Logical game-alias join guidance for Select AI.
---
--- COMN_GAME_ALIAS_BAS intentionally has multiple alias rows per GAME_ID, so
--- GAME_ID cannot be modelled as a physical foreign key to that table.  These
--- annotations describe the safe semantic relationship without asserting a
--- false database constraint or creating fan-out aggregation errors.
-
-DECLARE v_result VARCHAR2(4000); BEGIN
-  v_result := sgmp_set_annotation(
-    'SGMP_POC', 'TABLE', 'COMN_SALES_TXN', NULL,
-    'Logical game filter: COMN_SALES_TXN.GAME_ID is resolved through COMN_GAME_ALIAS_BAS. GAME_ID is not unique in the alias table because one game can have multiple aliases. For a game-name filter, use EXISTS against active aliases or join a DISTINCT GAME_ID alias subquery. Do not directly join all alias rows before SUM or COUNT because that can multiply fact rows.',
-    'GAME_ALIAS_JOIN'
-  );
-  dbms_output.put_line(v_result);
-END;
-/
-
-DECLARE v_result VARCHAR2(4000); BEGIN
-  v_result := sgmp_set_annotation(
-    'SGMP_POC', 'TABLE', 'COMN_REFUND_TXN', NULL,
-    'Logical game filter: COMN_REFUND_TXN.GAME_ID is resolved through COMN_GAME_ALIAS_BAS. GAME_ID is not unique in the alias table because one game can have multiple aliases. For a game-name filter, use EXISTS against active aliases or join a DISTINCT GAME_ID alias subquery. Do not directly join all alias rows before SUM or COUNT because that can multiply fact rows.',
-    'GAME_ALIAS_JOIN'
-  );
-  dbms_output.put_line(v_result);
-END;
-/
-
-DECLARE v_result VARCHAR2(4000); BEGIN
-  v_result := sgmp_set_annotation(
-    'SGMP_POC', 'TABLE', 'COMN_SALES_PRODUCT_DISP_BAS', NULL,
-    'Logical product scope: COMN_SALES_PRODUCT_DISP_BAS is keyed by GAME_ID and PRODUCT_ID. Resolve a natural-language game through COMN_GAME_ALIAS_BAS using EXISTS or a DISTINCT GAME_ID alias subquery before joining product data to transaction facts. The alias table has multiple aliases per GAME_ID and is not a physical foreign-key parent.',
-    'GAME_ALIAS_JOIN'
-  );
-  dbms_output.put_line(v_result);
-END;
-/

database/adb/79_hmm_rds_pg_06_verify.sql

@@ -1,86 +0,0 @@
--- ============================================================
--- Step 6: verify the local federation Views.
--- Expected: carrier/performance/latest = 8/144/8.
--- Redmine: #730
--- ============================================================
-
-DECLARE
-  v_carrier_count     PLS_INTEGER;
-  v_performance_count PLS_INTEGER;
-  v_latest_count      PLS_INTEGER;
-  v_risk_count        PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*) INTO v_carrier_count
-  FROM HMM_RDS_CARRIERS_V;
-
-  SELECT COUNT(*) INTO v_performance_count
-  FROM HMM_RDS_CARRIER_PERF_V;
-
-  SELECT COUNT(*), COUNT(DISTINCT risk_level)
-  INTO v_latest_count, v_risk_count
-  FROM HMM_RDS_CARRIER_LATEST_V;
-
-  IF v_carrier_count != 8 THEN
-    RAISE_APPLICATION_ERROR(
-      -20001,
-      'Expected 8 carriers, found ' || v_carrier_count
-    );
-  END IF;
-
-  IF v_performance_count != 144 THEN
-    RAISE_APPLICATION_ERROR(
-      -20002,
-      'Expected 144 performance rows, found ' || v_performance_count
-    );
-  END IF;
-
-  IF v_latest_count != 8 OR v_risk_count != 3 THEN
-    RAISE_APPLICATION_ERROR(
-      -20003,
-      'Expected 8 latest rows and 3 risk levels, found '
-      || v_latest_count || ' rows and ' || v_risk_count || ' levels'
-    );
-  END IF;
-END;
-/
-
-SELECT
-  (SELECT COUNT(*) FROM HMM_RDS_CARRIERS_V) AS carrier_count,
-  (SELECT COUNT(*) FROM HMM_RDS_CARRIER_PERF_V) AS performance_count,
-  (SELECT COUNT(*) FROM HMM_RDS_CARRIER_LATEST_V) AS latest_count
-FROM dual;
-
-SELECT
-  MIN(performance_month) AS first_month,
-  MAX(performance_month) AS latest_month,
-  COUNT(DISTINCT carrier_code) AS carrier_count
-FROM HMM_RDS_CARRIER_PERF_V;
-
-SELECT risk_level, COUNT(*) AS carrier_count
-FROM HMM_RDS_CARRIER_LATEST_V
-GROUP BY risk_level
-ORDER BY risk_level;
-
-SELECT
-  carrier_code,
-  carrier_name,
-  performance_month,
-  shipped_teu,
-  revenue_usd,
-  gross_margin_usd,
-  schedule_reliability_pct,
-  claim_rate_pct,
-  risk_level
-FROM HMM_RDS_CARRIER_LATEST_V
-ORDER BY carrier_code;
-
-SELECT
-  table_name,
-  comments
-FROM user_tab_comments
-WHERE table_name IN (
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-)
-ORDER BY table_name;

database/adb/79_sg_game_catalog_vector.sql

@@ -1,179 +0,0 @@
--- Metadata-driven game catalog for deterministic scope resolution.
--- No customer game names or prefixes are embedded in this script.
-
-BEGIN
-  EXECUTE IMMEDIATE q'[
-    CREATE TABLE sg_game_catalog (
-      game_key                VARCHAR2(128) PRIMARY KEY,
-      game_id                 VARCHAR2(128) NOT NULL,
-      game_prefix             VARCHAR2(128),
-      game_nm                 VARCHAR2(512),
-      game_alias_nm           VARCHAR2(512),
-      user_master_object_name VARCHAR2(128),
-      search_text             CLOB NOT NULL,
-      embedding               VECTOR(1536, FLOAT32),
-      active_yn               CHAR(1) DEFAULT 'Y' NOT NULL,
-      priority                NUMBER DEFAULT 100 NOT NULL,
-      updated_at              TIMESTAMP(6) DEFAULT SYSTIMESTAMP NOT NULL
-    )]';
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -955 THEN RAISE; END IF;
-END;
-/
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*) INTO v_count
-    FROM user_tab_columns
-   WHERE table_name = 'SG_GAME_CATALOG'
-     AND column_name = 'USER_MASTER_OBJECT_NAME';
-  IF v_count = 0 THEN
-    EXECUTE IMMEDIATE
-      'ALTER TABLE sg_game_catalog ADD (user_master_object_name VARCHAR2(128))';
-  END IF;
-END;
-/
-
-MERGE INTO sg_game_catalog c
-USING (
-  SELECT
-    game_id AS game_key,
-    game_id,
-    MAX(game_prefix) AS game_prefix,
-    MAX(game_nm) AS game_nm,
-    LISTAGG(game_alias_nm, ' ') WITHIN GROUP (ORDER BY game_alias_nm) AS game_alias_nm,
-    game_id || ' ' || MAX(NVL(game_nm, '')) || ' '
-      || LISTAGG(NVL(game_alias_nm, ''), ' ') WITHIN GROUP (ORDER BY game_alias_nm)
-      || ' ' || MAX(NVL(game_prefix, '')) AS search_text
-  FROM comn_game_alias_bas
-  WHERE use_yn = 'Y'
-  GROUP BY game_id
-) s
-ON (c.game_key = s.game_key)
-WHEN MATCHED THEN UPDATE SET
-  c.game_id = s.game_id,
-  c.game_prefix = s.game_prefix,
-  c.game_nm = s.game_nm,
-  c.game_alias_nm = s.game_alias_nm,
-  c.search_text = s.search_text,
-  c.active_yn = 'Y',
-  c.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT
-  (game_key, game_id, game_prefix, game_nm, game_alias_nm, search_text)
-VALUES
-  (s.game_key, s.game_id, s.game_prefix, s.game_nm, s.game_alias_nm, s.search_text);
-/
-
--- Keep operator-maintained games in the same canonical catalog. These rows
--- remain observable even when their current approved physical object is null.
-MERGE INTO sg_game_catalog c
-USING (
-  SELECT
-    r.game_key,
-    r.game_key AS game_id,
-    MAX(r.game_prefix) AS game_prefix,
-    MAX(r.display_name) AS game_nm,
-    LISTAGG(r.game_alias, ' ') WITHIN GROUP (ORDER BY r.game_alias) AS game_alias_nm,
-    r.game_key || ' ' || MAX(NVL(r.display_name, '')) || ' '
-      || LISTAGG(NVL(r.game_alias, ''), ' ') WITHIN GROUP (ORDER BY r.game_alias)
-      || ' ' || MAX(NVL(r.game_prefix, '')) AS search_text
-  FROM sg_game_scope_registry r
-  WHERE r.active_yn = 'Y'
-    AND NOT EXISTS (
-      SELECT 1
-        FROM comn_game_alias_bas a
-       WHERE a.use_yn = 'Y'
-         AND a.game_id = r.game_key
-    )
-  GROUP BY r.game_key
-) s
-ON (c.game_key = s.game_key)
-WHEN MATCHED THEN UPDATE SET
-  c.game_id = s.game_id,
-  c.game_prefix = s.game_prefix,
-  c.game_nm = s.game_nm,
-  c.game_alias_nm = s.game_alias_nm,
-  c.search_text = s.search_text,
-  c.active_yn = 'Y',
-  c.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT
-  (game_key, game_id, game_prefix, game_nm, game_alias_nm, search_text)
-VALUES
-  (s.game_key, s.game_id, s.game_prefix, s.game_nm, s.game_alias_nm, s.search_text);
-/
-
--- Resolve the physical user-master object from current valid objects and the
--- current Select AI object lists. No game, prefix, or object name is embedded
--- in this policy.
-MERGE INTO sg_game_catalog c
-USING (
-  WITH approved_objects AS (
-    SELECT DISTINCT UPPER(j.object_name) AS object_name
-      FROM user_cloud_ai_profile_attributes p,
-           JSON_TABLE(
-             p.attribute_value,
-             '$[*]' COLUMNS (object_name VARCHAR2(128) PATH '$.name')
-           ) j
-      INNER JOIN user_objects o
-        ON o.object_name = UPPER(j.object_name)
-       AND o.object_type IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW')
-       AND o.status = 'VALID'
-     WHERE p.attribute_name = 'object_list'
-  )
-  SELECT c2.game_key,
-         MIN(a.object_name) AS user_master_object_name
-    FROM sg_game_catalog c2
-    LEFT JOIN approved_objects a
-      ON c2.game_prefix IS NOT NULL
-     AND a.object_name = UPPER(c2.game_prefix || '_COMN_USER_MST')
-   GROUP BY c2.game_key
-) s
-ON (c.game_key = s.game_key)
-WHEN MATCHED THEN UPDATE SET
-  c.user_master_object_name = s.user_master_object_name,
-  c.updated_at = SYSTIMESTAMP;
-/
-
--- The catalog is small. Recompute embeddings after synchronization so changed
--- aliases and registry-only games cannot retain a stale or null vector.
-UPDATE sg_game_catalog c
-   SET c.embedding = DBMS_VECTOR.UTL_TO_EMBEDDING(
-         c.search_text,
-         JSON(sg_qa_vector_params('search_document'))
-       ),
-       c.updated_at = SYSTIMESTAMP
- WHERE c.active_yn = 'Y';
-/
-
-COMMENT ON TABLE sg_game_catalog IS
-  'Customer-owned game catalog used to resolve query scope before NL2SQL.';
-COMMENT ON COLUMN sg_game_catalog.embedding IS
-  'Vector representation of game names and aliases, generated with the configured vector credential.';
-COMMENT ON COLUMN sg_game_catalog.user_master_object_name IS
-  'Current valid Select AI-approved physical user-master object for this game; null when unavailable.';
-/
-
-CREATE OR REPLACE FUNCTION sg_game_catalog_search(
-  p_question IN CLOB,
-  p_top_k IN PLS_INTEGER DEFAULT 5
-) RETURN SYS_REFCURSOR AUTHID DEFINER IS
-  v_query VECTOR;
-  v_result SYS_REFCURSOR;
-BEGIN
-  v_query := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-  OPEN v_result FOR
-    SELECT game_key, game_id, game_prefix, game_nm, game_alias_nm,
-           user_master_object_name,
-           VECTOR_DISTANCE(embedding, v_query, COSINE) AS cosine_distance
-      FROM sg_game_catalog
-     WHERE active_yn = 'Y' AND embedding IS NOT NULL
-     ORDER BY VECTOR_DISTANCE(embedding, v_query, COSINE), priority, game_key
-     FETCH FIRST LEAST(GREATEST(NVL(p_top_k, 5), 1), 20) ROWS ONLY;
-  RETURN v_result;
-END;
-/

database/adb/80_hmm_rds_pg_99_cleanup.sql

@@ -1,63 +0,0 @@
--- ============================================================
--- Optional pre-recording reset.
--- Drops only the three local Views, Database Link, and
--- Credential owned by this demo. Host ACL entries are retained.
--- Redmine: #730
--- ============================================================
-
-DECLARE
-  v_count PLS_INTEGER;
-BEGIN
-  FOR object_row IN (
-    SELECT object_name
-    FROM user_objects
-    WHERE object_type = 'VIEW'
-      AND object_name IN (
-        'HMM_RDS_CARRIERS_V',
-        'HMM_RDS_CARRIER_PERF_V',
-        'HMM_RDS_CARRIER_LATEST_V'
-      )
-    ORDER BY CASE object_name
-      WHEN 'HMM_RDS_CARRIER_LATEST_V' THEN 1
-      WHEN 'HMM_RDS_CARRIER_PERF_V' THEN 2
-      ELSE 3
-    END
-  ) LOOP
-    EXECUTE IMMEDIATE 'DROP VIEW ' || object_row.object_name;
-  END LOOP;
-
-  SELECT COUNT(*) INTO v_count
-  FROM user_db_links
-  WHERE db_link = 'HMM_RDS_PG_LINK';
-
-  IF v_count = 1 THEN
-    EXECUTE IMMEDIATE 'DROP DATABASE LINK HMM_RDS_PG_LINK';
-  END IF;
-
-  SELECT COUNT(*) INTO v_count
-  FROM all_credentials
-  WHERE credential_name = 'HMM_RDS_PG_CRED';
-
-  IF v_count = 1 THEN
-    DBMS_CLOUD.DROP_CREDENTIAL(
-      credential_name => 'HMM_RDS_PG_CRED'
-    );
-  END IF;
-END;
-/
-
-SELECT credential_name, username
-FROM all_credentials
-WHERE credential_name = 'HMM_RDS_PG_CRED';
-
-SELECT db_link, username, host
-FROM user_db_links
-WHERE db_link = 'HMM_RDS_PG_LINK';
-
-SELECT object_name, object_type
-FROM user_objects
-WHERE object_name IN (
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-);

database/adb/80_sg_game_mention_extract.sql

@@ -1,35 +0,0 @@
--- One short OCI Chat call extracts game-name mentions. Identity resolution is
--- performed later by catalog vector score, not by another LLM call.
-CREATE OR REPLACE FUNCTION sg_game_extract_mentions(p_question IN CLOB)
-  RETURN CLOB AUTHID DEFINER
-IS
-  v_prompt CLOB;
-  v_result CLOB;
-  v_extract JSON_OBJECT_T;
-BEGIN
-  v_prompt := 'Extract only game identity mentions from the user question. '
-    || 'A registered game title, alias, GAME_ID, GAME_PREFIX, or catalog key is a game mention and must be preserved exactly as written. '
-    || 'Metrics, acronyms, dates, filters, and database object or column names are not game mentions unless they are themselves an explicit registered game identity. '
-    || 'When a title-like noun directly qualifies a game data request such as user master, character, sales, AU, NRU, server, or game log, preserve that noun as a game-name mention even when it is not in a catalog. '
-    || 'Do not discard an unknown title merely because it cannot be resolved. General scope words such as common, overall, all, total, or every are not game-name mentions unless they are part of an explicit title. '
-    || 'Return exactly one JSON object with keys game_mentions (array of strings) '
-    || 'and scope_hint (GLOBAL, SINGLE_GAME, MULTI_GAME, ALL_GAMES, UNKNOWN). '
-    || 'Do not resolve one game identity to another and do not generate SQL. '
-    || 'Return raw JSON only: no prose, no Markdown, and no code fence. Question: '
-    || DBMS_LOB.SUBSTR(p_question, 4000, 1);
-
-  v_result := DBMS_CLOUD_AI.GENERATE(
-    prompt => v_prompt,
-    profile_name => 'SGMP_POC_OCI_COHERE_COMMAND',
-    action => 'chat'
-  );
-  v_extract := JSON_OBJECT_T.parse(v_result);
-  IF NOT v_extract.has('game_mentions') OR NOT v_extract.has('scope_hint') THEN
-    RAISE_APPLICATION_ERROR(
-      -20091,
-      'Game mention extraction must return game_mentions and scope_hint JSON keys.'
-    );
-  END IF;
-  RETURN v_result;
-END;
-/

database/adb/81_hmm_carrier_access_groups.sql

@@ -1,209 +0,0 @@
--- ============================================================
--- HMM carrier assignments using existing access-group tables.
---
--- Existing tables:
---   HMM_HR_EMPLOYEES
---   HMM_ACCESS_GROUPS
---   HMM_ACCESS_GROUP_MEMBERS
---
--- No new assignment table is created.
--- Korean values are reconstructed from UTF-8 base64 so SQLcl
--- cannot corrupt the literals.
--- Redmine: #730
--- ============================================================
-
-WHENEVER SQLERROR EXIT SQL.SQLCODE
-SET DEFINE OFF
-SET FEEDBACK ON
-SET SERVEROUTPUT ON
-
-MERGE INTO hmm_access_groups dst
-USING (
-  SELECT
-    base.max_group_id + carrier.seq_no AS group_id,
-    'CARRIER_' || carrier.carrier_code AS group_code,
-    carrier.carrier_code || ' ' ||
-      utl_i18n.raw_to_char(
-        utl_encode.base64_decode(
-          utl_raw.cast_to_raw('7ISg7IKsIOuLtOuLuSDqt7jro7k=')
-        ),
-        'AL32UTF8'
-      ) AS group_name,
-    utl_i18n.raw_to_char(
-      utl_encode.base64_decode(
-        utl_raw.cast_to_raw(
-          '642w66qo7JqpIOyEoOyCrCDsoJHqt7wg67CPIOuLtOuLueyekCDqt7jro7k='
-        )
-      ),
-      'AL32UTF8'
-    ) || ' (' || carrier.carrier_code || ')' AS description
-  FROM (
-    SELECT 1 seq_no, 'C001' carrier_code FROM dual
-    UNION ALL SELECT 2, 'C002' FROM dual
-    UNION ALL SELECT 3, 'C003' FROM dual
-    UNION ALL SELECT 4, 'C004' FROM dual
-    UNION ALL SELECT 5, 'C005' FROM dual
-    UNION ALL SELECT 6, 'C006' FROM dual
-    UNION ALL SELECT 7, 'C007' FROM dual
-    UNION ALL SELECT 8, 'C008' FROM dual
-  ) carrier
-  CROSS JOIN (
-    SELECT NVL(MAX(group_id), 0) max_group_id
-    FROM hmm_access_groups
-  ) base
-) src
-ON (dst.group_code = src.group_code)
-WHEN MATCHED THEN UPDATE SET
-  dst.group_name = src.group_name,
-  dst.description = src.description,
-  dst.active_yn = 'Y',
-  dst.updated_at = SYSTIMESTAMP
-WHEN NOT MATCHED THEN INSERT (
-  group_id,
-  group_code,
-  group_name,
-  description,
-  active_yn,
-  created_at,
-  updated_at
-) VALUES (
-  src.group_id,
-  src.group_code,
-  src.group_name,
-  src.description,
-  'Y',
-  SYSTIMESTAMP,
-  SYSTIMESTAMP
-);
-
-MERGE INTO hmm_access_group_members dst
-USING (
-  SELECT
-    access_group.group_id,
-    employee.employee_id
-  FROM (
-    SELECT 'E1002' employee_code, 'CARRIER_C001' group_code FROM dual
-    UNION ALL SELECT 'E1002', 'CARRIER_C002' FROM dual
-    UNION ALL SELECT 'E1003', 'CARRIER_C003' FROM dual
-    UNION ALL SELECT 'E1004', 'CARRIER_C004' FROM dual
-    UNION ALL SELECT 'E1005', 'CARRIER_C005' FROM dual
-    UNION ALL SELECT 'E1006', 'CARRIER_C006' FROM dual
-    UNION ALL SELECT 'E1006', 'CARRIER_C007' FROM dual
-    UNION ALL SELECT 'E1007', 'CARRIER_C008' FROM dual
-  ) assignment
-  JOIN hmm_hr_employees employee
-    ON employee.employee_code = assignment.employee_code
-   AND employee.employment_status = 'ACTIVE'
-  JOIN hmm_access_groups access_group
-    ON access_group.group_code = assignment.group_code
-   AND access_group.active_yn = 'Y'
-) src
-ON (
-  dst.group_id = src.group_id
-  AND dst.employee_id = src.employee_id
-)
-WHEN NOT MATCHED THEN INSERT (
-  group_id,
-  employee_id,
-  created_at
-) VALUES (
-  src.group_id,
-  src.employee_id,
-  SYSTIMESTAMP
-);
-
-CREATE OR REPLACE VIEW hmm_carrier_assignments_v AS
-SELECT
-  employee.employee_id,
-  employee.employee_code,
-  employee.full_name AS employee_name,
-  employee.job_title,
-  employee.team_id,
-  employee.manager_employee_id,
-  manager.employee_code AS manager_employee_code,
-  manager.full_name AS manager_name,
-  SUBSTR(access_group.group_code, LENGTH('CARRIER_') + 1) AS carrier_code,
-  access_group.group_code,
-  access_group.group_name
-FROM hmm_access_group_members membership
-JOIN hmm_access_groups access_group
-  ON access_group.group_id = membership.group_id
- AND access_group.active_yn = 'Y'
-JOIN hmm_hr_employees employee
-  ON employee.employee_id = membership.employee_id
- AND employee.employment_status = 'ACTIVE'
-LEFT JOIN hmm_hr_employees manager
-  ON manager.employee_id = employee.manager_employee_id
-WHERE access_group.group_code LIKE 'CARRIER_C%';
-
-COMMENT ON TABLE hmm_carrier_assignments_v IS
-  'ADB employee-to-carrier assignments from HMM_HR_EMPLOYEES, HMM_ACCESS_GROUPS, and HMM_ACCESS_GROUP_MEMBERS. Join relationship: HMM_CARRIER_ASSIGNMENTS_V.CARRIER_CODE joins HMM_RDS_CARRIERS_V.CARRIER_CODE, HMM_RDS_CARRIER_PERF_V.CARRIER_CODE, and HMM_RDS_CARRIER_LATEST_V.CARRIER_CODE.';
-COMMENT ON COLUMN hmm_carrier_assignments_v.EMPLOYEE_CODE IS
-  'HMM employee code sourced from HMM_HR_EMPLOYEES.EMPLOYEE_CODE. Example: E1002.';
-COMMENT ON COLUMN hmm_carrier_assignments_v.MANAGER_EMPLOYEE_CODE IS
-  'Direct manager employee code sourced from HMM_HR_EMPLOYEES. Use E1001 to identify the HMM demo manager team.';
-COMMENT ON COLUMN hmm_carrier_assignments_v.CARRIER_CODE IS
-  'Join Key and Foreign Key to HMM_RDS_CARRIERS_V(CARRIER_CODE), HMM_RDS_CARRIER_PERF_V(CARRIER_CODE), and HMM_RDS_CARRIER_LATEST_V(CARRIER_CODE).';
-COMMENT ON COLUMN hmm_carrier_assignments_v.GROUP_CODE IS
-  'Existing access-group code in the form CARRIER_C001.';
-
-COMMIT;
-
-DECLARE
-  v_group_count      PLS_INTEGER;
-  v_member_count     PLS_INTEGER;
-  v_assignment_count PLS_INTEGER;
-  v_federated_count  PLS_INTEGER;
-BEGIN
-  SELECT COUNT(*)
-  INTO v_group_count
-  FROM hmm_access_groups
-  WHERE group_code BETWEEN 'CARRIER_C001' AND 'CARRIER_C008'
-    AND active_yn = 'Y';
-
-  SELECT COUNT(*)
-  INTO v_member_count
-  FROM hmm_access_group_members membership
-  JOIN hmm_access_groups access_group
-    ON access_group.group_id = membership.group_id
-  WHERE access_group.group_code BETWEEN 'CARRIER_C001' AND 'CARRIER_C008';
-
-  SELECT COUNT(*)
-  INTO v_assignment_count
-  FROM hmm_carrier_assignments_v;
-
-  SELECT COUNT(*)
-  INTO v_federated_count
-  FROM hmm_carrier_assignments_v assignment
-  JOIN hmm_rds_carrier_latest_v performance
-    ON performance.carrier_code = assignment.carrier_code;
-
-  IF v_group_count != 8
-     OR v_member_count != 8
-     OR v_assignment_count != 8
-     OR v_federated_count != 8 THEN
-    RAISE_APPLICATION_ERROR(
-      -20081,
-      'Expected group/member/assignment/federated counts 8/8/8/8; found '
-      || v_group_count || '/'
-      || v_member_count || '/'
-      || v_assignment_count || '/'
-      || v_federated_count
-    );
-  END IF;
-END;
-/
-
-SELECT
-  assignment.employee_code,
-  assignment.employee_name,
-  assignment.manager_employee_code,
-  assignment.carrier_code,
-  performance.carrier_name,
-  performance.performance_month,
-  performance.revenue_usd,
-  performance.risk_level
-FROM hmm_carrier_assignments_v assignment
-JOIN hmm_rds_carrier_latest_v performance
-  ON performance.carrier_code = assignment.carrier_code
-ORDER BY assignment.employee_code, assignment.carrier_code;

database/adb/81_sg_game_query_plan.sql

@@ -1,485 +0,0 @@
--- Vector-score candidate selection. The closest catalog vector is accepted
--- only when it is within the customer-managed policy threshold.
-CREATE OR REPLACE FUNCTION sg_game_match_candidate(
-  p_mention IN CLOB,
-  p_candidates_json IN CLOB
-) RETURN CLOB AUTHID DEFINER
-IS
-  v_candidates JSON_ARRAY_T;
-  v_candidate JSON_OBJECT_T;
-  v_result JSON_OBJECT_T := JSON_OBJECT_T();
-  v_threshold NUMBER;
-  v_distance NUMBER;
-  v_game_key VARCHAR2(128);
-BEGIN
-  SELECT number_value
-    INTO v_threshold
-    FROM sg_game_scope_policy
-   WHERE policy_key = 'GAME_ALIAS_MAX_COSINE_DISTANCE'
-     AND active_yn = 'Y';
-
-  v_candidates := JSON_ARRAY_T.parse(p_candidates_json);
-  IF v_candidates.get_size = 0 THEN
-    v_result.put('status', 'UNMATCHED');
-    v_result.put_null('game_key');
-    v_result.put('reason', 'No active game catalog vector candidate was returned.');
-    RETURN v_result.to_clob;
-  END IF;
-
-  v_candidate := TREAT(v_candidates.get(0) AS JSON_OBJECT_T);
-  v_distance := v_candidate.get_number('cosineDistance');
-  v_game_key := v_candidate.get_string('gameKey');
-
-  IF v_distance <= v_threshold THEN
-    v_result.put('status', 'MATCHED');
-    v_result.put('game_key', v_game_key);
-    v_result.put(
-      'reason',
-      'Closest catalog vector distance '
-      || TO_CHAR(v_distance, 'FM0D000000')
-      || ' is within configured maximum '
-      || TO_CHAR(v_threshold, 'FM0D000000') || '.'
-    );
-  ELSE
-    v_result.put('status', 'UNMATCHED');
-    v_result.put_null('game_key');
-    v_result.put(
-      'reason',
-      'Closest catalog vector distance '
-      || TO_CHAR(v_distance, 'FM0D000000')
-      || ' exceeds configured maximum '
-      || TO_CHAR(v_threshold, 'FM0D000000') || '.'
-    );
-  END IF;
-  RETURN v_result.to_clob;
-END;
-/
-
--- A game can be known to the scope registry while not being an active alias
--- source for a common fact query. Keep that availability separate from a
--- role-specific physical-object availability such as a user-master table.
-CREATE OR REPLACE FUNCTION sg_game_fact_scope_status(
-  p_game_id IN VARCHAR2
-) RETURN VARCHAR2 AUTHID DEFINER IS
-  v_exists NUMBER;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM SGMP_POC.comn_game_alias_bas
-   WHERE use_yn = 'Y'
-     AND game_id = p_game_id;
-  RETURN CASE WHEN v_exists > 0 THEN 'ACTIVE_ALIAS' ELSE 'REGISTRY_ONLY' END;
-END;
-/
-
--- Complete game query planning inside ADB. The MCP server only invokes this
--- function and returns its structured result.
-CREATE OR REPLACE FUNCTION sg_game_query_plan(
-  p_question IN CLOB,
-  p_top_k IN PLS_INTEGER DEFAULT 5
-) RETURN CLOB AUTHID DEFINER
-IS
-  TYPE t_seen_game_keys IS TABLE OF BOOLEAN INDEX BY VARCHAR2(128);
-
-  v_extract_raw CLOB;
-  v_extract JSON_OBJECT_T;
-  v_mentions JSON_ARRAY_T;
-  v_scope_type VARCHAR2(30);
-  v_target_type VARCHAR2(20);
-  v_targets JSON_ARRAY_T := JSON_ARRAY_T();
-  v_supported JSON_ARRAY_T := JSON_ARRAY_T();
-  v_data_eligible JSON_ARRAY_T := JSON_ARRAY_T();
-  v_data_ineligible JSON_ARRAY_T := JSON_ARRAY_T();
-  v_unresolved JSON_ARRAY_T := JSON_ARRAY_T();
-  v_unmatched JSON_ARRAY_T := JSON_ARRAY_T();
-  v_mention_results JSON_ARRAY_T := JSON_ARRAY_T();
-  v_execution_tasks JSON_ARRAY_T := JSON_ARRAY_T();
-  v_seen_game_keys t_seen_game_keys;
-  v_result JSON_OBJECT_T := JSON_OBJECT_T();
-  v_reference_summary JSON_OBJECT_T := JSON_OBJECT_T();
-  v_select_ai_reference CLOB;
-  v_plan_status VARCHAR2(30);
-  v_matched_count PLS_INTEGER := 0;
-  v_data_eligible_count PLS_INTEGER := 0;
-  v_unmatched_count PLS_INTEGER := 0;
-
-  v_mention VARCHAR2(1000);
-  v_candidates JSON_ARRAY_T;
-  v_candidate JSON_OBJECT_T;
-  v_decision_raw CLOB;
-  v_decision JSON_OBJECT_T;
-  v_decision_status VARCHAR2(30);
-  v_selected_key VARCHAR2(128);
-  v_reason VARCHAR2(4000);
-  v_matched_candidate JSON_OBJECT_T;
-  v_mention_result JSON_OBJECT_T;
-  v_target JSON_OBJECT_T;
-  v_unmatched_item JSON_OBJECT_T;
-  v_execution_task JSON_OBJECT_T;
-  v_worker_arguments JSON_OBJECT_T;
-  v_fewshot_arguments JSON_OBJECT_T;
-  v_task_plan JSON_OBJECT_T;
-  v_task_reference JSON_OBJECT_T;
-  v_task_targets JSON_ARRAY_T;
-  v_excluded_mentions JSON_ARRAY_T;
-  v_task_question CLOB;
-
-  v_cursor SYS_REFCURSOR;
-  v_game_key VARCHAR2(128);
-  v_game_id VARCHAR2(128);
-  v_game_prefix VARCHAR2(128);
-  v_game_nm VARCHAR2(512);
-  v_game_alias_nm VARCHAR2(512);
-  v_user_master_object_name VARCHAR2(128);
-  v_fact_scope_status VARCHAR2(30);
-  v_cosine_distance NUMBER;
-BEGIN
-  v_extract_raw := sg_game_extract_mentions(p_question);
-  v_extract := JSON_OBJECT_T.parse(v_extract_raw);
-  v_mentions := v_extract.get_array('game_mentions');
-  v_scope_type := NVL(v_extract.get_string('scope_hint'), 'UNKNOWN');
-
-  IF v_scope_type = 'ALL_GAMES' THEN
-    v_target_type := 'ALL';
-  ELSIF v_mentions.get_size = 0 THEN
-    v_target_type := 'NONE';
-  ELSIF v_mentions.get_size = 1 THEN
-    v_target_type := 'SINGLE';
-  ELSE
-    v_target_type := 'MULTI';
-  END IF;
-
-  IF v_target_type = 'ALL' THEN
-    FOR game_row IN (
-      SELECT game_key, game_id, game_prefix, game_nm, game_alias_nm,
-             user_master_object_name
-        FROM SGMP_POC.sg_game_catalog
-       WHERE active_yn = 'Y'
-       ORDER BY priority, game_key
-    ) LOOP
-      v_target := JSON_OBJECT_T();
-      v_target.put_null('mention');
-      v_target.put('status', 'CATALOG');
-      v_target.put('matchStatus', 'MATCHED');
-      v_target.put('gameKey', game_row.game_key);
-      v_target.put('gameId', game_row.game_id);
-      v_target.put('gamePrefix', game_row.game_prefix);
-      v_target.put('gameName', game_row.game_nm);
-      v_target.put('aliases', game_row.game_alias_nm);
-      v_target.put(
-        'userMasterObjectName',
-        game_row.user_master_object_name
-      );
-      v_target.put(
-        'objectStatus',
-        CASE WHEN game_row.user_master_object_name IS NULL
-          THEN 'UNAVAILABLE' ELSE 'AVAILABLE' END
-      );
-      v_fact_scope_status := sg_game_fact_scope_status(game_row.game_id);
-      v_target.put('factScopeStatus', v_fact_scope_status);
-      v_target.put(
-        'dataStatus',
-        CASE WHEN v_fact_scope_status = 'ACTIVE_ALIAS'
-          THEN 'AVAILABLE' ELSE 'UNAVAILABLE' END
-      );
-      v_target.put_null('cosineDistance');
-      v_target.put('reasonCode', 'ALL_GAMES_CATALOG');
-      v_target.put('reason', 'Active game returned from the database catalog.');
-      v_targets.append(v_target);
-      v_matched_count := v_matched_count + 1;
-      IF game_row.user_master_object_name IS NOT NULL THEN
-        v_supported.append(v_target);
-      END IF;
-      IF v_fact_scope_status = 'ACTIVE_ALIAS' THEN
-        v_data_eligible.append(v_target);
-        v_data_eligible_count := v_data_eligible_count + 1;
-      ELSE
-        v_data_ineligible.append(v_target);
-        v_unresolved.append(v_target);
-      END IF;
-    END LOOP;
-  ELSIF v_target_type = 'NONE' THEN
-    v_target := JSON_OBJECT_T();
-    v_target.put_null('mention');
-    v_target.put('status', 'NONE');
-    v_target.put('matchStatus', 'NOT_APPLICABLE');
-    v_target.put_null('gameKey');
-    v_target.put_null('gameId');
-    v_target.put_null('gamePrefix');
-    v_target.put_null('gameName');
-    v_target.put_null('aliases');
-    v_target.put_null('userMasterObjectName');
-    v_target.put('objectStatus', 'NOT_APPLICABLE');
-    v_target.put('factScopeStatus', 'NOT_APPLICABLE');
-    v_target.put('dataStatus', 'NOT_APPLICABLE');
-    v_target.put_null('cosineDistance');
-    v_target.put('reasonCode', 'NO_GAME_TARGET');
-    v_target.put(
-      'reason',
-      'The question does not select a particular game.'
-    );
-    v_targets.append(v_target);
-  ELSE
-    FOR i IN 0 .. v_mentions.get_size - 1 LOOP
-      v_mention := v_mentions.get_string(i);
-      v_candidates := JSON_ARRAY_T();
-      v_cursor := SGMP_POC.sg_game_catalog_search(
-        v_mention,
-        LEAST(GREATEST(NVL(p_top_k, 5), 1), 20)
-      );
-
-      LOOP
-        FETCH v_cursor INTO
-          v_game_key,
-          v_game_id,
-          v_game_prefix,
-          v_game_nm,
-          v_game_alias_nm,
-          v_user_master_object_name,
-          v_cosine_distance;
-        EXIT WHEN v_cursor%NOTFOUND;
-
-        v_candidate := JSON_OBJECT_T();
-        v_candidate.put('gameKey', v_game_key);
-        v_candidate.put('gameId', v_game_id);
-        v_candidate.put('gamePrefix', v_game_prefix);
-        v_candidate.put('gameName', v_game_nm);
-        v_candidate.put('aliases', v_game_alias_nm);
-        v_candidate.put(
-          'userMasterObjectName',
-          v_user_master_object_name
-        );
-        v_candidate.put(
-          'objectStatus',
-          CASE WHEN v_user_master_object_name IS NULL
-            THEN 'UNAVAILABLE' ELSE 'AVAILABLE' END
-        );
-        v_candidate.put(
-          'factScopeStatus',
-          sg_game_fact_scope_status(v_game_id)
-        );
-        v_candidate.put('cosineDistance', v_cosine_distance);
-        v_candidates.append(v_candidate);
-      END LOOP;
-      CLOSE v_cursor;
-
-      v_decision_raw := sg_game_match_candidate(
-        v_mention,
-        v_candidates.to_clob
-      );
-      v_decision := JSON_OBJECT_T.parse(v_decision_raw);
-      v_decision_status := UPPER(
-        NVL(v_decision.get_string('status'), 'UNMATCHED')
-      );
-      v_selected_key := v_decision.get_string('game_key');
-      v_reason := v_decision.get_string('reason');
-      v_matched_candidate := NULL;
-
-      IF v_decision_status = 'MATCHED' AND v_selected_key IS NOT NULL THEN
-        FOR j IN 0 .. v_candidates.get_size - 1 LOOP
-          v_candidate := TREAT(v_candidates.get(j) AS JSON_OBJECT_T);
-          IF v_candidate.get_string('gameKey') = v_selected_key THEN
-            v_matched_candidate := v_candidate;
-            EXIT;
-          END IF;
-        END LOOP;
-      END IF;
-
-      v_mention_result := JSON_OBJECT_T();
-      v_mention_result.put('mention', v_mention);
-      v_mention_result.put('candidateGames', v_candidates);
-      v_mention_result.put('reason', v_reason);
-
-      IF v_matched_candidate IS NOT NULL THEN
-        v_mention_result.put('status', 'MATCHED');
-        v_mention_result.put('reasonCode', 'VECTOR_SCORE_MATCH');
-        v_mention_result.put('matchedGameKey', v_selected_key);
-
-        v_target := JSON_OBJECT_T.parse(v_matched_candidate.to_clob);
-        v_target.put('mention', v_mention);
-        v_target.put('status', 'MATCHED');
-        v_target.put('matchStatus', 'MATCHED');
-        v_target.put('reasonCode', 'VECTOR_SCORE_MATCH');
-        v_target.put('reason', v_reason);
-        v_matched_count := v_matched_count + 1;
-
-        IF v_matched_candidate.get_string('factScopeStatus') = 'ACTIVE_ALIAS' THEN
-          v_target.put('dataStatus', 'AVAILABLE');
-          v_data_eligible.append(v_target);
-          v_data_eligible_count := v_data_eligible_count + 1;
-        ELSE
-          v_target.put('dataStatus', 'UNAVAILABLE');
-          v_data_ineligible.append(v_target);
-          v_unresolved.append(v_target);
-        END IF;
-        v_targets.append(v_target);
-        IF NOT v_seen_game_keys.EXISTS(v_selected_key) THEN
-          v_supported.append(v_target);
-          v_seen_game_keys(v_selected_key) := TRUE;
-        END IF;
-      ELSE
-        v_mention_result.put('status', 'UNMATCHED');
-        v_mention_result.put('reasonCode', 'VECTOR_SCORE_OVER_THRESHOLD');
-
-        v_target := JSON_OBJECT_T();
-        v_target.put('mention', v_mention);
-        v_target.put('status', 'UNMATCHED');
-        v_target.put('matchStatus', 'UNMATCHED');
-        v_target.put_null('gameKey');
-        v_target.put_null('gameId');
-        v_target.put_null('gamePrefix');
-        v_target.put_null('gameName');
-        v_target.put_null('aliases');
-        v_target.put_null('userMasterObjectName');
-        v_target.put('objectStatus', 'UNAVAILABLE');
-        v_target.put('factScopeStatus', 'UNAVAILABLE');
-        v_target.put('dataStatus', 'UNAVAILABLE');
-        v_target.put_null('cosineDistance');
-        v_target.put(
-          'reasonCode',
-          v_mention_result.get_string('reasonCode')
-        );
-        v_target.put('reason', v_reason);
-        v_targets.append(v_target);
-
-        v_unmatched_item := JSON_OBJECT_T();
-        v_unmatched_item.put('mention', v_mention);
-        v_unmatched_item.put(
-          'reasonCode',
-          v_mention_result.get_string('reasonCode')
-        );
-        v_unmatched_item.put('reason', v_reason);
-        v_unmatched.append(v_unmatched_item);
-        v_unresolved.append(v_target);
-        v_unmatched_count := v_unmatched_count + 1;
-      END IF;
-      v_mention_results.append(v_mention_result);
-    END LOOP;
-  END IF;
-
-  IF v_target_type = 'NONE' THEN
-    v_plan_status := 'NO_TARGET';
-  ELSIF v_matched_count = 0 THEN
-    v_plan_status := 'UNMATCHED';
-  ELSIF v_data_eligible_count = 0 THEN
-    v_plan_status := 'UNAVAILABLE';
-  ELSIF v_unmatched_count > 0 THEN
-    v_plan_status := 'PARTIAL';
-  ELSE
-    v_plan_status := 'SUPPORTED';
-  END IF;
-
-  -- This is the sole Select AI handoff contract.  It is deliberately generic:
-  -- game values and physical objects come only from the database lookup above.
-  v_reference_summary.put('targetType', v_target_type);
-  v_reference_summary.put('status', v_plan_status);
-  v_reference_summary.put('gameTargets', v_supported);
-  v_select_ai_reference := '[GAME QUERY REFERENCE]' || CHR(10) || CHR(10)
-    || v_reference_summary.to_clob()
-    || CHR(10) || CHR(10)
-    || 'Field meanings:' || CHR(10) || CHR(10)
-    || '* targetType:' || CHR(10)
-    || '  * NONE: No game was resolved.' || CHR(10)
-    || '  * SINGLE: Exactly one game was resolved.' || CHR(10)
-    || '  * MULTI: Multiple specific games were resolved.' || CHR(10)
-    || '  * ALL: The query applies to all supported games.' || CHR(10)
-    || '* status: The result of game-target resolution.' || CHR(10)
-    || '* gameTargets: The exact games resolved by the DB lookup. Each item may include:' || CHR(10)
-    || '  * gameKey: Canonical game identifier.' || CHR(10)
-    || '  * gamePrefix: Prefix used for game-scoped objects.' || CHR(10)
-    || '  * userMasterObjectName: Resolved user-master object for that game.' || CHR(10) || CHR(10)
-    || 'Object-selection guidance:' || CHR(10) || CHR(10)
-    || '* Use only the targets listed in gameTargets.' || CHR(10)
-    || '* For NONE, use a game-neutral common object when it directly answers the question.' || CHR(10)
-    || '* If no suitable common object exists, state that a game name is required.' || CHR(10)
-    || '* Do not infer an unlisted game or game-scoped object.';
-
-  v_result.put('contractVersion', '2.0');
-  v_result.put('targetType', v_target_type);
-  v_result.put('scopeType', v_target_type);
-  v_result.put('selectAiReference', v_select_ai_reference);
-  v_result.put('extractScopeHint', v_scope_type);
-  v_result.put('status', v_plan_status);
-  -- `gameTargets` is the public downstream contract.  The detailed `targets`
-  -- collection remains diagnostic evidence only for the MCP response.
-  v_result.put('gameTargets', v_supported);
-  v_result.put('targets', v_targets);
-  v_result.put('matchedGames', v_supported);
-  v_result.put('mentionResults', v_mention_results);
-  v_result.put('supportedGames', v_supported);
-  v_result.put('dataEligibleTargets', v_data_eligible);
-  v_result.put('unresolvedTargets', v_unresolved);
-  v_result.put('dataIneligibleTargets', v_data_ineligible);
-  v_result.put('unmatchedGames', v_unmatched);
-  -- Dynamic ReAct work items. Every game identity and availability state comes
-  -- from the catalog lookup above; clients must not infer their own targets.
-  FOR i IN 0 .. v_targets.get_size - 1 LOOP
-    v_target := TREAT(v_targets.get(i) AS JSON_OBJECT_T);
-    IF v_target.get_string('gameKey') IS NOT NULL THEN
-      v_execution_task := JSON_OBJECT_T();
-      v_execution_task.put(
-        'action',
-        CASE
-          WHEN v_target.get_string('dataStatus') = 'AVAILABLE'
-            AND v_target.get_string('userMasterObjectName') IS NOT NULL
-          THEN 'QUERY'
-          ELSE 'REPORT_UNAVAILABLE'
-        END
-      );
-      v_execution_task.put('scopeGameKey', v_target.get_string('gameKey'));
-      v_execution_task.put('target', v_target);
-      IF v_execution_task.get_string('action') = 'QUERY' THEN
-        v_excluded_mentions := JSON_ARRAY_T();
-        FOR j IN 0 .. v_targets.get_size - 1 LOOP
-          v_candidate := TREAT(v_targets.get(j) AS JSON_OBJECT_T);
-          IF v_candidate.get_string('gameKey') <> v_target.get_string('gameKey')
-             AND v_candidate.get_string('mention') IS NOT NULL THEN
-            v_excluded_mentions.append(v_candidate.get_string('mention'));
-          END IF;
-        END LOOP;
-
-        -- Preserve the original question verbatim. The target-specific
-        -- queryPlan below is the separate, authoritative scope contract.
-        v_task_question := p_question;
-        v_task_reference := JSON_OBJECT_T();
-        v_task_targets := JSON_ARRAY_T();
-        v_task_targets.append(v_target);
-        v_task_reference.put('targetType', 'SINGLE');
-        v_task_reference.put('status', 'SUPPORTED');
-        v_task_reference.put('gameTargets', v_task_targets);
-
-        v_task_plan := JSON_OBJECT_T();
-        v_task_plan.put('contractVersion', '2.0');
-        v_task_plan.put('targetType', 'SINGLE');
-        v_task_plan.put('status', 'SUPPORTED');
-        v_task_plan.put('gameTargets', v_task_targets);
-        v_task_plan.put('selectAiReference',
-          '[GAME QUERY REFERENCE]' || CHR(10) || CHR(10) || v_task_reference.to_clob());
-
-        v_worker_arguments := JSON_OBJECT_T();
-        v_worker_arguments.put('prompt', v_task_question);
-        v_worker_arguments.put('scopeGameKey', v_target.get_string('gameKey'));
-        v_worker_arguments.put('queryPlan', v_task_plan);
-        v_fewshot_arguments := JSON_OBJECT_T();
-        v_fewshot_arguments.put('question', v_task_question);
-        v_fewshot_arguments.put('topK', 3);
-        v_execution_task.put('workerTool', 'oracle.select_ai.smilegate_fewshot_nl2sql');
-        v_execution_task.put('workerArguments', v_worker_arguments);
-        v_execution_task.put('fewShotArguments', v_fewshot_arguments);
-      END IF;
-      v_execution_tasks.append(v_execution_task);
-    END IF;
-  END LOOP;
-  v_result.put('executionTasks', v_execution_tasks);
-  v_result.put('nextAction', 'CALL_FEWSHOT');
-
-  CASE v_target_type
-    WHEN 'NONE' THEN v_result.put('executionMode', 'UNSCOPED');
-    WHEN 'SINGLE' THEN v_result.put('executionMode', 'SINGLE');
-    WHEN 'MULTI' THEN v_result.put('executionMode', 'COMBINED');
-    WHEN 'ALL' THEN v_result.put('executionMode', 'ALL');
-  END CASE;
-
-  RETURN v_result.to_clob;
-END;
-/

database/adb/82_hmm_federation_relationship_comments.sql

@@ -1,67 +0,0 @@
--- ============================================================
--- Explicit Select AI relationship metadata for ADB + RDS Views.
--- Redmine: #730
--- ============================================================
-
-WHENEVER SQLERROR EXIT SQL.SQLCODE
-SET DEFINE OFF
-SET FEEDBACK ON
-
-COMMENT ON TABLE hmm_carrier_assignments_v IS
-  'ADB employee-to-carrier assignments from HMM_HR_EMPLOYEES, HMM_ACCESS_GROUPS, and HMM_ACCESS_GROUP_MEMBERS. Join relationship: HMM_CARRIER_ASSIGNMENTS_V.CARRIER_CODE joins HMM_RDS_CARRIERS_V.CARRIER_CODE, HMM_RDS_CARRIER_PERF_V.CARRIER_CODE, and HMM_RDS_CARRIER_LATEST_V.CARRIER_CODE.';
-
-COMMENT ON COLUMN hmm_carrier_assignments_v.EMPLOYEE_CODE IS
-  'HMM employee code sourced from HMM_HR_EMPLOYEES.EMPLOYEE_CODE. Example: E1002.';
-
-COMMENT ON COLUMN hmm_carrier_assignments_v.MANAGER_EMPLOYEE_CODE IS
-  'Direct manager employee code sourced from HMM_HR_EMPLOYEES. Use E1001 to identify the HMM demo manager team.';
-
-COMMENT ON COLUMN hmm_carrier_assignments_v.CARRIER_CODE IS
-  'Join Key and Foreign Key to HMM_RDS_CARRIERS_V(CARRIER_CODE), HMM_RDS_CARRIER_PERF_V(CARRIER_CODE), and HMM_RDS_CARRIER_LATEST_V(CARRIER_CODE).';
-
-COMMENT ON TABLE hmm_rds_carriers_v IS
-  'PostgreSQL fictional carrier master exposed through HMM_RDS_PG_LINK. Primary Key: CARRIER_CODE. Join relationship: HMM_RDS_CARRIERS_V.CARRIER_CODE joins HMM_CARRIER_ASSIGNMENTS_V.CARRIER_CODE and HMM_RDS_CARRIER_PERF_V.CARRIER_CODE.';
-
-COMMENT ON COLUMN hmm_rds_carriers_v.CARRIER_CODE IS
-  'Primary Key. Join Key to HMM_CARRIER_ASSIGNMENTS_V(CARRIER_CODE), HMM_RDS_CARRIER_PERF_V(CARRIER_CODE), and HMM_RDS_CARRIER_LATEST_V(CARRIER_CODE).';
-
-COMMENT ON TABLE hmm_rds_carrier_perf_v IS
-  'PostgreSQL monthly carrier KPI exposed through HMM_RDS_PG_LINK. Composite Primary Key: CARRIER_CODE and PERFORMANCE_MONTH. Foreign Key: CARRIER_CODE references HMM_RDS_CARRIERS_V(CARRIER_CODE). Join relationship: CARRIER_CODE joins HMM_CARRIER_ASSIGNMENTS_V.CARRIER_CODE.';
-
-COMMENT ON COLUMN hmm_rds_carrier_perf_v.CARRIER_CODE IS
-  'Foreign Key to HMM_RDS_CARRIERS_V(CARRIER_CODE). Join Key to HMM_CARRIER_ASSIGNMENTS_V(CARRIER_CODE).';
-
-COMMENT ON COLUMN hmm_rds_carrier_perf_v.PERFORMANCE_MONTH IS
-  'Part of the composite Primary Key with CARRIER_CODE. First calendar day of the KPI month.';
-
-COMMENT ON TABLE hmm_rds_carrier_latest_v IS
-  'Latest PostgreSQL KPI for each fictional carrier exposed through HMM_RDS_PG_LINK. Primary Key: CARRIER_CODE. Join relationship: HMM_RDS_CARRIER_LATEST_V.CARRIER_CODE joins HMM_CARRIER_ASSIGNMENTS_V.CARRIER_CODE and HMM_RDS_CARRIERS_V.CARRIER_CODE.';
-
-COMMENT ON COLUMN hmm_rds_carrier_latest_v.CARRIER_CODE IS
-  'Primary Key. Join Key to HMM_CARRIER_ASSIGNMENTS_V(CARRIER_CODE) and HMM_RDS_CARRIERS_V(CARRIER_CODE).';
-
-SELECT table_name, comments
-FROM user_tab_comments
-WHERE table_name IN (
-  'HMM_CARRIER_ASSIGNMENTS_V',
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-)
-ORDER BY table_name;
-
-SELECT table_name, column_name, comments
-FROM user_col_comments
-WHERE table_name IN (
-  'HMM_CARRIER_ASSIGNMENTS_V',
-  'HMM_RDS_CARRIERS_V',
-  'HMM_RDS_CARRIER_PERF_V',
-  'HMM_RDS_CARRIER_LATEST_V'
-)
-  AND column_name IN (
-    'EMPLOYEE_CODE',
-    'MANAGER_EMPLOYEE_CODE',
-    'CARRIER_CODE',
-    'PERFORMANCE_MONTH'
-  )
-ORDER BY table_name, column_name;

database/adb/82_sgmp_qa_fewshot_reference_governance.sql

@@ -1,219 +0,0 @@
--- Governed Few-shot examples for the Smilegate Select AI MCP.
--- Existing rows are preserved for audit and only APPROVED rows are retrievable.
-
-DECLARE
-  PROCEDURE add_column(p_definition IN VARCHAR2) IS
-  BEGIN
-    EXECUTE IMMEDIATE 'ALTER TABLE sg_qa_vector_example ADD (' || p_definition || ')';
-  EXCEPTION
-    WHEN OTHERS THEN
-      IF SQLCODE != -1430 THEN
-        RAISE;
-      END IF;
-  END;
-BEGIN
-  add_column('reference_status VARCHAR2(16) DEFAULT ''DRAFT'' NOT NULL');
-  add_column('reference_kind VARCHAR2(32) DEFAULT ''SQL_TEMPLATE'' NOT NULL');
-  add_column('target_type VARCHAR2(16) DEFAULT ''ANY'' NOT NULL');
-  add_column('object_role VARCHAR2(64)');
-  add_column('inspection_status VARCHAR2(16) DEFAULT ''PENDING'' NOT NULL');
-  add_column('inspection_note CLOB');
-  add_column('verified_at TIMESTAMP(6)');
-  add_column('verified_by VARCHAR2(128)');
-END;
-/
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       inspection_status = 'RETIRED',
-       inspection_note = 'Executed successfully but maps BUBBLYZ to the CZN physical user-master object. Conflicts with the approved game-target contract.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id = 2;
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       reference_kind = 'OBJECT_UNAVAILABLE',
-       target_type = 'SINGLE',
-       object_role = 'GAME_ALIAS_CATALOG',
-       inspection_status = 'RETIRED',
-       inspection_note = 'Executed successfully with no BUBBLYZ alias rows, but the game literal is not a reusable object-unavailable template. The current game query plan is the authoritative boundary source.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id = 3;
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'SINGLE',
-       object_role = 'GAME_USER_MASTER',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Logical placeholder template. The resolved physical object must come only from the current game query plan.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id = 4;
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       reference_kind = 'NO_TARGET',
-       target_type = 'NONE',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Executed successfully with no rows. Canonical boundary for an unscoped game-user-master request.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id = 5;
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       reference_kind = 'METADATA_POLICY',
-       target_type = 'ANY',
-       object_role = 'GAME_ALIAS_CATALOG',
-       inspection_status = 'RETIRED',
-       inspection_note = 'Not directly executable: requires an unbound GAME_TERM placeholder. Game resolution is now supplied by game_query_plan.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id = 6;
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       reference_kind = 'SQL_TEMPLATE',
-       target_type = 'NONE',
-       object_role = 'GAME_USER_MASTER',
-       inspection_status = 'RETIRED',
-       inspection_note = 'Executed successfully but chooses CZN_COMN_USER_MST for a game-unscoped question. Conflicts with the NONE target contract.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_REVIEW'
- WHERE example_id IN (7, 8);
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_store(
-  p_question   IN CLOB,
-  p_answer_sql IN CLOB,
-  p_answer     IN CLOB DEFAULT NULL
-) RETURN NUMBER
-AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_input      CLOB;
-  v_embedding  VECTOR;
-  v_example_id NUMBER;
-BEGIN
-  IF p_question IS NULL OR p_answer_sql IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20002, 'question and answer_sql are required.');
-  END IF;
-
-  v_input := TO_CLOB('Question: ') || p_question
-          || TO_CLOB(CHR(10) || 'Answer SQL: ') || p_answer_sql
-          || CASE WHEN p_answer IS NULL THEN NULL ELSE TO_CLOB(CHR(10) || 'Answer: ') || p_answer END;
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  INSERT INTO sg_qa_vector_example (
-    question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-    reference_status, reference_kind, target_type, inspection_status
-  ) VALUES (
-    p_question, p_answer_sql, p_answer, v_input, v_embedding, 'cohere.embed-v4.0',
-    'DRAFT', 'SQL_TEMPLATE', 'ANY', 'PENDING'
-  ) RETURNING example_id INTO v_example_id;
-
-  COMMIT;
-  RETURN v_example_id;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR
-AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results      SYS_REFCURSOR;
-  v_target_type  VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'target_type must be NONE, SINGLE, MULTI, ALL, or ANY.');
-  END IF;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id,
-           question,
-           answer_sql,
-           answer_text,
-           embedding_model,
-           reference_kind,
-           target_type,
-           object_role,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     WHERE reference_status = 'APPROVED'
-       AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-     ORDER BY vector_distance(embedding, v_query_vector, COSINE), example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_context(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN CLOB
-AUTHID DEFINER
-IS
-  v_results SYS_REFCURSOR;
-  v_id      NUMBER;
-  v_q       CLOB;
-  v_sql     CLOB;
-  v_answer  CLOB;
-  v_model   VARCHAR2(128);
-  v_kind    VARCHAR2(32);
-  v_target  VARCHAR2(16);
-  v_role    VARCHAR2(64);
-  v_dist    NUMBER;
-  v_context CLOB := EMPTY_CLOB();
-BEGIN
-  v_results := sg_qa_vector_search(p_question, p_top_k, p_target_type);
-  LOOP
-    FETCH v_results INTO v_id, v_q, v_sql, v_answer, v_model, v_kind, v_target, v_role, v_dist;
-    EXIT WHEN v_results%NOTFOUND;
-    v_context := v_context
-      || CASE WHEN DBMS_LOB.GETLENGTH(v_context) = 0 THEN NULL ELSE CHR(10) || CHR(10) END
-      || '[Example ' || v_id || ', kind=' || v_kind || ', target_type=' || v_target
-      || ', cosine_distance=' || TO_CHAR(v_dist, 'FM0D000000') || ']' || CHR(10)
-      || 'Question: ' || v_q || CHR(10)
-      || 'Answer SQL: ' || v_sql
-      || CASE WHEN v_answer IS NULL THEN NULL ELSE CHR(10) || 'Answer: ' || v_answer END;
-  END LOOP;
-  CLOSE v_results;
-  RETURN v_context;
-END;
-/
-
-COMMENT ON COLUMN sg_qa_vector_example.reference_status IS
-  'Few-shot retrieval lifecycle: DRAFT, APPROVED, or RETIRED. Only APPROVED is retrievable.';
-COMMENT ON COLUMN sg_qa_vector_example.reference_kind IS
-  'Few-shot semantic kind: SQL_TEMPLATE, NO_TARGET, OBJECT_UNAVAILABLE, or METADATA_POLICY.';
-COMMENT ON COLUMN sg_qa_vector_example.target_type IS
-  'Applicable game query-plan target type: NONE, SINGLE, MULTI, ALL, or ANY.';
-COMMENT ON COLUMN sg_qa_vector_example.object_role IS
-  'Logical object role; physical object names must be sourced from the current game query plan.';

database/adb/83_sgmp_qa_benchmark_fewshot_candidates.sql

@@ -1,304 +0,0 @@
--- Import the 47 customer QA benchmark rows as governed Few-shot candidates.
--- This migration deliberately creates DRAFT records only.  Retrieval continues
--- to use APPROVED rows only (see 82_sgmp_qa_fewshot_reference_governance.sql).
-
-DECLARE
-  PROCEDURE add_column(p_definition IN VARCHAR2) IS
-  BEGIN
-    EXECUTE IMMEDIATE 'ALTER TABLE sg_qa_vector_example ADD (' || p_definition || ')';
-  EXCEPTION
-    WHEN OTHERS THEN
-      IF SQLCODE != -1430 THEN
-        RAISE;
-      END IF;
-  END;
-BEGIN
-  add_column('source_case_id VARCHAR2(30)');
-  add_column('source_type VARCHAR2(30)');
-END;
-/
-
-BEGIN
-  EXECUTE IMMEDIATE
-    'CREATE UNIQUE INDEX sg_qa_vector_example_source_uk '
-    || 'ON sg_qa_vector_example (source_type, source_case_id)';
-EXCEPTION
-  WHEN OTHERS THEN
-    IF SQLCODE != -955 THEN
-      RAISE;
-    END IF;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_seed_benchmark
-RETURN NUMBER
-AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_input       CLOB;
-  v_embedding   VECTOR;
-  v_answer_sql  CLOB;
-  v_answer_text CLOB;
-  v_exists      NUMBER;
-  v_inserted    NUMBER := 0;
-BEGIN
-  FOR item IN (
-    SELECT question_code,
-           question_text,
-           baseline_sql,
-           baseline_answer,
-           expected_focus,
-           support_level
-      FROM sg_ai_qa_question
-     WHERE question_source = 'CUSTOMER_EXCEL'
-       AND active_yn = 'Y'
-     ORDER BY question_code
-  ) LOOP
-    SELECT CASE
-             WHEN EXISTS (
-               SELECT 1
-                 FROM sg_qa_vector_example existing
-                WHERE existing.source_type = 'CUSTOMER_QA_BENCHMARK'
-                  AND existing.source_case_id = item.question_code
-             ) THEN 1 ELSE 0
-           END
-      INTO v_exists
-      FROM dual;
-
-    IF v_exists = 0 THEN
-      v_answer_sql := CASE
-        WHEN item.baseline_sql IS NULL OR DBMS_LOB.GETLENGTH(TRIM(item.baseline_sql)) = 0
-          THEN TO_CLOB('SELECT CAST(NULL AS NUMBER) AS "NO_BASELINE" FROM DUAL WHERE 1 = 0')
-        ELSE item.baseline_sql
-      END;
-      v_answer_text := TO_CLOB('Expected focus: ') || item.expected_focus
-        || CASE WHEN item.baseline_answer IS NULL THEN NULL
-                ELSE TO_CLOB(CHR(10) || 'Historical answer: ') || item.baseline_answer END;
-      v_input := TO_CLOB('Customer QA case: ') || item.question_code
-        || TO_CLOB(CHR(10) || 'Question: ') || item.question_text
-        || TO_CLOB(CHR(10) || 'Expected focus: ') || item.expected_focus
-        || TO_CLOB(CHR(10) || 'Candidate SQL: ') || v_answer_sql;
-      v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-        v_input,
-        JSON(sg_qa_vector_params('search_document'))
-      );
-
-      BEGIN
-        INSERT INTO sg_qa_vector_example (
-          question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-          reference_status, reference_kind, target_type, inspection_status,
-          inspection_note, source_case_id, source_type
-        ) VALUES (
-          item.question_text, v_answer_sql, v_answer_text, v_input, v_embedding, 'cohere.embed-v4.0',
-          'DRAFT',
-          CASE WHEN item.support_level = 'UNSUPPORTED' THEN 'OBJECT_UNAVAILABLE'
-               ELSE 'SQL_TEMPLATE' END,
-          'ANY',
-          'PENDING',
-          'Imported from the customer benchmark. A candidate cannot be retrieved until scope, logical object role, and SQL safety are reviewed.',
-          item.question_code,
-          'CUSTOMER_QA_BENCHMARK'
-        );
-        v_inserted := v_inserted + 1;
-      EXCEPTION
-        WHEN DUP_VAL_ON_INDEX THEN
-          NULL;
-      END;
-    END IF;
-  END LOOP;
-
-  COMMIT;
-  RETURN v_inserted;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_approve_verified_benchmark
-RETURN NUMBER
-AUTHID DEFINER
-IS
-  PRAGMA AUTONOMOUS_TRANSACTION;
-  v_target_type VARCHAR2(16);
-  v_input       CLOB;
-  v_answer_text CLOB;
-  v_embedding   VECTOR;
-  v_approved    NUMBER := 0;
-BEGIN
-  FOR item IN (
-    WITH latest_answer AS (
-      SELECT answer.question_id,
-             answer.generated_sql,
-             answer.answer_text,
-             answer.result_json,
-             answer.judgment_status,
-             answer.execution_status,
-             ROW_NUMBER() OVER (
-               PARTITION BY answer.question_id ORDER BY answer.answer_seq DESC
-             ) AS row_rank
-        FROM sg_ai_qa_answer answer
-    )
-    SELECT example.example_id,
-           question.question_text,
-           question.expected_focus,
-           question.support_level,
-           latest.generated_sql,
-           latest.answer_text AS live_answer,
-           latest.result_json,
-           latest.judgment_status,
-           latest.execution_status
-      FROM sg_qa_vector_example example
-      JOIN sg_ai_qa_question question
-        ON question.question_code = example.source_case_id
-      LEFT JOIN latest_answer latest
-        ON latest.question_id = question.question_id
-       AND latest.row_rank = 1
-     WHERE example.source_type = 'CUSTOMER_QA_BENCHMARK'
-       AND example.reference_status = 'DRAFT'
-  ) LOOP
-    IF item.support_level = 'SUPPORTED'
-       AND item.judgment_status = 'PASS'
-       AND item.execution_status = 'COMPLETED'
-       AND item.generated_sql IS NOT NULL
-       AND DBMS_LOB.GETLENGTH(TRIM(item.generated_sql)) > 0 THEN
-      v_target_type := REGEXP_SUBSTR(
-        DBMS_LOB.SUBSTR(item.result_json, 32767, 1),
-        '"targetType"[[:space:]]*:[[:space:]]*"([A-Z]+)"',
-        1, 1, NULL, 1
-      );
-      IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-        v_target_type := 'ANY';
-      END IF;
-      v_answer_text := TO_CLOB('Expected focus: ') || item.expected_focus
-        || CASE WHEN item.live_answer IS NULL THEN NULL
-                ELSE TO_CLOB(CHR(10) || 'Verified live answer: ') || item.live_answer END;
-      v_input := TO_CLOB('Customer QA question: ') || item.question_text
-        || TO_CLOB(CHR(10) || 'Expected focus: ') || item.expected_focus
-        || TO_CLOB(CHR(10) || 'Verified SQL template: ') || item.generated_sql;
-      v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-        v_input,
-        JSON(sg_qa_vector_params('search_document'))
-      );
-      UPDATE sg_qa_vector_example
-         SET answer_sql = item.generated_sql,
-             answer_text = v_answer_text,
-             embedding_input = v_input,
-             embedding = v_embedding,
-             reference_status = 'APPROVED',
-             reference_kind = 'SQL_TEMPLATE',
-             target_type = v_target_type,
-             inspection_status = 'VERIFIED',
-             inspection_note = 'Promoted only after the latest Portal ReAct run completed with PASS for this customer benchmark case.',
-             verified_at = SYSTIMESTAMP,
-             verified_by = 'SGMP_POC_BENCHMARK_REVIEW'
-       WHERE example_id = item.example_id;
-      v_approved := v_approved + 1;
-    ELSE
-      UPDATE sg_qa_vector_example
-         SET inspection_status = 'REVIEW',
-             inspection_note = 'Not retrievable: latest customer benchmark execution is unsupported, incomplete, WARN, FAIL, or lacks executable SQL.'
-       WHERE example_id = item.example_id;
-    END IF;
-  END LOOP;
-  COMMIT;
-  RETURN v_approved;
-EXCEPTION
-  WHEN OTHERS THEN
-    ROLLBACK;
-    RAISE;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR
-AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results      SYS_REFCURSOR;
-  v_target_type  VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'target_type must be NONE, SINGLE, MULTI, ALL, or ANY.');
-  END IF;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id,
-           question,
-           answer_sql,
-           answer_text,
-           embedding_model,
-           reference_kind,
-           target_type,
-           object_role,
-           source_case_id,
-           source_type,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     WHERE reference_status = 'APPROVED'
-       AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-     ORDER BY vector_distance(embedding, v_query_vector, COSINE), example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_context(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN CLOB
-AUTHID DEFINER
-IS
-  v_results SYS_REFCURSOR;
-  v_id      NUMBER;
-  v_q       CLOB;
-  v_sql     CLOB;
-  v_answer  CLOB;
-  v_model   VARCHAR2(128);
-  v_kind    VARCHAR2(32);
-  v_target  VARCHAR2(16);
-  v_role    VARCHAR2(64);
-  v_case_id VARCHAR2(30);
-  v_source  VARCHAR2(30);
-  v_dist    NUMBER;
-  v_context CLOB := EMPTY_CLOB();
-BEGIN
-  v_results := sg_qa_vector_search(p_question, p_top_k, p_target_type);
-  LOOP
-    FETCH v_results INTO v_id, v_q, v_sql, v_answer, v_model, v_kind, v_target, v_role,
-      v_case_id, v_source, v_dist;
-    EXIT WHEN v_results%NOTFOUND;
-    v_context := v_context
-      || CASE WHEN DBMS_LOB.GETLENGTH(v_context) = 0 THEN NULL ELSE CHR(10) || CHR(10) END
-      || '[Example ' || v_id || ', kind=' || v_kind || ', target_type=' || v_target
-      || CASE WHEN v_case_id IS NULL THEN NULL ELSE ', source_case_id=' || v_case_id END
-      || ', cosine_distance=' || TO_CHAR(v_dist, 'FM0D000000') || ']' || CHR(10)
-      || 'Question: ' || v_q || CHR(10)
-      || 'Answer SQL: ' || v_sql
-      || CASE WHEN v_answer IS NULL THEN NULL ELSE CHR(10) || 'Answer: ' || v_answer END;
-  END LOOP;
-  CLOSE v_results;
-  RETURN v_context;
-END;
-/
-
-COMMENT ON COLUMN sg_qa_vector_example.source_case_id IS
-  'Customer QA benchmark case identifier, such as STD-01 or CZN-01.';
-COMMENT ON COLUMN sg_qa_vector_example.source_type IS
-  'Candidate provenance. CUSTOMER_QA_BENCHMARK rows remain DRAFT until reviewed.';

database/adb/84_sgmp_none_scope_common_object_guidance.sql

@@ -1,31 +0,0 @@
--- NONE means "no selected game", not "no executable query".
--- Keep the boundary example scoped to its logical object role so it cannot
--- be generalized to approved common-object questions.
-
-UPDATE sg_qa_vector_example
-   SET object_role = 'GAME_USER_MASTER',
-       answer_text = 'This boundary applies only to a game-scoped user-master operation. '
-           || 'When no game identifier is resolved, do not select a prefix-specific user-master object. '
-           || 'This does not prohibit an approved common-object query.',
-       inspection_note = 'Canonical boundary for an unscoped game-user-master request. '
-           || 'It applies only to GAME_USER_MASTER and must not suppress common-object queries.'
- WHERE example_id = 5
-   AND reference_kind = 'NO_TARGET';
-
--- Populate logical roles from verified SQL. This is prompt metadata only;
--- runtime physical-object selection remains governed by the query plan.
-UPDATE sg_qa_vector_example
-   SET object_role = CASE
-     WHEN REGEXP_LIKE(answer_sql, 'COMN_SALES_TXN', 'i') THEN 'SALES_TRANSACTION'
-     WHEN REGEXP_LIKE(answer_sql, 'COMN_REFUND_TXN', 'i') THEN 'REFUND_TRANSACTION'
-     WHEN REGEXP_LIKE(answer_sql, 'COMN_CHARACTER_MST', 'i') THEN 'GAME_CHARACTER_MASTER'
-     WHEN REGEXP_LIKE(answer_sql, 'COMN_USER_MST', 'i') THEN 'GAME_USER_MASTER'
-     ELSE object_role
-   END
- WHERE reference_status = 'APPROVED'
-   AND object_role IS NULL;
-
-COMMENT ON COLUMN sg_qa_vector_example.object_role IS
-  'Logical business object role used to bound Few-shot interpretation. It is not a runtime physical-object selector.';
-
-COMMIT;

database/adb/85_sgmp_no_target_null_value_template.sql

@@ -1,39 +0,0 @@
--- A no-target aggregate is a successful empty-value result, not a no-row
--- execution failure. Keep the output alias from the verified logical metric.
-
-DECLARE
-  v_input CLOB;
-  v_embedding VECTOR;
-BEGIN
-  SELECT TO_CLOB('Question: ') || question
-      || TO_CLOB(CHR(10) || 'Answer SQL: SELECT CAST(NULL AS NUMBER) AS "USER_COUNT" FROM DUAL')
-      || TO_CLOB(CHR(10) || 'Answer: This boundary applies only to a game-scoped user-master operation. '
-          || 'When no game identifier is resolved, do not select a prefix-specific user-master object. '
-          || 'Return USER_COUNT as NULL. This does not prohibit an approved common-object query.')
-    INTO v_input
-    FROM sg_qa_vector_example
-   WHERE example_id = 5;
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  UPDATE sg_qa_vector_example
-     SET answer_sql = 'SELECT CAST(NULL AS NUMBER) AS "USER_COUNT" FROM DUAL',
-         answer_text = 'This boundary applies only to a game-scoped user-master operation. '
-             || 'When no game identifier is resolved, do not select a prefix-specific user-master object. '
-             || 'Return USER_COUNT as NULL. This does not prohibit an approved common-object query.',
-         embedding_input = v_input,
-         embedding = v_embedding,
-         embedding_model = 'cohere.embed-v4.0',
-         inspection_note = 'Canonical GAME_USER_MASTER boundary: no game target returns a NULL metric value, '
-             || 'not an execution error and not a default game selection.',
-         verified_at = SYSTIMESTAMP,
-         verified_by = 'SGMP_POC_REVIEW'
-   WHERE example_id = 5
-     AND reference_status = 'APPROVED'
-     AND reference_kind = 'NO_TARGET'
-     AND object_role = 'GAME_USER_MASTER';
-  COMMIT;
-END;
-/

database/adb/86_sgmp_game_scope_profile_guidance.sql

@@ -1,19 +0,0 @@
--- Select AI profile instructions contain only common SQL-generation guidance.
--- Game target routing and execution policy are supplied at runtime by
--- SG_GAME_QUERY_PLAN; they do not belong in the profile-wide prompt.
-
-BEGIN
-  DBMS_CLOUD_AI.SET_ATTRIBUTE(
-    profile_name => 'SGMP_POC_OCI_GPT54MINI',
-    attribute_name => 'additional_instructions',
-    attribute_value => q'~Generate Oracle SQL only for the listed approved objects. Do not reference external tables. Use English aliases only. Use database comments and annotations as the source of business rules.
-
-~'
-  );
-END;
-/
-
-SELECT attribute_name, attribute_value
-  FROM user_cloud_ai_profile_attributes
- WHERE profile_name = 'SGMP_POC_OCI_GPT54MINI'
-   AND attribute_name = 'additional_instructions';

database/adb/87_sgmp_std09_catalog_fact_boundary.sql

@@ -1,23 +0,0 @@
--- Benchmark correction: game-catalog resolution and fact-row availability are distinct.
--- Korean text is reconstructed from UTF-8 base64 so SQLcl cannot corrupt it.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '6rKM7J6EIOuzhOy5rSDsubTtg4jroZzqt7jsl5DshJwg7ZmV7J2465CcIOqyjOyehOydgCDqs7XthrUg66ek7LacIOqwneyytOydmCBHQU1FX0lE66W8IOuzhOy5rSDsubTtg4jroZzqt7ggRVhJU1RTL+yEnOu4jOy/vOumrOuhnCDsl7DqsrDtlZzri6QuIEdBTUVfSUTrgpggcHJlZml466W8IOyngeygkSDrpqzthLDrn7TroZwg6rOg7KCV7ZWY7KeAIOyViuuKlOuLpC4g7Lm07YOI66Gc6re4IOunpOy5reqzvCDtlbTri7kg66ek7LacIOyCrOyLpCDrjbDsnbTthLAg7KG07J6sIOyXrOu2gOuKlCDrs4TqsJzsnbTrqbAsIOunpOy5reuQmOyXiOyngOunjCDtlbTri7kg7J287J6QIOunpOy2nCDtlonsnbQg7JeG7Jy866m0IOynkeqzhCBOVUxMIOuYkOuKlCAw6rG07J2AIOygleyDgSDqsrDqs7zri6QuIOyehOydmOydmCDri6Trpbgg6rKM7J6E7Jy866GcIOuMgOyytO2VmOyngCDslYrripTri6Qu'
-         )),
-         'AL32UTF8'
-       )
- WHERE question_code = 'STD-09';
-
-UPDATE sg_qa_vector_example
-   SET inspection_status = 'REVIEW',
-       inspection_note = 'Customer benchmark criterion updated: catalog resolution and common-fact availability are evaluated separately.'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-09';
-
-COMMIT;
-
-SELECT question_code, expected_focus
-  FROM sg_ai_qa_question
- WHERE question_code = 'STD-09';

database/adb/88_sgmp_std11_partial_common_fact_comparison.sql

@@ -1,63 +0,0 @@
--- Benchmark correction: common-fact eligibility is determined by the active
--- alias source. Registry-only games are reported separately while eligible
--- targets continue through the common-fact query.
--- Korean baseline text and SQL are reconstructed from UTF-8 base64 for SQLcl safety.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '7Jes65+sIOqyjOyehCDruYTqtZDsl5DshJwg7Lm07YOI66Gc6re466GcIO2ZleyduOuQnCDrjIDsg4HsnYAg67OE7LmtIOy5tO2TiOuhnOq3uOulvCDqtazrj5kg7KeR7ZWp7Jy866GcIO2VmOqzoCDqs7XthrUg7IKs7IukIO2FjOydtOu4lOydhCBMRUZUIEpPSU7tlZjsl6wg6rKM7J6E67OEIOynkeqzhO2VnOuLpC4g7IKs7IukIO2WieydtCDsl4bripQg64yA7IOB7J2AIDDsnLzroZwg67O07KG07ZWY6rOgLCDrp6Tsua3rkJwg64uk66W4IOuMgOyDgeydmCDqsrDqs7zrpbwg7IOd65617ZWY7KeAIOyViuuKlOuLpC4gRFVBTCBVTklPTuycvOuhnCDrjIDsg4HrqoXqs7wg6rCS7J2EIO2VqeyEse2VmOyngCDslYrripTri6Qu'
-         )),
-         'AL32UTF8'
-       ),
-       baseline_answer = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '7Lm07YOI66Gc6re4IOunpOy5rSDrjIDsg4Hrs4Qg66ek7Lac7J2EIOuwmO2ZmO2VnOuLpC4g7IKs7IukIO2WieydtCDsl4bripQg64yA7IOB7J2AIDAsIOuLpOuluCDrp6Tsua0g64yA7IOB7J2AIO2VtOuLuSDsnbzsnpDsnZgg7KeR6rOE6rCS7J2EIOuwmO2ZmO2VnOuLpC4='
-         )),
-         'AL32UTF8'
-       ),
-       baseline_sql = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           'V0lUSCByZXF1ZXN0ZWRfZ2FtZXMgQVMgKAogIFNFTEVDVCBESVNUSU5DVCBnLiJHQU1FX0lEIiwgZy4iR0FNRV9OTSIKICBGUk9NICJTR01QX1BPQyIuIkNPTU5fR0FNRV9BTElBU19CQVMiIGcKICBXSEVSRSBnLiJVU0VfWU4iID0gJ1knCiAgICBBTkQgKAogICAgICBVUFBFUihnLiJHQU1FX05NIikgTElLRSBVUFBFUignJUJ1YmJseXolJykKICAgICAgT1IgVVBQRVIoZy4iR0FNRV9BTElBU19OTSIpIExJS0UgVVBQRVIoJyVCdWJibHl6JScpCiAgICAgIE9SIFVQUEVSKGcuIkdBTUVfTk0iKSBMSUtFIFVQUEVSKCcl7Lm07KCc64KYJScpCiAgICAgIE9SIFVQUEVSKGcuIkdBTUVfQUxJQVNfTk0iKSBMSUtFIFVQUEVSKCcl7Lm07KCc64KYJScpCiAgICApCikKU0VMRUNUIHJnLiJHQU1FX05NIiBBUyAiR0FNRV9OQU1FIiwKICAgICAgIE5WTChTVU0oQ0FTRQogICAgICAgICBXSEVOIHMuIlBBWU1UX0RUTSIgPj0gVE9fREFURSgnMjAyNjA3MTUnLCAnWVlZWU1NREQnKQogICAgICAgICAgQU5EIHMuIlBBWU1UX0RUTSIgPCBUT19EQVRFKCcyMDI2MDcxNicsICdZWVlZTU1ERCcpCiAgICAgICAgICBBTkQgcy4iRVhQVF9VU0VSX1lOIiA9ICdOJwogICAgICAgICBUSEVOIENBU1Qocy4iUEFZTVRfQU1UIiBBUyBOVU1CRVIpIEVMU0UgMCBFTkQpLCAwKSBBUyAiU0FMRVNfQU1UIgpGUk9NIHJlcXVlc3RlZF9nYW1lcyByZwpMRUZUIEpPSU4gIlNHTVBfUE9DIi4iQ09NTl9TQUxFU19UWE4iIHMKICBPTiBzLiJHQU1FX0lEIiA9IHJnLiJHQU1FX0lEIgpHUk9VUCBCWSByZy4iR0FNRV9OTSIKT1JERVIgQlkgcmcuIkdBTUVfTk0iCg=='
-         )),
-         'AL32UTF8'
-       )
- WHERE question_code = 'STD-11';
-
-UPDATE sg_qa_vector_example
-   SET inspection_status = 'REVIEW',
-       inspection_note = 'Customer benchmark criterion updated: multi-target common-fact comparisons preserve catalog-resolved zero-fact targets through a catalog-driven left join.'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-11';
-
-COMMIT;
-
--- Correct the earlier catalog-only interpretation in this same migration. A
--- registry can identify a game to the operator, but does not by itself make it
--- an approved source for a common fact query.
-UPDATE sg_ai_qa_question
-   SET expected_focus = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '67O17IiYIOqyjOyehCDqs7XthrUg7IKs7IukIOuNsOydtO2EsCDsp4jsnZjripQg7Zmc7ISxIOqyjOyehCDrs4Tsua0g7JuQ7LKc7JeQ7IScIO2ZleyduOuQnCDrjIDsg4Hrp4wg7IKs7IukIOyhsO2ajCDrjIDsg4HsnLzroZwg7IKs7Jqp7ZWY6rOgLCDrs4Tsua0g7JuQ7LKc7J20IOyXhuuKlCDroIjsp4DsiqTtirjrpqwg7KCE7JqpIOuMgOyDgeydgCDsobDtmowg67aI6rCAIOyDge2DnOuhnCDrs4Trj4Qg7JWI64K07ZWc64ukLiDsobDtmowg6rCA64ql7ZWcIOuMgOyDgeydmCDqsrDqs7zripQg7Jyg7KeA7ZWY66mwIOyghOyytCDsmpTssq3snYQg7LCo64uo7ZWY7KeAIOyViuuKlOuLpC4gRFVBTCBVTklPTuycvOuhnCDrjIDsg4Eg7ZaJ7J2064KYIOqwkuydhCDrp4zrk6Tsp4Ag7JWK64qU64ukLg=='
-         )),
-         'AL32UTF8'
-       ),
-       baseline_answer = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '7Lm07KCc64KYIOunpOy2nOydgCAyMjcsNjgx7J6F64uI64ukLiBCdWJibHl664qUIO2ZnOyEsSDqsozsnoQg67OE7LmtIOybkOyynOydtCDsl4bslrQg66ek7LacIOyhsO2ajCDrjIDsg4HsnbQg7JWE64uZ64uI64ukLg=='
-         )),
-         'AL32UTF8'
-       )
- WHERE question_code = 'STD-11';
-
-UPDATE sg_qa_vector_example
-   SET inspection_status = 'REVIEW',
-       inspection_note = 'Customer benchmark criterion updated: common-fact comparison queries use active-alias eligible targets; registry-only targets are separately unavailable and do not become synthetic fact rows.'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-11';
-
-COMMIT;
-
-SELECT question_code, expected_focus, baseline_answer
-  FROM sg_ai_qa_question
- WHERE question_code = 'STD-11';

database/adb/89_sgmp_common_fact_multi_target_guidance.sql

@@ -1,22 +0,0 @@
--- Object-specific, data-driven guidance for comparison queries on a common fact table.
--- No game, prefix, ID, or physical per-game object is embedded in this annotation.
-
-DECLARE
-  v_result VARCHAR2(4000);
-BEGIN
-  v_result := sgmp_set_annotation(
-    'SGMP_POC',
-    'TABLE',
-    'COMN_SALES_TXN',
-    NULL,
-    'Game fact scope: query this table only for plan targets marked ACTIVE_ALIAS. Derive target GAME_ID values through active COMN_GAME_ALIAS_BAS aliases rather than direct identifier or prefix literals. For a mixed request, retain the eligible target results and report other plan statuses separately; do not substitute or manufacture a target result.',
-    'MULTI_TARGET_COMPARISON'
-  );
-  DBMS_OUTPUT.PUT_LINE(v_result);
-END;
-/
-
-SELECT annotation_name, annotation_value
-  FROM user_annotations_usage
- WHERE object_name = 'COMN_SALES_TXN'
-   AND annotation_name = 'MULTI_TARGET_COMPARISON';

database/adb/90_sgmp_multi_common_fact_fewshot_template.sql

@@ -1,92 +0,0 @@
--- Generic Few-shot structure for multi-target comparisons on a common fact object.
--- The template is intentionally logical: no current game, prefix, ID, date, or result value is embedded.
-
-DECLARE
-  v_exists     NUMBER;
-  v_input      CLOB;
-  v_embedding  VECTOR;
-BEGIN
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM sg_qa_vector_example
-   WHERE source_type = 'POLICY_TEMPLATE'
-     AND source_case_id = 'MULTI_COMMON_FACT_LEFT_JOIN';
-
-  IF v_exists = 0 THEN
-    v_input := TO_CLOB('Question pattern: Compare a common fact metric across multiple resolved games. Use only fact-query-eligible targets and separately report known registry-only or unavailable targets.')
-      || CHR(10) || 'Logical object role: SALES_TRANSACTION'
-      || CHR(10) || 'Required structure: active alias catalog distinct game set, left join fact, aggregate by catalog display identifier.';
-    v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-      v_input,
-      JSON(sg_qa_vector_params('search_document'))
-    );
-
-    INSERT INTO sg_qa_vector_example (
-      question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-      reference_status, reference_kind, target_type, object_role,
-      inspection_status, inspection_note, verified_at, verified_by,
-      source_case_id, source_type
-    ) VALUES (
-      'Compare a common fact metric across multiple resolved games, including games with no fact rows.',
-      TO_CLOB('WITH resolved_games AS (' || CHR(10)
-        || '  SELECT DISTINCT a."GAME_ID", a."GAME_NM"' || CHR(10)
-        || '  FROM "SGMP_POC"."COMN_GAME_ALIAS_BAS" a' || CHR(10)
-        || '  WHERE a."USE_YN" = ''Y''' || CHR(10)
-        || '    AND (<ACTIVE_ALIAS_MATCHES_FOR_EACH_REQUESTED_GAME_TERM>)' || CHR(10)
-        || ')' || CHR(10)
-        || 'SELECT g."GAME_NM" AS "GAME_NAME",' || CHR(10)
-        || '       NVL(SUM(CASE WHEN <FACT_DATE_AND_EXCLUSION_CONDITION>' || CHR(10)
-        || '                    THEN CAST(f."<METRIC_COLUMN>" AS NUMBER) ELSE 0 END), 0) AS "METRIC_VALUE"' || CHR(10)
-        || 'FROM resolved_games g' || CHR(10)
-        || 'LEFT JOIN "SGMP_POC"."<APPROVED_COMMON_FACT_OBJECT>" f' || CHR(10)
-        || '  ON f."GAME_ID" = g."GAME_ID"' || CHR(10)
-        || 'GROUP BY g."GAME_NM"' || CHR(10)
-        || 'ORDER BY g."GAME_NM"'),
-      'Structural Few-shot only. Replace every angle-bracket placeholder from the current approved object metadata, the current game query plan, and the original question. Only ACTIVE_ALIAS targets enter the alias-driven LEFT JOIN and grouping; report registry-only or unavailable targets from the plan without manufacturing fact rows with DUAL/UNION.',
-      v_input,
-      v_embedding,
-      'cohere.embed-v4.0',
-      'APPROVED', 'SQL_TEMPLATE', 'MULTI', 'SALES_TRANSACTION',
-      'VERIFIED',
-      'Generic, non-customer-specific comparison structure. Verified against the game-alias and common-fact metadata contract; not an executable answer key.',
-      SYSTIMESTAMP, 'SGMP_POC_METADATA_REVIEW',
-      'MULTI_COMMON_FACT_LEFT_JOIN', 'POLICY_TEMPLATE'
-    );
-  END IF;
-  COMMIT;
-END;
-/
-
--- Keep the approved template current when the policy text evolves. The vector
--- is rebuilt from its generic retrieval text; no customer answer is embedded.
-DECLARE
-  v_input     CLOB;
-  v_embedding VECTOR;
-BEGIN
-  v_input := TO_CLOB('Question pattern: Compare a common fact metric across multiple resolved games. Use only fact-query-eligible targets and separately report known registry-only or unavailable targets.')
-    || CHR(10) || 'Logical object role: SALES_TRANSACTION'
-    || CHR(10) || 'Required structure: active alias catalog distinct game set, left join fact, aggregate by catalog display identifier.';
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  UPDATE sg_qa_vector_example
-     SET question = 'Compare a common fact metric across multiple resolved games, using only fact-query-eligible targets.',
-         answer_text = 'Structural Few-shot only. Replace every angle-bracket placeholder from the current approved object metadata, the current game query plan, and the original question. Only ACTIVE_ALIAS targets enter the alias-driven LEFT JOIN and grouping; report registry-only or unavailable targets from the plan without manufacturing fact rows with DUAL/UNION.',
-         embedding_input = v_input,
-         embedding = v_embedding,
-         inspection_note = 'Generic, non-customer-specific comparison structure. Active-alias targets are fact-query eligible; registry-only targets are reported separately. Not an executable answer key.',
-         verified_at = SYSTIMESTAMP,
-         verified_by = 'SGMP_POC_METADATA_REVIEW'
-   WHERE source_type = 'POLICY_TEMPLATE'
-     AND source_case_id = 'MULTI_COMMON_FACT_LEFT_JOIN';
-  COMMIT;
-END;
-/
-
-SELECT example_id, reference_status, reference_kind, target_type, object_role,
-       source_case_id, source_type
-  FROM sg_qa_vector_example
- WHERE source_type = 'POLICY_TEMPLATE'
-   AND source_case_id = 'MULTI_COMMON_FACT_LEFT_JOIN';

database/adb/91_sgmp_remove_over_specific_no_target_template.sql

@@ -1,13 +0,0 @@
--- Retire the overly specific no-target template. The profile and table
--- metadata carry this general scope policy without a case-shaped example.
-
-DELETE FROM sg_qa_vector_example
- WHERE source_type = 'POLICY_TEMPLATE'
-   AND source_case_id = 'NO_ELIGIBLE_FACT_TARGET';
-
-COMMIT;
-
-SELECT COUNT(*) AS remaining_template_count
-  FROM sg_qa_vector_example
- WHERE source_type = 'POLICY_TEMPLATE'
-   AND source_case_id = 'NO_ELIGIBLE_FACT_TARGET';

database/adb/92_sgmp_transaction_detail_fewshot_template.sql

@@ -1,70 +0,0 @@
--- Generic Few-shot structure for a filtered transaction/order detail request.
--- It fixes the output grain through an approved object pattern, not a global
--- instruction or a customer-specific answer.
-
-DECLARE
-  v_input     CLOB;
-  v_embedding VECTOR;
-  v_exists    NUMBER;
-BEGIN
-  v_input := TO_CLOB('Question pattern: List individual payment orders that match a business date and an amount condition.')
-    || CHR(10) || 'Logical object role: SALES_TRANSACTION'
-    || CHR(10) || 'Required output: transaction identifiers, game, user, payment timestamp, and payment amount.';
-  v_embedding := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    v_input,
-    JSON(sg_qa_vector_params('search_document'))
-  );
-
-  SELECT COUNT(*)
-    INTO v_exists
-    FROM sg_qa_vector_example
-   WHERE source_type = 'POLICY_TEMPLATE'
-     AND source_case_id = 'FILTERED_TRANSACTION_DETAIL';
-
-  IF v_exists = 0 THEN
-    INSERT INTO sg_qa_vector_example (
-      question, answer_sql, answer_text, embedding_input, embedding, embedding_model,
-      reference_status, reference_kind, target_type, object_role,
-      inspection_status, inspection_note, verified_at, verified_by,
-      source_case_id, source_type
-    ) VALUES (
-      'List payment orders matching a date and amount condition.',
-      TO_CLOB('SELECT t."PAYMT_TRANSAC_ID" AS "PAYMENT_TRANSACTION_ID",' || CHR(10)
-        || '       t."PAYMT_TRANSAC_DTL_ID" AS "PAYMENT_TRANSACTION_DETAIL_ID",' || CHR(10)
-        || '       t."GAME_ID" AS "GAME_ID",' || CHR(10)
-        || '       t."GUID" AS "USER_ID",' || CHR(10)
-        || '       t."PAYMT_DTM" AS "PAYMENT_DATETIME",' || CHR(10)
-        || '       t."PAYMT_AMT" AS "PAYMENT_AMOUNT"' || CHR(10)
-        || 'FROM "SGMP_POC"."COMN_SALES_TXN" t' || CHR(10)
-        || 'WHERE t."PAYMT_DTM" >= <BUSINESS_DATE_START>' || CHR(10)
-        || '  AND t."PAYMT_DTM" < <BUSINESS_DATE_END>' || CHR(10)
-        || '  AND CAST(t."PAYMT_AMT" AS NUMBER) <AMOUNT_CONDITION>' || CHR(10)
-        || '  AND t."EXPT_USER_YN" = ''N''' || CHR(10)
-        || 'ORDER BY t."PAYMT_DTM", t."PAYMT_TRANSAC_ID", t."PAYMT_TRANSAC_DTL_ID"'),
-      'Structural Few-shot only. Replace placeholders using the original request and approved metadata. Use the business payment timestamp for a payment-date condition. This pattern is for individual transaction detail; do not substitute an aggregate-only result for a requested order list.',
-      v_input,
-      v_embedding,
-      'cohere.embed-v4.0',
-      'APPROVED', 'SQL_TEMPLATE', 'NONE', 'SALES_TRANSACTION',
-      'VERIFIED',
-      'Generic transaction-detail output shape with no customer date, amount, game, or result value; not an executable answer key.',
-      SYSTIMESTAMP, 'SGMP_POC_METADATA_REVIEW',
-      'FILTERED_TRANSACTION_DETAIL', 'POLICY_TEMPLATE'
-    );
-  ELSE
-    UPDATE sg_qa_vector_example
-       SET embedding_input = v_input,
-           embedding = v_embedding,
-           verified_at = SYSTIMESTAMP,
-           verified_by = 'SGMP_POC_METADATA_REVIEW'
-     WHERE source_type = 'POLICY_TEMPLATE'
-       AND source_case_id = 'FILTERED_TRANSACTION_DETAIL';
-  END IF;
-  COMMIT;
-END;
-/
-
-SELECT example_id, reference_status, target_type, object_role, source_case_id
-  FROM sg_qa_vector_example
- WHERE source_type = 'POLICY_TEMPLATE'
-   AND source_case_id = 'FILTERED_TRANSACTION_DETAIL';

database/adb/93_sgmp_std18_transaction_detail_expectation.sql

@@ -1,57 +0,0 @@
--- Customer question wording requests individual orders. Align the benchmark
--- with the transaction-detail output pattern rather than forcing KPI summary.
-
-UPDATE sg_ai_qa_question
-   SET expected_focus = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           'Q09NTl9TQUxFU19UWE7sl5DshJwgUEFZTVRfRFRNIOq4sOykgOydvCwgUEFZTVRfQU1UID4gMTAwMDAsIEVYUFRfVVNFUl9ZTj0nTicg7KGw6rG07J2YIOqwnOuzhCDso7zrrLgg7IOB7IS466W8IOyhsO2ajO2VnOuLpC4g7KO866y4IOyLneuzhOyekCwg6rKM7J6ELCDsgqzsmqnsnpAsIOqysOygnCDsnbzsi5zsmYAg6riI7JWh7J2EIOygnOqzte2VnOuLpC4='
-         )),
-         'AL32UTF8'
-       ),
-       baseline_sql = TO_CLOB('SELECT s."PAYMT_TRANSAC_ID" AS "PAYMENT_TRANSACTION_ID",' || CHR(10)
-         || '       s."PAYMT_TRANSAC_DTL_ID" AS "PAYMENT_TRANSACTION_DETAIL_ID",' || CHR(10)
-         || '       s."GAME_ID" AS "GAME_ID",' || CHR(10)
-         || '       s."GUID" AS "USER_ID",' || CHR(10)
-         || '       s."PAYMT_DTM" AS "PAYMENT_DATETIME",' || CHR(10)
-         || '       s."PAYMT_AMT" AS "PAYMENT_AMOUNT"' || CHR(10)
-         || 'FROM "SGMP_POC"."COMN_SALES_TXN" s' || CHR(10)
-         || 'WHERE s."PAYMT_DTM" >= DATE ''2026-07-15''' || CHR(10)
-         || '  AND s."PAYMT_DTM" < DATE ''2026-07-16''' || CHR(10)
-         || '  AND CAST(s."PAYMT_AMT" AS NUMBER) > 10000' || CHR(10)
-         || '  AND s."EXPT_USER_YN" = ''N''' || CHR(10)
-         || 'ORDER BY s."PAYMT_DTM", s."PAYMT_TRANSAC_ID", s."PAYMT_TRANSAC_DTL_ID"'),
-       baseline_answer = utl_i18n.raw_to_char(
-         utl_encode.base64_decode(utl_raw.cast_to_raw(
-           '6rKw7KCc6riI7JWhIDHrp4zsm5Ag7LSI6rO8IOyjvOusuCA26rG07J2EIOyjvOusuCDsi53rs4TsnpAsIOqyjOyehCwg7IKs7Jqp7J6QLCDqsrDsoJwg7J287IucLCDqsrDsoJzquIjslaHqs7wg7ZWo6ruYIOuwmO2ZmO2VnOuLpC4='
-         )),
-         'AL32UTF8'
-       )
- WHERE question_code = 'STD-18';
-
-UPDATE sg_qa_vector_example
-   SET answer_sql = TO_CLOB('SELECT s."PAYMT_TRANSAC_ID" AS "PAYMENT_TRANSACTION_ID",' || CHR(10)
-         || '       s."PAYMT_TRANSAC_DTL_ID" AS "PAYMENT_TRANSACTION_DETAIL_ID",' || CHR(10)
-         || '       s."GAME_ID" AS "GAME_ID",' || CHR(10)
-         || '       s."GUID" AS "USER_ID",' || CHR(10)
-         || '       s."PAYMT_DTM" AS "PAYMENT_DATETIME",' || CHR(10)
-         || '       s."PAYMT_AMT" AS "PAYMENT_AMOUNT"' || CHR(10)
-         || 'FROM "SGMP_POC"."COMN_SALES_TXN" s' || CHR(10)
-         || 'WHERE s."PAYMT_DTM" >= DATE ''2026-07-15''' || CHR(10)
-         || '  AND s."PAYMT_DTM" < DATE ''2026-07-16''' || CHR(10)
-         || '  AND CAST(s."PAYMT_AMT" AS NUMBER) > 10000' || CHR(10)
-         || '  AND s."EXPT_USER_YN" = ''N''' || CHR(10)
-         || 'ORDER BY s."PAYMT_DTM", s."PAYMT_TRANSAC_ID", s."PAYMT_TRANSAC_DTL_ID"'),
-       answer_text = 'Approved customer Few-shot: return individual qualifying payment orders with transaction identifiers, game, user, payment timestamp, and payment amount. Use PAYMT_DTM for the payment business date.',
-       reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Customer benchmark aligned to detailed qualifying orders and the payment business timestamp.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-18';
-
-COMMIT;
-
-SELECT question_code, expected_focus, baseline_answer
-  FROM sg_ai_qa_question
- WHERE question_code = 'STD-18';

database/adb/94_sgmp_std21_country_continuous_fewshot.sql

@@ -1,19 +0,0 @@
--- Customer benchmark evidence is retained for evaluation only. It is not a
--- runtime Few-shot because the vector store must not become a collection of
--- case-specific benchmark overrides.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'RETIRED',
-       inspection_status = 'RETIRED',
-       inspection_note = 'Retired from runtime Few-shot retrieval; retained as customer QA evaluation evidence.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-21';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, source_case_id
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-21';

database/adb/95_sgmp_std22_nru_fewshot.sql

@@ -1,17 +0,0 @@
--- Promote the reviewed customer QA example for the NRU metric.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Customer QA reviewed: NRU is measured with NRU_FLAG, with the stated date and excluded-user condition.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-22';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, source_case_id
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'STD-22';

database/adb/96_sgmp_czn02_standard_au_fewshot.sql

@@ -1,17 +0,0 @@
--- Promote the reviewed customer QA example for the standard AU metric.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       inspection_note = 'Customer QA reviewed: standard AU is measured with AU_FLAG and excluded-user filtering.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-02';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, source_case_id
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-02';

database/adb/97_sgmp_exact_qa_fewshot_priority.sql

@@ -1,57 +0,0 @@
--- Prefer an exact approved customer QA question over semantically adjacent
--- vector neighbours. This is a general retrieval rule; it does not encode
--- a game, metric, table, or customer-case-specific SQL policy.
-
-CREATE OR REPLACE FUNCTION sg_qa_vector_search(
-  p_question    IN CLOB,
-  p_top_k       IN PLS_INTEGER DEFAULT 3,
-  p_target_type IN VARCHAR2 DEFAULT 'ANY'
-) RETURN SYS_REFCURSOR
-AUTHID DEFINER
-IS
-  v_query_vector VECTOR;
-  v_results      SYS_REFCURSOR;
-  v_target_type  VARCHAR2(16) := UPPER(TRIM(NVL(p_target_type, 'ANY')));
-BEGIN
-  IF p_question IS NULL THEN
-    RAISE_APPLICATION_ERROR(-20003, 'question is required.');
-  END IF;
-  IF p_top_k IS NULL OR p_top_k < 1 OR p_top_k > 20 THEN
-    RAISE_APPLICATION_ERROR(-20004, 'top_k must be between 1 and 20.');
-  END IF;
-  IF v_target_type NOT IN ('NONE', 'SINGLE', 'MULTI', 'ALL', 'ANY') THEN
-    RAISE_APPLICATION_ERROR(-20005, 'target_type must be NONE, SINGLE, MULTI, ALL, or ANY.');
-  END IF;
-
-  v_query_vector := DBMS_VECTOR.UTL_TO_EMBEDDING(
-    p_question,
-    JSON(sg_qa_vector_params('search_query'))
-  );
-
-  OPEN v_results FOR
-    SELECT example_id,
-           question,
-           answer_sql,
-           answer_text,
-           embedding_model,
-           reference_kind,
-           target_type,
-           object_role,
-           source_case_id,
-           source_type,
-           vector_distance(embedding, v_query_vector, COSINE) AS cosine_distance
-      FROM sg_qa_vector_example
-     WHERE reference_status = 'APPROVED'
-       AND (target_type = 'ANY' OR v_target_type = 'ANY' OR target_type = v_target_type)
-     ORDER BY CASE
-                WHEN DBMS_LOB.COMPARE(
-                    LOWER(TRIM(question)), LOWER(TRIM(p_question))
-                ) = 0 THEN 0
-                ELSE 1
-              END,
-              vector_distance(embedding, v_query_vector, COSINE),
-              example_id
-     FETCH FIRST p_top_k ROWS ONLY;
-  RETURN v_results;
-END;
-/

database/adb/98_sgmp_czn02_standard_au_semantics.sql

@@ -1,20 +0,0 @@
--- Strengthen the approved customer QA example itself.  The wording belongs
--- to the benchmark Few-shot record, not to a global Select AI profile rule.
-
-UPDATE sg_qa_vector_example
-   SET answer_text = 'Expected focus: CZN_COMN_USER_MST, BASE_DT=2026-07-15, AU_FLAG=1, EXPT_USER_YN=''N''. '
-                   || 'The phrase standard AU is the report metric label; do not add STD_USER_YN unless the question separately asks for the standard-user cohort. '
-                   || 'Historical answer: STD_AU_COUNT=0',
-       inspection_note = 'Customer QA verified: standard AU uses the AU flag and excluded-user filtering; standard-user cohort is a separate request.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-02'
-   AND reference_status = 'APPROVED';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, answer_text
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-02';

database/adb/99_sgmp_czn03_standard_business_au_fewshot.sql

@@ -1,23 +0,0 @@
--- Approve the reviewed customer QA comparison example.  Metric definitions
--- stay in the exact Few-shot example rather than becoming global profile text.
-
-UPDATE sg_qa_vector_example
-   SET reference_status = 'APPROVED',
-       inspection_status = 'VERIFIED',
-       answer_text = 'Expected focus: compare two independently aggregated metrics for the same resolved game and date. '
-                   || 'Standard AU: CZN_COMN_USER_MST with AU_FLAG=1 and EXPT_USER_YN=''N''. '
-                   || 'Business AU: CZN_CUSTOM_BIZ_USER_TXN with BIZ_AU_FLAG=1 and EXPT_USER_YN=''N''. '
-                   || 'The labels standard AU and business AU do not imply STD_USER_YN. '
-                   || 'Historical answer: STD_AU_COUNT=0, BIZ_AU_COUNT=1.',
-       inspection_note = 'Customer QA verified: standard and business AU are separate aggregates with their respective AU flags.',
-       verified_at = SYSTIMESTAMP,
-       verified_by = 'SGMP_POC_METADATA_REVIEW'
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-03';
-
-COMMIT;
-
-SELECT example_id, reference_status, inspection_status, source_case_id, answer_text
-  FROM sg_qa_vector_example
- WHERE source_type = 'CUSTOMER_QA_BENCHMARK'
-   AND source_case_id = 'CZN-03';

database/source/postgres_hmm_carrier_performance.sql

@@ -1,300 +0,0 @@
--- ============================================================
--- HMM demo carrier performance source data for PostgreSQL.
---
--- Target: AWS RDS for PostgreSQL, database postgres
--- Schema: hmm_demo
--- Redmine: #729
---
--- This script is idempotent. It owns only C001..C008 and their
--- 2025-02 through 2026-07 monthly demo rows. It never stores an
--- RDS endpoint, password, or certificate path.
---
--- Example:
---   PGPASSWORD="$PG_PASSWORD" psql \
---     "host=$PG_HOST port=5432 dbname=postgres user=$PG_USER \
---      sslmode=verify-full sslrootcert=$PG_SSL_ROOT_CERT" \
---     -X -f database/source/postgres_hmm_carrier_performance.sql
--- ============================================================
-
-\set ON_ERROR_STOP on
-\echo === HMM carrier performance demo: begin ===
-
-BEGIN;
-
-CREATE SCHEMA IF NOT EXISTS hmm_demo AUTHORIZATION postgres;
-COMMENT ON SCHEMA hmm_demo IS
-  'HMM federation demonstration data. All carrier names and KPI values are fictional.';
-
-REVOKE CREATE ON SCHEMA hmm_demo FROM PUBLIC;
-
-CREATE TABLE IF NOT EXISTS hmm_demo.carriers (
-  carrier_code       VARCHAR(10)  PRIMARY KEY,
-  carrier_name       VARCHAR(120) NOT NULL UNIQUE,
-  country_code       CHAR(2)      NOT NULL CHECK (country_code ~ '^[A-Z]{2}$'),
-  alliance_name      VARCHAR(80),
-  service_region     VARCHAR(40)  NOT NULL,
-  performance_tier  VARCHAR(10)  NOT NULL
-      CHECK (performance_tier IN ('CORE', 'GROWTH', 'WATCH')),
-  active             BOOLEAN      NOT NULL DEFAULT TRUE,
-  created_at         TIMESTAMPTZ  NOT NULL DEFAULT CURRENT_TIMESTAMP
-);
-
-COMMENT ON TABLE hmm_demo.carriers IS
-  'Fictional carrier master data for the HMM ADB and PostgreSQL federation demo.';
-COMMENT ON COLUMN hmm_demo.carriers.carrier_code IS 'Fictional carrier identifier.';
-COMMENT ON COLUMN hmm_demo.carriers.performance_tier IS
-  'Demo portfolio tier: CORE, GROWTH, or WATCH.';
-
-CREATE TABLE IF NOT EXISTS hmm_demo.carrier_monthly_performance (
-  carrier_code              VARCHAR(10)   NOT NULL
-      REFERENCES hmm_demo.carriers (carrier_code),
-  performance_month         DATE          NOT NULL
-      CHECK (performance_month = date_trunc('month', performance_month)::DATE),
-  contracted_teu            INTEGER       NOT NULL CHECK (contracted_teu >= 0),
-  shipped_teu               INTEGER       NOT NULL CHECK (shipped_teu >= 0),
-  revenue_usd               NUMERIC(16,2) NOT NULL CHECK (revenue_usd >= 0),
-  gross_margin_usd          NUMERIC(16,2) NOT NULL,
-  schedule_reliability_pct  NUMERIC(5,2)  NOT NULL
-      CHECK (schedule_reliability_pct BETWEEN 0 AND 100),
-  vessel_utilization_pct    NUMERIC(5,2)  NOT NULL
-      CHECK (vessel_utilization_pct BETWEEN 0 AND 100),
-  claim_rate_pct            NUMERIC(5,2)  NOT NULL
-      CHECK (claim_rate_pct BETWEEN 0 AND 100),
-  yoy_growth_pct            NUMERIC(7,2)  NOT NULL,
-  risk_level                VARCHAR(10)   NOT NULL
-      CHECK (risk_level IN ('GREEN', 'AMBER', 'RED')),
-  updated_at                TIMESTAMPTZ   NOT NULL,
-  PRIMARY KEY (carrier_code, performance_month)
-);
-
-COMMENT ON TABLE hmm_demo.carrier_monthly_performance IS
-  'Deterministic fictional monthly carrier KPIs for 2025-02 through 2026-07.';
-COMMENT ON COLUMN hmm_demo.carrier_monthly_performance.performance_month IS
-  'First calendar day of the KPI month.';
-COMMENT ON COLUMN hmm_demo.carrier_monthly_performance.risk_level IS
-  'Derived demo risk level based on margin, reliability, and claim rate.';
-
-CREATE INDEX IF NOT EXISTS ix_carrier_perf_month
-  ON hmm_demo.carrier_monthly_performance (performance_month, carrier_code);
-CREATE INDEX IF NOT EXISTS ix_carrier_perf_risk
-  ON hmm_demo.carrier_monthly_performance (risk_level, performance_month);
-
-INSERT INTO hmm_demo.carriers (
-  carrier_code,
-  carrier_name,
-  country_code,
-  alliance_name,
-  service_region,
-  performance_tier,
-  active
-) VALUES
-  ('C001', 'Bluewave Maritime',       'SG', 'North Pacific Network', 'ASIA-PACIFIC', 'CORE',   TRUE),
-  ('C002', 'Pacific Star Lines',      'JP', 'East Ocean Connect',    'ASIA-PACIFIC', 'CORE',   TRUE),
-  ('C003', 'Korea Ocean Link',        'KR', 'East Ocean Connect',    'ASIA-PACIFIC', 'GROWTH', TRUE),
-  ('C004', 'Nordic Seaways',          'DK', 'Northern Trade Group',  'EUROPE',       'CORE',   TRUE),
-  ('C005', 'Orient Bridge Shipping',  'TW', 'North Pacific Network', 'ASIA-PACIFIC', 'WATCH',  TRUE),
-  ('C006', 'Atlantic Merchant Line',  'DE', 'Atlantic Cargo Forum',  'EUROPE-AMERICAS', 'WATCH', TRUE),
-  ('C007', 'Global Horizon Cargo',    'US', 'Atlantic Cargo Forum',  'AMERICAS',     'GROWTH', TRUE),
-  ('C008', 'Southern Cross Marine',   'FR', 'Southern Ocean Group',  'OCEANIA',      'WATCH',  TRUE)
-ON CONFLICT (carrier_code) DO UPDATE SET
-  carrier_name      = EXCLUDED.carrier_name,
-  country_code      = EXCLUDED.country_code,
-  alliance_name     = EXCLUDED.alliance_name,
-  service_region    = EXCLUDED.service_region,
-  performance_tier = EXCLUDED.performance_tier,
-  active            = EXCLUDED.active;
-
-WITH month_series AS (
-  SELECT
-    month_index,
-    (DATE '2025-02-01' + make_interval(months => month_index))::DATE AS performance_month,
-    CASE month_index % 6
-      WHEN 0 THEN -1
-      WHEN 1 THEN 0
-      WHEN 2 THEN 1
-      WHEN 3 THEN 2
-      WHEN 4 THEN 1
-      ELSE -1
-    END::NUMERIC AS seasonal_factor
-  FROM generate_series(0, 17) AS series(month_index)
-),
-profiles (
-  carrier_code,
-  base_teu,
-  monthly_teu_step,
-  seasonal_teu,
-  utilization_base,
-  utilization_step,
-  revenue_per_teu,
-  revenue_step,
-  margin_pct_base,
-  margin_pct_step,
-  reliability_base,
-  reliability_step,
-  claim_rate_base,
-  claim_rate_step,
-  yoy_growth_base,
-  yoy_growth_step
-) AS (
-  VALUES
-    ('C001', 1800::NUMERIC,  25::NUMERIC,  80::NUMERIC, 91.5::NUMERIC,  0.10::NUMERIC, 1850::NUMERIC,  4::NUMERIC, 15.0::NUMERIC,  0.10::NUMERIC, 95.0::NUMERIC,  0.05::NUMERIC, 0.35::NUMERIC, -0.005::NUMERIC,  8.0::NUMERIC,  0.25::NUMERIC),
-    ('C002', 1500::NUMERIC,   5::NUMERIC,  60::NUMERIC, 88.5::NUMERIC,  0.02::NUMERIC, 1780::NUMERIC,  3::NUMERIC, 12.0::NUMERIC,  0.00::NUMERIC, 92.5::NUMERIC,  0.00::NUMERIC, 0.45::NUMERIC,  0.005::NUMERIC,  3.0::NUMERIC,  0.05::NUMERIC),
-    ('C003', 1050::NUMERIC,  15::NUMERIC,  50::NUMERIC, 83.0::NUMERIC,  0.20::NUMERIC, 1920::NUMERIC,  2::NUMERIC,  8.0::NUMERIC,  0.15::NUMERIC, 88.5::NUMERIC,  0.25::NUMERIC, 1.20::NUMERIC, -0.040::NUMERIC, -4.0::NUMERIC,  0.60::NUMERIC),
-    ('C004', 1350::NUMERIC,   0::NUMERIC, 180::NUMERIC, 86.0::NUMERIC,  0.00::NUMERIC, 1810::NUMERIC,  3::NUMERIC, 10.0::NUMERIC,  0.00::NUMERIC, 93.0::NUMERIC,  0.00::NUMERIC, 0.55::NUMERIC,  0.010::NUMERIC,  1.0::NUMERIC,  0.10::NUMERIC),
-    ('C005', 1300::NUMERIC, -20::NUMERIC,  70::NUMERIC, 88.0::NUMERIC, -0.10::NUMERIC, 1850::NUMERIC, -2::NUMERIC,  8.0::NUMERIC, -0.20::NUMERIC, 91.0::NUMERIC, -0.15::NUMERIC, 0.80::NUMERIC,  0.030::NUMERIC, -2.0::NUMERIC, -0.50::NUMERIC),
-    ('C006', 1250::NUMERIC, -10::NUMERIC,  90::NUMERIC, 84.0::NUMERIC, -0.12::NUMERIC, 1800::NUMERIC, -3::NUMERIC,  6.0::NUMERIC, -0.15::NUMERIC, 87.0::NUMERIC, -0.25::NUMERIC, 1.50::NUMERIC,  0.050::NUMERIC, -5.0::NUMERIC, -0.70::NUMERIC),
-    ('C007',  800::NUMERIC,  30::NUMERIC, 100::NUMERIC, 82.0::NUMERIC,  0.25::NUMERIC, 2050::NUMERIC,  5::NUMERIC,  9.0::NUMERIC,  0.18::NUMERIC, 90.5::NUMERIC,  0.15::NUMERIC, 0.70::NUMERIC, -0.020::NUMERIC, 12.0::NUMERIC,  0.50::NUMERIC),
-    ('C008', 1150::NUMERIC, -25::NUMERIC,  60::NUMERIC, 80.0::NUMERIC, -0.15::NUMERIC, 1750::NUMERIC, -4::NUMERIC,  3.0::NUMERIC, -0.20::NUMERIC, 85.0::NUMERIC, -0.30::NUMERIC, 2.00::NUMERIC,  0.080::NUMERIC, -8.0::NUMERIC, -0.80::NUMERIC)
-),
-base_metrics AS (
-  SELECT
-    p.carrier_code,
-    m.performance_month,
-    ROUND(
-      p.base_teu
-      + p.monthly_teu_step * m.month_index
-      + p.seasonal_teu * m.seasonal_factor
-    )::INTEGER AS contracted_teu,
-    LEAST(
-      98.0::NUMERIC,
-      GREATEST(
-        60.0::NUMERIC,
-        p.utilization_base
-        + p.utilization_step * m.month_index
-        + m.seasonal_factor * 0.50
-      )
-    ) AS utilization_pct,
-    p.revenue_per_teu + p.revenue_step * m.month_index AS unit_revenue,
-    p.margin_pct_base + p.margin_pct_step * m.month_index AS margin_pct,
-    LEAST(
-      99.5::NUMERIC,
-      GREATEST(
-        60.0::NUMERIC,
-        p.reliability_base
-        + p.reliability_step * m.month_index
-        + m.seasonal_factor * 0.20
-      )
-    ) AS reliability_pct,
-    LEAST(
-      100.0::NUMERIC,
-      GREATEST(
-        0.0::NUMERIC,
-        p.claim_rate_base + p.claim_rate_step * m.month_index
-      )
-    ) AS claim_pct,
-    p.yoy_growth_base + p.yoy_growth_step * m.month_index AS yoy_pct
-  FROM profiles p
-  CROSS JOIN month_series m
-),
-volume_metrics AS (
-  SELECT
-    b.*,
-    ROUND(b.contracted_teu * b.utilization_pct / 100.0)::INTEGER AS shipped_teu
-  FROM base_metrics b
-),
-financial_metrics AS (
-  SELECT
-    v.*,
-    ROUND(v.shipped_teu * v.unit_revenue, 2) AS revenue_usd
-  FROM volume_metrics v
-),
-final_metrics AS (
-  SELECT
-    f.*,
-    ROUND(f.revenue_usd * f.margin_pct / 100.0, 2) AS gross_margin_usd
-  FROM financial_metrics f
-)
-INSERT INTO hmm_demo.carrier_monthly_performance (
-  carrier_code,
-  performance_month,
-  contracted_teu,
-  shipped_teu,
-  revenue_usd,
-  gross_margin_usd,
-  schedule_reliability_pct,
-  vessel_utilization_pct,
-  claim_rate_pct,
-  yoy_growth_pct,
-  risk_level,
-  updated_at
-)
-SELECT
-  f.carrier_code,
-  f.performance_month,
-  f.contracted_teu,
-  f.shipped_teu,
-  f.revenue_usd,
-  f.gross_margin_usd,
-  ROUND(f.reliability_pct, 2),
-  ROUND(f.utilization_pct, 2),
-  ROUND(f.claim_pct, 2),
-  ROUND(f.yoy_pct, 2),
-  CASE
-    WHEN f.gross_margin_usd < 0
-      OR f.reliability_pct < 87
-      OR f.claim_pct >= 2 THEN 'RED'
-    WHEN f.margin_pct < 7
-      OR f.reliability_pct < 92
-      OR f.claim_pct >= 1 THEN 'AMBER'
-    ELSE 'GREEN'
-  END,
-  TIMESTAMPTZ '2026-07-24 00:00:00+00'
-FROM final_metrics f
-ON CONFLICT (carrier_code, performance_month) DO UPDATE SET
-  contracted_teu           = EXCLUDED.contracted_teu,
-  shipped_teu              = EXCLUDED.shipped_teu,
-  revenue_usd              = EXCLUDED.revenue_usd,
-  gross_margin_usd         = EXCLUDED.gross_margin_usd,
-  schedule_reliability_pct = EXCLUDED.schedule_reliability_pct,
-  vessel_utilization_pct   = EXCLUDED.vessel_utilization_pct,
-  claim_rate_pct           = EXCLUDED.claim_rate_pct,
-  yoy_growth_pct           = EXCLUDED.yoy_growth_pct,
-  risk_level               = EXCLUDED.risk_level,
-  updated_at               = EXCLUDED.updated_at;
-
-CREATE OR REPLACE VIEW hmm_demo.carrier_performance_latest_v AS
-SELECT
-  c.carrier_code,
-  c.carrier_name,
-  c.country_code,
-  c.alliance_name,
-  c.service_region,
-  c.performance_tier,
-  p.performance_month,
-  p.contracted_teu,
-  p.shipped_teu,
-  p.revenue_usd,
-  p.gross_margin_usd,
-  p.schedule_reliability_pct,
-  p.vessel_utilization_pct,
-  p.claim_rate_pct,
-  p.yoy_growth_pct,
-  p.risk_level
-FROM hmm_demo.carriers c
-JOIN hmm_demo.carrier_monthly_performance p
-  ON p.carrier_code = c.carrier_code
-WHERE p.performance_month = (
-  SELECT MAX(latest.performance_month)
-  FROM hmm_demo.carrier_monthly_performance latest
-);
-
-COMMENT ON VIEW hmm_demo.carrier_performance_latest_v IS
-  'Latest fictional monthly KPI for each active demo carrier.';
-
-DO $role$
-BEGIN
-  IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'hmm_federation_reader') THEN
-    CREATE ROLE hmm_federation_reader NOLOGIN;
-  END IF;
-END
-$role$;
-
-GRANT USAGE ON SCHEMA hmm_demo TO hmm_federation_reader;
-GRANT SELECT ON ALL TABLES IN SCHEMA hmm_demo TO hmm_federation_reader;
-ALTER DEFAULT PRIVILEGES IN SCHEMA hmm_demo
-  GRANT SELECT ON TABLES TO hmm_federation_reader;
-
-COMMIT;
-
-\echo === HMM carrier performance demo: complete ===
-\echo Next: run database/source/postgres_hmm_carrier_performance_verify.sql

database/source/postgres_hmm_carrier_performance_verify.sql

@@ -1,324 +0,0 @@
--- ============================================================
--- Verification for HMM demo carrier performance data.
--- Redmine: #729
--- ============================================================
-
-\set ON_ERROR_STOP on
-\pset pager off
-\echo === HMM carrier performance demo: verification begin ===
-
-DO $verify$
-DECLARE
-  carrier_count       INTEGER;
-  performance_count   INTEGER;
-  invalid_month_count INTEGER;
-  latest_month        DATE;
-  earliest_month      DATE;
-  wrong_series_count  INTEGER;
-  latest_risk_count   INTEGER;
-  wrong_trend_count   INTEGER;
-  reader_can_login    BOOLEAN;
-BEGIN
-  SELECT COUNT(*)
-    INTO carrier_count
-    FROM hmm_demo.carriers
-   WHERE carrier_code BETWEEN 'C001' AND 'C008';
-
-  SELECT COUNT(*), MIN(performance_month), MAX(performance_month)
-    INTO performance_count, earliest_month, latest_month
-    FROM hmm_demo.carrier_monthly_performance
-   WHERE carrier_code BETWEEN 'C001' AND 'C008'
-     AND performance_month BETWEEN DATE '2025-02-01' AND DATE '2026-07-01';
-
-  SELECT COUNT(*)
-    INTO invalid_month_count
-    FROM hmm_demo.carrier_monthly_performance
-   WHERE performance_month <> date_trunc('month', performance_month)::DATE;
-
-  SELECT COUNT(*)
-    INTO wrong_series_count
-    FROM (
-      SELECT carrier_code, COUNT(*) AS month_count
-        FROM hmm_demo.carrier_monthly_performance
-       WHERE carrier_code BETWEEN 'C001' AND 'C008'
-         AND performance_month BETWEEN DATE '2025-02-01' AND DATE '2026-07-01'
-       GROUP BY carrier_code
-      HAVING COUNT(*) <> 18
-    ) wrong_series;
-
-  SELECT COUNT(DISTINCT risk_level)
-    INTO latest_risk_count
-    FROM hmm_demo.carrier_performance_latest_v;
-
-  WITH boundaries AS (
-    SELECT
-      carrier_code,
-      MAX(revenue_usd) FILTER (WHERE performance_month = DATE '2025-02-01')
-        AS first_revenue,
-      MAX(revenue_usd) FILTER (WHERE performance_month = DATE '2026-07-01')
-        AS latest_revenue
-    FROM hmm_demo.carrier_monthly_performance
-    WHERE carrier_code BETWEEN 'C001' AND 'C008'
-    GROUP BY carrier_code
-  )
-  SELECT COUNT(*)
-    INTO wrong_trend_count
-    FROM boundaries
-   WHERE (carrier_code IN ('C001', 'C002', 'C003', 'C004', 'C007')
-          AND latest_revenue <= first_revenue)
-      OR (carrier_code IN ('C005', 'C006', 'C008')
-          AND latest_revenue >= first_revenue);
-
-  SELECT rolcanlogin
-    INTO reader_can_login
-    FROM pg_roles
-   WHERE rolname = 'hmm_federation_reader';
-
-  IF carrier_count <> 8 THEN
-    RAISE EXCEPTION 'Expected 8 carriers, found %', carrier_count;
-  END IF;
-  IF performance_count <> 144 THEN
-    RAISE EXCEPTION 'Expected 144 monthly performance rows, found %', performance_count;
-  END IF;
-  IF earliest_month <> DATE '2025-02-01' OR latest_month <> DATE '2026-07-01' THEN
-    RAISE EXCEPTION 'Unexpected period: % through %', earliest_month, latest_month;
-  END IF;
-  IF invalid_month_count <> 0 OR wrong_series_count <> 0 THEN
-    RAISE EXCEPTION
-      'Invalid monthly series: invalid dates %, wrong carrier series %',
-      invalid_month_count,
-      wrong_series_count;
-  END IF;
-  IF latest_risk_count <> 3 THEN
-    RAISE EXCEPTION 'Expected GREEN, AMBER, RED latest risks, found % levels',
-      latest_risk_count;
-  END IF;
-  IF wrong_trend_count <> 0 THEN
-    RAISE EXCEPTION 'Unexpected first-to-latest trend for % carriers', wrong_trend_count;
-  END IF;
-  IF reader_can_login IS DISTINCT FROM FALSE THEN
-    RAISE EXCEPTION 'hmm_federation_reader must remain a NOLOGIN role';
-  END IF;
-
-  IF NOT has_schema_privilege('hmm_federation_reader', 'hmm_demo', 'USAGE') THEN
-    RAISE EXCEPTION 'hmm_federation_reader lacks schema USAGE';
-  END IF;
-  IF has_schema_privilege('hmm_federation_reader', 'hmm_demo', 'CREATE') THEN
-    RAISE EXCEPTION 'hmm_federation_reader unexpectedly has schema CREATE';
-  END IF;
-  IF NOT has_table_privilege(
-      'hmm_federation_reader',
-      'hmm_demo.carrier_monthly_performance',
-      'SELECT'
-  ) THEN
-    RAISE EXCEPTION 'hmm_federation_reader lacks SELECT';
-  END IF;
-  IF has_table_privilege(
-      'hmm_federation_reader',
-      'hmm_demo.carrier_monthly_performance',
-      'INSERT'
-  ) THEN
-    RAISE EXCEPTION 'hmm_federation_reader unexpectedly has INSERT';
-  END IF;
-END
-$verify$;
-
-DO $constraint_tests$
-BEGIN
-  BEGIN
-    INSERT INTO hmm_demo.carrier_monthly_performance (
-      carrier_code,
-      performance_month,
-      contracted_teu,
-      shipped_teu,
-      revenue_usd,
-      gross_margin_usd,
-      schedule_reliability_pct,
-      vessel_utilization_pct,
-      claim_rate_pct,
-      yoy_growth_pct,
-      risk_level,
-      updated_at
-    ) VALUES (
-      'C001',
-      DATE '2026-07-02',
-      1,
-      1,
-      1,
-      1,
-      90,
-      90,
-      1,
-      1,
-      'GREEN',
-      CURRENT_TIMESTAMP
-    );
-    RAISE EXCEPTION 'Month-first-day constraint did not reject invalid input';
-  EXCEPTION
-    WHEN check_violation THEN
-      NULL;
-  END;
-
-  BEGIN
-    INSERT INTO hmm_demo.carrier_monthly_performance (
-      carrier_code,
-      performance_month,
-      contracted_teu,
-      shipped_teu,
-      revenue_usd,
-      gross_margin_usd,
-      schedule_reliability_pct,
-      vessel_utilization_pct,
-      claim_rate_pct,
-      yoy_growth_pct,
-      risk_level,
-      updated_at
-    ) VALUES (
-      'UNKNOWN',
-      DATE '2026-08-01',
-      1,
-      1,
-      1,
-      1,
-      90,
-      90,
-      1,
-      1,
-      'GREEN',
-      CURRENT_TIMESTAMP
-    );
-    RAISE EXCEPTION 'Foreign key constraint did not reject unknown carrier';
-  EXCEPTION
-    WHEN foreign_key_violation THEN
-      NULL;
-  END;
-
-  BEGIN
-    INSERT INTO hmm_demo.carrier_monthly_performance (
-      carrier_code,
-      performance_month,
-      contracted_teu,
-      shipped_teu,
-      revenue_usd,
-      gross_margin_usd,
-      schedule_reliability_pct,
-      vessel_utilization_pct,
-      claim_rate_pct,
-      yoy_growth_pct,
-      risk_level,
-      updated_at
-    ) VALUES (
-      'C001',
-      DATE '2026-08-01',
-      1,
-      1,
-      1,
-      1,
-      101,
-      90,
-      1,
-      1,
-      'GREEN',
-      CURRENT_TIMESTAMP
-    );
-    RAISE EXCEPTION 'Percentage constraint did not reject invalid input';
-  EXCEPTION
-    WHEN check_violation THEN
-      NULL;
-  END;
-END
-$constraint_tests$;
-
-\echo --- Row counts and period ---
-SELECT
-  COUNT(DISTINCT carrier_code) AS carrier_count,
-  COUNT(*) AS monthly_row_count,
-  MIN(performance_month) AS first_month,
-  MAX(performance_month) AS latest_month
-FROM hmm_demo.carrier_monthly_performance
-WHERE carrier_code BETWEEN 'C001' AND 'C008'
-  AND performance_month BETWEEN DATE '2025-02-01' AND DATE '2026-07-01';
-
-\echo --- Per-carrier series ---
-SELECT
-  c.carrier_code,
-  c.carrier_name,
-  COUNT(p.*) AS month_count,
-  MIN(p.performance_month) AS first_month,
-  MAX(p.performance_month) AS latest_month
-FROM hmm_demo.carriers c
-JOIN hmm_demo.carrier_monthly_performance p
-  ON p.carrier_code = c.carrier_code
-WHERE c.carrier_code BETWEEN 'C001' AND 'C008'
-GROUP BY c.carrier_code, c.carrier_name
-ORDER BY c.carrier_code;
-
-\echo --- Latest KPI and risk distribution ---
-SELECT
-  carrier_code,
-  carrier_name,
-  performance_month,
-  shipped_teu,
-  revenue_usd,
-  gross_margin_usd,
-  schedule_reliability_pct,
-  claim_rate_pct,
-  risk_level
-FROM hmm_demo.carrier_performance_latest_v
-ORDER BY carrier_code;
-
-SELECT risk_level, COUNT(*) AS carrier_count
-FROM hmm_demo.carrier_performance_latest_v
-GROUP BY risk_level
-ORDER BY risk_level;
-
-\echo --- First-to-latest revenue trend ---
-WITH boundaries AS (
-  SELECT
-    carrier_code,
-    MAX(revenue_usd) FILTER (WHERE performance_month = DATE '2025-02-01') AS first_revenue,
-    MAX(revenue_usd) FILTER (WHERE performance_month = DATE '2026-07-01') AS latest_revenue
-  FROM hmm_demo.carrier_monthly_performance
-  WHERE carrier_code BETWEEN 'C001' AND 'C008'
-  GROUP BY carrier_code
-)
-SELECT
-  carrier_code,
-  first_revenue,
-  latest_revenue,
-  CASE
-    WHEN latest_revenue > first_revenue THEN 'UP'
-    WHEN latest_revenue < first_revenue THEN 'DOWN'
-    ELSE 'FLAT'
-  END AS trend
-FROM boundaries
-ORDER BY carrier_code;
-
-\echo --- TLS session ---
-SELECT
-  ssl,
-  version AS tls_version,
-  cipher,
-  bits
-FROM pg_stat_ssl
-WHERE pid = pg_backend_pid();
-
-\echo --- Read-only role privileges ---
-SELECT
-  (SELECT NOT rolcanlogin
-     FROM pg_roles
-    WHERE rolname = 'hmm_federation_reader') AS no_login,
-  has_schema_privilege('hmm_federation_reader', 'hmm_demo', 'USAGE') AS schema_usage,
-  has_schema_privilege('hmm_federation_reader', 'hmm_demo', 'CREATE') AS schema_create,
-  has_table_privilege(
-    'hmm_federation_reader',
-    'hmm_demo.carrier_monthly_performance',
-    'SELECT'
-  ) AS can_select,
-  has_table_privilege(
-    'hmm_federation_reader',
-    'hmm_demo.carrier_monthly_performance',
-    'INSERT'
-  ) AS can_insert;
-
-\echo === HMM carrier performance demo: verification complete ===

dds-backoffice/README.md

@@ -56,10 +56,10 @@ ORDS Handler가 Bearer 값을 문자열로 바꾸는 것만으로 DDS Context가
 먼저 DDS 데모 전용 로컬 데이터셋과 권한 객체를 적용합니다. 이 스크립트는 VPD VIEW나 외부 RDS DB Link를 사용하지 않습니다.
 
 ```bash
-sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @database/adb/31_dds_standalone_demo_setup.sql
-sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @database/adb/32_dds_vector_tag_setup.sql
+sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @sql/adb/31_dds_standalone_demo_setup.sql
+sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @sql/adb/32_dds_vector_tag_setup.sql
 bash scripts/setup-dds-token-data-grant.sh
-sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @database/adb/36_dds_sales_knowledge_scenario.sql
+sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @sql/adb/36_dds_sales_knowledge_scenario.sql
 ```
 
 `32_dds_vector_tag_setup.sql`은 공통 청크·태그 저장소를 읽는 DDS 전용 VIEW를 만들고, 동일한 `CB_PERMISSION`/`CB_PERMISSION_RULE`에 역할별 TAG 규칙을 등록합니다. `SPRING_BOOT`, `ORDS`, `ORACLE_VPD`, `MCP`처럼 한 역할에 여러 TAG가 있으면 `/dds-provision`이 OR 조건으로 합쳐 DDS DATA GRANT를 다시 만듭니다. 벡터 검색에 필요한 `EMBEDDING`은 DDS 엔진이 거리 계산에 사용하므로 Grant에서 제외하지 않고, 검색 응답에서는 애플리케이션이 반환하지 않습니다. 그 외 민감 컬럼은 애플리케이션 권한의 원문 허용 목록에 없으면 `ALL COLUMNS EXCEPT`로 제외됩니다. 검색 화면에서는 같은 문서를 청킹·임베딩한 뒤 선택한 END USER로 직접 조회하므로, DDS Grant가 없는 주체는 보호 VIEW 자체를 볼 수 없습니다.
@@ -68,7 +68,7 @@ sqlplus "$ADB_USER/$ADB_PASSWORD@$ADB_TNS" @database/adb/36_dds_sales_knowledge_
 
 `36_dds_sales_knowledge_scenario.sql`은 `agent_sales`와 `SALES_KNOWLEDGE_ROLE`을 만들고 `TECH_TAG=SALES`인 세일즈 청크(28004)를 추가합니다. 짧은 데모 토큰 `dds_sales_demo_token`을 사용하면 결과는 28004만 남아야 합니다. 운영에서는 이 토큰 대신 Bearer 관리 화면에서 발급한 임시 토큰을 사용합니다.
 
-토큰 경로를 제거할 때는 사용 중인 애플리케이션이 없는지 확인한 뒤 `database/adb/37_dds_sales_knowledge_scenario_cleanup.sql`과 `database/adb/35_dds_token_data_grant_cleanup.sql`을 별도로 승인해 실행합니다.
+토큰 경로를 제거할 때는 사용 중인 애플리케이션이 없는지 확인한 뒤 `sql/adb/37_dds_sales_knowledge_scenario_cleanup.sql`과 `sql/adb/35_dds_token_data_grant_cleanup.sql`을 별도로 승인해 실행합니다.
 
 그 다음 DDS 인스턴스를 실행합니다.
 

deploy/ai-web-agent-console/nginx/hmm-portal-auth.locations.conf

@@ -1,41 +0,0 @@
-location = /auth/check {
-    internal;
-    proxy_pass http://127.0.0.1:8621/auth/check;
-    proxy_pass_request_body off;
-    proxy_set_header Content-Length "";
-    proxy_set_header Cookie $http_cookie;
-    proxy_set_header X-Real-IP $remote_addr;
-}
-
-location /auth/ {
-    proxy_pass http://127.0.0.1:8621;
-    proxy_http_version 1.1;
-    proxy_set_header Host $host;
-    proxy_set_header X-Real-IP $remote_addr;
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_set_header X-Forwarded-Proto $scheme;
-}
-
-location @hmm_portal_login {
-    return 302 /auth/login;
-}
-
-location / {
-    auth_request /auth/check;
-    error_page 401 = @hmm_portal_login;
-    auth_request_set $hmm_auth_user $upstream_http_x_auth_user;
-    auth_request_set $hmm_auth_expires $upstream_http_x_auth_expires;
-
-    proxy_pass http://127.0.0.1:8622;
-    proxy_http_version 1.1;
-    proxy_set_header Host $host;
-    proxy_set_header X-Real-IP $remote_addr;
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_set_header X-Forwarded-Proto $scheme;
-    proxy_set_header X-HMM-Authenticated-User $hmm_auth_user;
-    proxy_set_header X-HMM-Auth-Expires $hmm_auth_expires;
-    proxy_set_header Upgrade $http_upgrade;
-    proxy_set_header Connection "upgrade";
-    proxy_read_timeout 300;
-    proxy_send_timeout 300;
-}

deploy/ai-web-agent-console/systemd/ai-web-agent-console-audit.conf

@@ -1,2 +0,0 @@
-[Service]
-EnvironmentFile=/etc/hmm-poc4-audit.env

deploy/ai-web-agent-console/systemd/hmm-portal-auth.service

@@ -1,29 +0,0 @@
-[Unit]
-Description=HMM Portal HttpOnly Cookie Authentication
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=opc
-Group=opc
-WorkingDirectory=/opt/hmm-poc4
-Environment=PYTHONUNBUFFERED=1
-EnvironmentFile=/opt/hmm-poc4/.env
-ExecStart=/opt/hmm-poc4/.venv/bin/python -m ai_web_agent_console.auth_gateway
-Restart=on-failure
-RestartSec=3
-NoNewPrivileges=true
-PrivateTmp=true
-ProtectSystem=strict
-ProtectHome=true
-ProtectKernelTunables=true
-ProtectKernelModules=true
-ProtectControlGroups=true
-RestrictSUIDSGID=true
-LockPersonality=true
-RestrictAddressFamilies=AF_INET AF_INET6
-UMask=0077
-
-[Install]
-WantedBy=multi-user.target

deploy/ai-web-agent-console/systemd/smilegate-poc4-auth.service

@@ -1,20 +0,0 @@
-[Unit]
-Description=Smilegate PoC4 Portal Authentication Gateway
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=opc
-Group=opc
-WorkingDirectory=/home/opc/workspaces/vpd-permission-poc-20260628213409/poc4_active_source_20260714
-EnvironmentFile=/etc/smilegate/backoffice.env
-EnvironmentFile=/etc/smilegate/poc4-console.env
-ExecStart=/opt/smilegate/poc4-console/venv/bin/python /home/opc/workspaces/vpd-permission-poc-20260628213409/poc4_active_source_20260714/apps/poc4/portal_auth_gateway.py
-Restart=on-failure
-RestartSec=3
-NoNewPrivileges=true
-PrivateTmp=true
-
-[Install]
-WantedBy=multi-user.target

deploy/ai-web-agent-console/systemd/smilegate-poc4-console-blank.override.conf

@@ -1,3 +0,0 @@
-[Service]
-ExecStart=
-ExecStart=/opt/smilegate/poc4-console/venv/bin/streamlit run /home/opc/workspaces/vpd-permission-poc-20260628213409/poc4_active_source_20260714/apps/smilegate_demo/main.py --server.address 127.0.0.1 --server.port 8622 --server.headless true --server.enableCORS false --server.enableXsrfProtection false --browser.serverAddress smilegate.cloud-handson.com --browser.serverPort 443 --browser.gatherUsageStats false --logger.level=warn