Add categorical survey questions and run logging

frontend/src/silicon/SiliconCharts.tsx

@@ -35,6 +35,7 @@ export function SiliconCharts({ result }: SiliconChartsProps) {
   const selectedQuestion = result.config.questions.find((question) => question.id === selectedQuestionId) || result.config.questions[0];
   const selectedStat = result.questionStats.find((stat) => stat.questionId === selectedQuestion?.id);
   const isLikert = selectedQuestion?.kind === "likert";
+  const isCategorical = selectedQuestion?.kind === "categorical";
   const breakdownRows = useMemo(
     () => isLikert && breakdown !== "overall" ? resultBreakdown(result, selectedQuestion.id, breakdown) : [],
     [breakdown, isLikert, result, selectedQuestion?.id],
@@ -71,14 +72,14 @@ export function SiliconCharts({ result }: SiliconChartsProps) {
             type="button"
             className={[
               selectedQuestion.id === question.id ? "active" : "",
-              question.kind === "likert" ? "kind-likert" : "kind-open",
+              question.kind === "likert" ? "kind-likert" : question.kind === "categorical" ? "kind-categorical" : "kind-open",
             ].filter(Boolean).join(" ")}
             onClick={() => {
               setSelectedQuestionId(question.id);
-              if (question.kind === "open") setBreakdown("overall");
+              if (question.kind !== "likert") setBreakdown("overall");
             }}
           >
-            <span>{question.kind === "likert" ? `${question.scale}점 Likert` : "Open-ended"}</span>
+            <span>{question.kind === "likert" ? `${question.scale}점 Likert` : question.kind === "categorical" ? "Categorical" : "Open-ended"}</span>
             <strong>{question.title}</strong>
           </button>
         ))}
@@ -125,6 +126,32 @@ export function SiliconCharts({ result }: SiliconChartsProps) {
             <ResponseTable result={result} questionId={selectedQuestion.id} />
           </div>
         </>
+      ) : isCategorical ? (
+        <div className="silicon-chart-grid single">
+          <ChartCard
+            title="선택지별 응답 분포"
+            subtitle={selectedQuestion.title}
+            option={{
+              color: ["#6f7deb"],
+              tooltip: tooltip((value) => `${Number(value).toLocaleString()}개`),
+              grid: { ...grid(), left: 80 },
+              xAxis: { type: "value", axisLabel: axisLabel(), splitLine: splitLine() },
+              yAxis: { type: "category", data: selectedStat?.distribution?.map((item) => item.label || item.optionId || "") || [], axisLabel: axisLabel() },
+              series: [{
+                type: "bar",
+                data: selectedStat?.distribution?.map((item) => item.count) || [],
+                barWidth: "54%",
+                itemStyle: { borderRadius: [0, 8, 8, 0] },
+              }],
+            }}
+          />
+          <CategoricalMetricPanel
+            count={result.categoricalAnswers.filter((answer) => answer.questionId === selectedQuestion.id).length}
+            options={selectedQuestion.options?.length || 0}
+            topLabel={topCategoricalLabel(selectedStat?.distribution)}
+          />
+          <ResponseTable result={result} questionId={selectedQuestion.id} />
+        </div>
       ) : (
         <div className="silicon-chart-grid open-only">
           <OpenAnswerPanel result={result} questionId={selectedQuestion.id} />
@@ -135,6 +162,22 @@ export function SiliconCharts({ result }: SiliconChartsProps) {
   );
 }
 
+function CategoricalMetricPanel({ count, options, topLabel }: { count: number; options: number; topLabel: string }) {
+  return (
+    <section className="silicon-chart-card metric-card">
+      <header>
+        <span>선택 문항</span>
+        <strong>요약 지표</strong>
+      </header>
+      <div className="metric-card-grid">
+        <MetricItem label="응답 수" value={`${count.toLocaleString()}개`} />
+        <MetricItem label="선택지 수" value={`${options.toLocaleString()}개`} />
+        <MetricItem label="최다 선택" value={topLabel} />
+      </div>
+    </section>
+  );
+}
+
 function MetricPanel({ mean, positiveShare, count, scale }: { mean?: number; positiveShare?: number; count: number; scale: number }) {
   return (
     <section className="silicon-chart-card metric-card">
@@ -204,15 +247,17 @@ function ResponseTable({ result, questionId }: { result: SiliconResult; question
   const question = result.config.questions.find((item) => item.id === questionId);
   if (!question) return null;
   const likertByRespondent = new Map(result.likertAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.value]));
+  const categoricalByRespondent = new Map(result.categoricalAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.label]));
   const openByRespondent = new Map(result.openAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.text]));
   const rationaleByRespondent = new Map([
     ...result.likertAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.rationale || ""] as const),
+    ...result.categoricalAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.rationale || ""] as const),
     ...result.openAnswers.filter((answer) => answer.questionId === questionId).map((answer) => [answer.respondentId, answer.rationale || ""] as const),
   ]);
   const rows = result.respondents
     .map((respondent) => ({
       respondent,
-      value: question.kind === "likert" ? likertByRespondent.get(respondent.id) : openByRespondent.get(respondent.id),
+      value: question.kind === "likert" ? likertByRespondent.get(respondent.id) : question.kind === "categorical" ? categoricalByRespondent.get(respondent.id) : openByRespondent.get(respondent.id),
       rationale: rationaleByRespondent.get(respondent.id) || "",
     }))
     .filter((row) => row.value !== undefined);
@@ -233,7 +278,7 @@ function ResponseTable({ result, questionId }: { result: SiliconResult; question
               <th>주거</th>
               <th>혼인</th>
               <th>가구</th>
-              <th>{question.kind === "likert" ? "점수" : "답변"}</th>
+              <th>{question.kind === "likert" ? "점수" : question.kind === "categorical" ? "선택" : "답변"}</th>
               <th>응답 근거</th>
             </tr>
           </thead>
@@ -267,6 +312,12 @@ function MetricItem({ label, value }: { label: string; value: string }) {
   );
 }
 
+function topCategoricalLabel(distribution?: Array<{ label?: string; optionId?: string; count: number }>) {
+  const top = [...(distribution || [])].sort((a, b) => b.count - a.count)[0];
+  if (!top) return "-";
+  return `${top.label || top.optionId || "-"} (${top.count.toLocaleString()}개)`;
+}
+
 function breakdownOption(rows: ReturnType<typeof resultBreakdown>, metricMode: MetricMode) {
   const isPositive = metricMode === "positive";
   return {

frontend/src/silicon/SiliconSamplingApp.tsx

@@ -17,6 +17,7 @@ declare global {
 const SAMPLE_PRESETS = [10, 20, 50, 100];
 const MIN_SAMPLE_SIZE = 1;
 const MAX_SAMPLE_SIZE = 100;
+const DEFAULT_CATEGORICAL_OPTIONS = ["돈", "명예", "건강"];
 const VISIBLE_GENDERS = GENDERS.filter((gender) => gender.id !== "no_response");
 const SIDO_LOCATION_OPTIONS = LOCATION_OPTIONS.filter((location) => location.level === "sido");
 const ALL_FILTER = "all";
@@ -84,6 +85,7 @@ export function SiliconSamplingApp() {
   const [customScale, setCustomScale] = useState<4 | 5 | 7>(5);
   const [customLowLabel, setCustomLowLabel] = useState("");
   const [customHighLabel, setCustomHighLabel] = useState("");
+  const [customCategoricalOptions, setCustomCategoricalOptions] = useState<string[]>(() => DEFAULT_CATEGORICAL_OPTIONS);
   const [questionBankOpen, setQuestionBankOpen] = useState(true);
   const [generatedRespondents, setGeneratedRespondents] = useState<SyntheticRespondent[]>([]);
   const [seed, setSeed] = useState(20260629);
@@ -208,6 +210,7 @@ export function SiliconSamplingApp() {
     setCustomScale(5);
     setCustomLowLabel("");
     setCustomHighLabel("");
+    setCustomCategoricalOptions(DEFAULT_CATEGORICAL_OPTIONS);
     setQuestionBankOpen(true);
     setGeneratedRespondents([]);
     setResult(null);
@@ -218,20 +221,24 @@ export function SiliconSamplingApp() {
   const addCustomQuestion = () => {
     const title = customTitle.trim();
     if (!title) return;
+    const categoricalOptions = normalizeCategoricalOptions(customCategoricalOptions);
+    if (customKind === "categorical" && categoricalOptions.length < 2) return;
     const question: SurveyQuestion = {
       id: `custom_${Date.now().toString(36)}`,
       title,
       source: "사용자 추가 문항",
-      category: customKind === "likert" ? "직접 입력 Likert" : "직접 입력 자유응답",
+      category: customKind === "likert" ? "직접 입력 Likert" : customKind === "categorical" ? "직접 입력 Categorical" : "직접 입력 자유응답",
       kind: customKind,
       scale: customKind === "likert" ? customScale : undefined,
       lowLabel: customKind === "likert" ? (customLowLabel.trim() || "낮음") : undefined,
       highLabel: customKind === "likert" ? (customHighLabel.trim() || "높음") : undefined,
+      options: customKind === "categorical" ? categoricalOptions.map((label, index) => ({ id: `opt_${index + 1}`, label })) : undefined,
     };
     setCustomQuestions((items) => [...items, question]);
     setCustomTitle("");
     setCustomLowLabel("");
     setCustomHighLabel("");
+    setCustomCategoricalOptions(DEFAULT_CATEGORICAL_OPTIONS);
   };
 
   useEffect(() => {
@@ -247,6 +254,7 @@ export function SiliconSamplingApp() {
         questionCount: questions.length,
         likertCount: questions.filter((question) => question.kind === "likert").length,
         openCount: questions.filter((question) => question.kind === "open").length,
+        categoricalCount: questions.filter((question) => question.kind === "categorical").length,
         hasResult: Boolean(result),
         isRunning,
         resultOnlyPage: stage === "results",
@@ -315,6 +323,8 @@ export function SiliconSamplingApp() {
             setCustomLowLabel={setCustomLowLabel}
             customHighLabel={customHighLabel}
             setCustomHighLabel={setCustomHighLabel}
+            customCategoricalOptions={customCategoricalOptions}
+            setCustomCategoricalOptions={setCustomCategoricalOptions}
             questions={questions}
             onAddCustomQuestion={addCustomQuestion}
             onBack={() => setStage("respondents")}
@@ -459,6 +469,8 @@ function QuestionSetup({
   setCustomLowLabel,
   customHighLabel,
   setCustomHighLabel,
+  customCategoricalOptions,
+  setCustomCategoricalOptions,
   questions,
   onAddCustomQuestion,
   onBack,
@@ -481,6 +493,8 @@ function QuestionSetup({
   setCustomLowLabel: (value: string) => void;
   customHighLabel: string;
   setCustomHighLabel: (value: string) => void;
+  customCategoricalOptions: string[];
+  setCustomCategoricalOptions: (value: string[] | ((current: string[]) => string[])) => void;
   questions: SurveyQuestion[];
   onAddCustomQuestion: () => void;
   onBack: () => void;
@@ -524,11 +538,11 @@ function QuestionSetup({
                 type="button"
                 className={[
                   selectedQuestionIds.includes(question.id) ? "selected" : "",
-                  question.kind === "likert" ? "kind-likert" : "kind-open",
+                  question.kind === "likert" ? "kind-likert" : question.kind === "categorical" ? "kind-categorical" : "kind-open",
                 ].filter(Boolean).join(" ")}
                 onClick={() => setSelectedQuestionIds((ids) => ids.includes(question.id) ? ids.filter((id) => id !== question.id) : [...ids, question.id])}
               >
-                <span>{question.category} · {question.kind === "likert" ? `${question.scale}점` : "자유응답"}</span>
+                <span>{question.category} · {question.kind === "likert" ? `${question.scale}점` : question.kind === "categorical" ? "선택형" : "자유응답"}</span>
                 <strong>{question.title}</strong>
                 <em>{question.source}</em>
               </button>
@@ -554,6 +568,7 @@ function QuestionSetup({
             <span>답변 양식</span>
             <select value={customKind} onChange={(event) => setCustomKind(event.target.value as QuestionKind)}>
               <option value="likert">Likert</option>
+              <option value="categorical">Categorical</option>
               <option value="open">Open-ended</option>
             </select>
           </label>
@@ -577,6 +592,24 @@ function QuestionSetup({
               </label>
             </>
           ) : null}
+          {customKind === "categorical" ? (
+            <div className="categorical-options-editor">
+              <div className="categorical-options-head">
+                <span>선택지</span>
+                <button type="button" onClick={() => setCustomCategoricalOptions((items) => [...items, ""])}>선택지 추가</button>
+              </div>
+              {customCategoricalOptions.map((option, index) => (
+                <label key={index}>
+                  <span>{index + 1}번 선택지</span>
+                  <input
+                    value={option}
+                    onChange={(event) => setCustomCategoricalOptions((items) => items.map((item, itemIndex) => itemIndex === index ? event.target.value : item))}
+                    placeholder={`예: ${DEFAULT_CATEGORICAL_OPTIONS[index] || "기타"}`}
+                  />
+                </label>
+              ))}
+            </div>
+          ) : null}
           <button data-testid="silicon-custom-question-add" type="button" className="primary" onClick={onAddCustomQuestion}><Plus size={15} /> 추가</button>
         </div>
       </section>
@@ -592,9 +625,9 @@ function QuestionSetup({
         {questions.length ? (
           <div className="final-question-list">
             {questions.map((question) => (
-              <article key={question.id} className={question.kind === "likert" ? "kind-likert" : "kind-open"}>
+              <article key={question.id} className={question.kind === "likert" ? "kind-likert" : question.kind === "categorical" ? "kind-categorical" : "kind-open"}>
                 <div>
-                  <span>{question.kind === "likert" ? `${question.scale}점 Likert · 1점=${question.lowLabel || "낮음"} · ${question.scale}점=${question.highLabel || "높음"}` : "Open-ended"}</span>
+                  <span>{questionSummary(question)}</span>
                   <strong>{question.title}</strong>
                 </div>
                 <button type="button" onClick={() => removeQuestion(question)}>제거</button>
@@ -615,6 +648,7 @@ function QuestionSetup({
 
 function ResultsOnly({ result, isRunning, runStatus, onBack }: { result: SiliconResult | null; isRunning: boolean; runStatus: string; onBack: () => void }) {
   const likertCount = result?.config.questions.filter((question) => question.kind === "likert").length || 0;
+  const categoricalCount = result?.config.questions.filter((question) => question.kind === "categorical").length || 0;
   const openCount = result?.config.questions.filter((question) => question.kind === "open").length || 0;
   return (
     <section className="results-only-panel">
@@ -625,6 +659,7 @@ function ResultsOnly({ result, isRunning, runStatus, onBack }: { result: Silicon
         </div>
         <div className="result-stats">
           <span><strong>{likertCount}</strong> Likert</span>
+          <span><strong>{categoricalCount}</strong> categorical</span>
           <span><strong>{openCount}</strong> open-ended</span>
           <span><strong>{result?.config.questions.length || 0}</strong> questions</span>
         </div>
@@ -653,6 +688,7 @@ function ResultsOnly({ result, isRunning, runStatus, onBack }: { result: Silicon
             </header>
             <Metric label="평균 점수" value={formatNumber(result.questionStats.find((item) => item.questionId === result.primaryQuestionId)?.mean)} />
             <Metric label="긍정 응답률" value={formatPercent(result.questionStats.find((item) => item.questionId === result.primaryQuestionId)?.positiveShare)} />
+            <Metric label="선택형 응답 수" value={`${(result.categoricalAnswers || []).length.toLocaleString()}개`} />
             <Metric label="자유응답 수" value={`${result.openAnswers.length.toLocaleString()}개`} />
             <Metric label="문항 수" value={`${result.config.questions.length.toLocaleString()}개`} />
           </section>
@@ -911,6 +947,20 @@ function labelOf<T extends string>(items: Array<{ id: T; label: string }>, id?:
   return items.find((item) => item.id === id)?.label || id || "-";
 }
 
+function normalizeCategoricalOptions(options: string[]) {
+  return options.map((option) => option.trim()).filter(Boolean);
+}
+
+function questionSummary(question: SurveyQuestion) {
+  if (question.kind === "likert") {
+    return `${question.scale}점 Likert · 1점=${question.lowLabel || "낮음"} · ${question.scale}점=${question.highLabel || "높음"}`;
+  }
+  if (question.kind === "categorical") {
+    return `Categorical · ${(question.options || []).map((option) => option.label).join(" / ") || "선택지 없음"}`;
+  }
+  return "Open-ended";
+}
+
 function clampNumber(value: string, min: number, max: number) {
   const number = Number(value);
   if (!Number.isFinite(number)) return min;

frontend/src/silicon/simulate.ts

@@ -1,6 +1,7 @@
 import { AGE_BANDS, GENDERS, LOCATION_OPTIONS, PERSONA_OPTIONS, REGIONS } from "./data";
 import type {
   AgeBandId,
+  CategoricalAnswer,
   GenderId,
   LikertAnswer,
   LocationId,
@@ -56,8 +57,10 @@ export function simulateSiliconSampling(config: SiliconConfig): SiliconResult {
   const rand = mulberry32(config.seed);
   const respondents: SyntheticRespondent[] = [];
   const likertAnswers: LikertAnswer[] = [];
+  const categoricalAnswers: CategoricalAnswer[] = [];
   const openAnswers: OpenAnswer[] = [];
   const likertQuestions = config.questions.filter((question) => question.kind === "likert");
+  const categoricalQuestions = config.questions.filter((question) => question.kind === "categorical");
   const openQuestions = config.questions.filter((question) => question.kind === "open");
   const genderPool = buildAllocationPool(config.genders, config.sampleSize, "female", rand);
   const agePool = buildAllocationPool(config.ages, config.sampleSize, "40s", rand);
@@ -80,6 +83,13 @@ export function simulateSiliconSampling(config: SiliconConfig): SiliconResult {
         rationale: answerLikertRationale(question, respondent),
       });
     }
+    for (const question of categoricalQuestions) {
+      categoricalAnswers.push({
+        respondentId: respondent.id,
+        questionId: question.id,
+        ...answerCategorical(question, respondent, rand),
+      });
+    }
     for (const question of openQuestions) {
       openAnswers.push({
         respondentId: respondent.id,
@@ -94,9 +104,10 @@ export function simulateSiliconSampling(config: SiliconConfig): SiliconResult {
     config,
     respondents,
     likertAnswers,
+    categoricalAnswers,
     openAnswers,
     regionStats: buildRegionStats(config.locations, config.locationOptions, respondents, likertAnswers, openAnswers, likertQuestions[0]),
-    questionStats: buildQuestionStats(config.questions, likertAnswers),
+    questionStats: buildQuestionStats(config.questions, likertAnswers, categoricalAnswers),
     primaryQuestionId,
   };
 }
@@ -187,6 +198,16 @@ function answerOpen(question: SurveyQuestion, respondent: SyntheticRespondent, r
   return { theme, text, rationale };
 }
 
+function answerCategorical(question: SurveyQuestion, respondent: SyntheticRespondent, rand: () => number): { optionId: string; label: string; rationale: string } {
+  const options = question.options?.length ? question.options : [{ id: "opt_1", label: "기타" }];
+  const ageTilt = respondent.age === "20s" || respondent.age === "30s" ? 0 : respondent.age === "60plus" ? 2 : 1;
+  const anxietyTilt = respondent.economicAnxiety > 0.6 ? 0 : 1;
+  const index = Math.min(options.length - 1, Math.max(0, Math.floor((rand() * options.length + ageTilt + anxietyTilt) / 3)));
+  const option = options[index] || options[0];
+  const rationale = `${labelOf(REGIONS, respondent.region)} 거주 ${labelOf(AGE_BANDS, respondent.age)} 응답자로서 현재 생활 여건과 persona 특성에 가장 가까운 선택지를 골랐습니다.`;
+  return { optionId: option.id, label: option.label, rationale };
+}
+
 function buildRegionStats(
   locations: WeightedPick<LocationId>[],
   locationOptions: SiliconConfig["locationOptions"],
@@ -217,9 +238,23 @@ function buildRegionStats(
   });
 }
 
-function buildQuestionStats(questions: SurveyQuestion[], likertAnswers: LikertAnswer[]): QuestionStat[] {
+function buildQuestionStats(questions: SurveyQuestion[], likertAnswers: LikertAnswer[], categoricalAnswers: CategoricalAnswer[]): QuestionStat[] {
   return questions.map((question) => {
     if (question.kind === "open") return { questionId: question.id, title: question.title, kind: "open" };
+    if (question.kind === "categorical") {
+      const answers = categoricalAnswers.filter((answer) => answer.questionId === question.id);
+      const options = question.options || [];
+      const distribution = options.map((option) => {
+        const count = answers.filter((answer) => answer.optionId === option.id).length;
+        return { optionId: option.id, label: option.label, count, share: answers.length ? count / answers.length : 0 };
+      });
+      return {
+        questionId: question.id,
+        title: question.title,
+        kind: "categorical",
+        distribution,
+      };
+    }
     const scale = question.scale || 5;
     const answers = likertAnswers.filter((answer) => answer.questionId === question.id);
     const distribution = Array.from({ length: scale }, (_, index) => {

frontend/src/silicon/types.ts

@@ -23,7 +23,7 @@ export type LocationLevel = "sido" | "district";
 export type PersonaDimensionId = "occupation" | "education" | "housing" | "marital" | "family";
 export type PersonaAttributeId = string;
 
-export type QuestionKind = "likert" | "open";
+export type QuestionKind = "likert" | "categorical" | "open";
 
 export interface ToggleOption<T extends string> {
   id: T;
@@ -59,6 +59,7 @@ export interface SurveyQuestion {
   scale?: 4 | 5 | 7;
   lowLabel?: string;
   highLabel?: string;
+  options?: Array<{ id: string; label: string }>;
 }
 
 export interface WeightedPick<T extends string> {
@@ -109,6 +110,14 @@ export interface OpenAnswer {
   rationale?: string;
 }
 
+export interface CategoricalAnswer {
+  respondentId: string;
+  questionId: string;
+  optionId: string;
+  label: string;
+  rationale?: string;
+}
+
 export interface RegionStat {
   region: LocationId;
   parentRegion: RegionId;
@@ -127,13 +136,14 @@ export interface QuestionStat {
   scale?: number;
   mean?: number;
   positiveShare?: number;
-  distribution?: Array<{ value: number; count: number; share: number }>;
+  distribution?: Array<{ value?: number; optionId?: string; label?: string; count: number; share: number }>;
 }
 
 export interface SiliconResult {
   config: SiliconConfig;
   respondents: SyntheticRespondent[];
   likertAnswers: LikertAnswer[];
+  categoricalAnswers: CategoricalAnswer[];
   openAnswers: OpenAnswer[];
   regionStats: RegionStat[];
   questionStats: QuestionStat[];

frontend/src/styles.css

@@ -1080,6 +1080,12 @@ button {
   border-top-color: #f08a6c;
 }
 
+.question-bank button.kind-categorical,
+.question-tabs button.kind-categorical {
+  border-left-color: #14b8a6;
+  border-top-color: #14b8a6;
+}
+
 .question-tabs button.active {
   border-color: rgba(91, 110, 225, 0.38);
   background: linear-gradient(180deg, #f3f5ff, #ffffff);
@@ -1143,6 +1149,10 @@ button {
   border-left: 4px solid #f08a6c;
 }
 
+.custom-question-list article.kind-categorical {
+  border-left: 4px solid #14b8a6;
+}
+
 .custom-question-list em {
   color: rgba(24, 33, 58, 0.56);
   font-size: 11px;
@@ -1566,6 +1576,38 @@ button {
   grid-column: span 2;
 }
 
+.categorical-options-editor {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 10px;
+  border: 1px solid rgba(20, 184, 166, 0.18);
+  border-radius: 16px;
+  padding: 12px;
+  background: linear-gradient(180deg, rgba(236, 253, 245, 0.7), rgba(255, 255, 255, 0.92));
+}
+
+.categorical-options-head {
+  grid-column: 1 / -1;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 10px;
+}
+
+.categorical-options-head span {
+  color: rgba(24, 33, 58, 0.62);
+  font-size: 11px;
+  font-weight: 850;
+}
+
+.categorical-options-head button {
+  min-height: 32px;
+  padding: 6px 10px;
+  background: #ecfdf5;
+  color: #0f766e;
+}
+
 .custom-question-form label span {
   color: rgba(24, 33, 58, 0.58);
   font-size: 11px;
@@ -1596,6 +1638,10 @@ button {
   border-left: 4px solid #f08a6c;
 }
 
+.final-question-list article.kind-categorical {
+  border-left: 4px solid #14b8a6;
+}
+
 .final-question-list article span {
   color: rgba(24, 33, 58, 0.58);
   font-size: 11px;

scripts/test_silicon_llm_runtime.py

@@ -40,6 +40,16 @@ QUESTIONS = [
         "title": "가장 먼저 해결해야 할 문제는 무엇입니까?",
         "kind": "open",
     },
+    {
+        "id": "q_categorical",
+        "title": "삶에서 가장 중요한 것을 하나만 고르십시오.",
+        "kind": "categorical",
+        "options": [
+            {"id": "money", "label": "돈"},
+            {"id": "honor", "label": "명예"},
+            {"id": "health", "label": "건강"},
+        ],
+    },
 ]
 
 
@@ -55,6 +65,7 @@ class FakeLLM:
                     "q_likert_5": {"value": 4, "reason": "정책 평가는 대체로 긍정적입니다."},
                     "q_likert_4": {"value": 2, "reason": "의료 접근성은 지역에 따라 부족합니다."},
                     "q_open": {"text": "물가와 의료 접근성 개선이 가장 시급합니다.", "theme": "의료", "rationale": "생활비와 의료 이용 경험을 함께 고려했습니다."},
+                    "q_categorical": {"optionId": "health", "label": "건강", "rationale": "고령 가족 돌봄 경험 때문에 건강을 우선했습니다."},
                 }
             },
             ensure_ascii=False,
@@ -66,13 +77,14 @@ class SiliconLLMRuntimeTests(unittest.TestCase):
         contract = build_silicon_llm_response_contract(QUESTIONS)
 
         answer_properties = contract["schema"]["properties"]["answers"]["properties"]
-        self.assertEqual(set(answer_properties), {"q_likert_5", "q_likert_4", "q_open"})
+        self.assertEqual(set(answer_properties), {"q_likert_5", "q_likert_4", "q_open", "q_categorical"})
         self.assertEqual(answer_properties["q_likert_5"]["properties"]["value"]["minimum"], 1)
         self.assertEqual(answer_properties["q_likert_5"]["properties"]["value"]["maximum"], 5)
         self.assertEqual(answer_properties["q_likert_4"]["properties"]["value"]["maximum"], 4)
         self.assertIn("rationale", answer_properties["q_likert_4"]["required"])
         self.assertIn("text", answer_properties["q_open"]["required"])
         self.assertIn("rationale", answer_properties["q_open"]["required"])
+        self.assertEqual(answer_properties["q_categorical"]["properties"]["optionId"]["enum"], ["money", "honor", "health"])
 
     def test_parser_extracts_all_dynamic_answers_from_fenced_json(self) -> None:
         raw = """
@@ -82,7 +94,8 @@ class SiliconLLMRuntimeTests(unittest.TestCase):
           "answers": {
             "q_likert_5": {"value": "5", "reason": "강한 긍정"},
             "q_likert_4": {"score": 3, "reason": "보통 이상"},
-            "q_open": {"answer": "교통과 돌봄이 필요합니다", "topic": "교통"}
+            "q_open": {"answer": "교통과 돌봄이 필요합니다", "topic": "교통"},
+            "q_categorical": {"label": "건강", "rationale": "생활 안정의 전제라고 보았습니다."}
           }
         }
         ```
@@ -90,10 +103,13 @@ class SiliconLLMRuntimeTests(unittest.TestCase):
         parsed = parse_silicon_agent_response(raw, QUESTIONS, respondent_id="R0001")
 
         self.assertEqual(len(parsed["likertAnswers"]), 2)
+        self.assertEqual(len(parsed["categoricalAnswers"]), 1)
         self.assertEqual(len(parsed["openAnswers"]), 1)
         self.assertEqual(parsed["likertAnswers"][0]["value"], 5)
         self.assertEqual(parsed["likertAnswers"][1]["value"], 3)
         self.assertEqual(parsed["likertAnswers"][0]["rationale"], "강한 긍정")
+        self.assertEqual(parsed["categoricalAnswers"][0]["optionId"], "health")
+        self.assertEqual(parsed["categoricalAnswers"][0]["label"], "건강")
         self.assertEqual(parsed["openAnswers"][0]["theme"], "교통")
         self.assertTrue(parsed["openAnswers"][0]["rationale"])
 
@@ -117,14 +133,17 @@ class SiliconLLMRuntimeTests(unittest.TestCase):
         result = run_silicon_llm_sampling(payload, llm=fake)
 
         self.assertEqual(len(fake.calls), 2)
-        self.assertTrue(all(len(call["questions"]) == 3 for call in fake.calls))
+        self.assertTrue(all(len(call["questions"]) == 4 for call in fake.calls))
         self.assertEqual(len(result["respondents"]), 2)
         self.assertEqual(len(result["likertAnswers"]), 4)
+        self.assertEqual(len(result["categoricalAnswers"]), 2)
         self.assertEqual(len(result["openAnswers"]), 2)
         self.assertTrue(all(answer.get("rationale") for answer in result["likertAnswers"]))
+        self.assertTrue(all(answer.get("rationale") for answer in result["categoricalAnswers"]))
         self.assertTrue(all(answer.get("rationale") for answer in result["openAnswers"]))
-        self.assertEqual([stat["questionId"] for stat in result["questionStats"]], ["q_likert_5", "q_likert_4", "q_open"])
+        self.assertEqual([stat["questionId"] for stat in result["questionStats"]], ["q_likert_5", "q_likert_4", "q_open", "q_categorical"])
         self.assertEqual(result["questionStats"][0]["distribution"][3]["count"], 2)
+        self.assertEqual(result["questionStats"][3]["distribution"][2]["count"], 2)
         self.assertEqual(result["regionStats"][0]["respondents"], 2)
         self.assertEqual(result["llmTrace"]["calls"], 2)
 

scripts/test_silicon_logs.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Unit tests for anonymous silicon sampling run logs."""
+
+from __future__ import annotations
+
+import os
+import sqlite3
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from silicon_logs import log_status, record_run, recent_runs  # noqa: E402
+
+
+class SiliconLogTests(unittest.TestCase):
+    def test_record_run_writes_anonymous_settings_questions_and_summary(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "logs.sqlite3"
+            old = os.environ.get("SILICON_LOG_DB")
+            os.environ["SILICON_LOG_DB"] = str(path)
+            try:
+                info = record_run(
+                    {
+                        "config": {
+                            "sampleSize": 2,
+                            "genders": [{"id": "male", "enabled": True, "weight": 1}],
+                            "ages": [{"id": "30s", "enabled": True, "weight": 2}],
+                            "locations": [{"id": "seoul", "enabled": True, "weight": 2}],
+                            "locationOptions": [{"id": "seoul", "label": "서울", "parentRegion": "seoul", "level": "sido"}],
+                            "personaAttributes": [{"id": "occ_office", "enabled": True, "weight": 2}],
+                            "nemotronFields": ["persona", "occupation"],
+                            "questions": [
+                                {"id": "q1", "title": "만족도", "kind": "likert", "scale": 5},
+                                {"id": "q2", "title": "중요 가치", "kind": "categorical", "options": [{"id": "health", "label": "건강"}]},
+                            ],
+                        }
+                    },
+                    {
+                        "respondents": [{"id": "R0001"}, {"id": "R0002"}],
+                        "likertAnswers": [{"questionId": "q1"}, {"questionId": "q1"}],
+                        "categoricalAnswers": [{"questionId": "q2"}, {"questionId": "q2"}],
+                        "openAnswers": [],
+                        "questionStats": [{"questionId": "q1"}, {"questionId": "q2"}],
+                        "regionStats": [],
+                        "llmTrace": {"calls": 2, "rawResponses": ["not stored"]},
+                    },
+                    client={"userAgent": "unit-test"},
+                )
+                self.assertTrue(info["runId"].startswith("run_"))
+                self.assertTrue(path.exists())
+                self.assertEqual(log_status()["runCount"], 1)
+                rows = recent_runs()
+                self.assertEqual(len(rows), 1)
+                self.assertEqual(rows[0]["sampleSize"], 2)
+                self.assertEqual(rows[0]["questions"][1]["kind"], "categorical")
+                self.assertEqual(rows[0]["resultSummary"]["categoricalAnswers"], 2)
+                self.assertNotIn("rawResponses", rows[0]["resultSummary"]["llmTrace"])
+                with sqlite3.connect(path) as conn:
+                    self.assertEqual(conn.execute("SELECT COUNT(*) FROM runs").fetchone()[0], 1)
+            finally:
+                if old is None:
+                    os.environ.pop("SILICON_LOG_DB", None)
+                else:
+                    os.environ["SILICON_LOG_DB"] = old
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

scripts/validate_silicon_llm_api.py

@@ -7,6 +7,7 @@ import argparse
 import json
 import sys
 import time
+from urllib import request
 from pathlib import Path
 from typing import Any
 
@@ -19,36 +20,41 @@ from silicon_llm import resolve_openai_api_key, run_silicon_llm_sampling  # noqa
 
 def main() -> int:
     parser = argparse.ArgumentParser()
-    parser.add_argument("--agents", type=int, default=5)
+    parser.add_argument("--agents", type=int, default=2)
+    parser.add_argument("--max-cases", type=int, default=3)
     parser.add_argument("--model", default="gpt-4o-mini")
+    parser.add_argument("--endpoint", default="")
     parser.add_argument("--out", default="")
     args = parser.parse_args()
-    if not resolve_openai_api_key():
+    if not args.endpoint and not resolve_openai_api_key():
         print(json.dumps({"ok": False, "error": "OPENAI_API_KEY or .env OPENAI_API_KEY is required"}, ensure_ascii=False, indent=2))
         return 1
     out_dir = Path(args.out) if args.out else ROOT / "runs" / f"silicon_llm_api_validation_{timestamp()}"
     out_dir.mkdir(parents=True, exist_ok=True)
-    report: dict[str, Any] = {"ok": False, "model": args.model, "agents": args.agents, "cases": []}
-    for case in validation_cases():
+    report: dict[str, Any] = {"ok": False, "model": args.model, "agents": args.agents, "maxCases": args.max_cases, "endpoint": args.endpoint, "cases": []}
+    for case in validation_cases()[: max(1, args.max_cases)]:
         payload = base_payload(args.agents, case["questions"], model=args.model)
         started = time.time()
         try:
-            result = run_silicon_llm_sampling(payload)
+            result = run_payload(payload, endpoint=args.endpoint)
             checks = validate_result(case["case_id"], result, case["questions"], args.agents)
             report["cases"].append(
                 {
                     "case_id": case["case_id"],
                     "ok": all(check["ok"] for check in checks),
                     "elapsed_seconds": round(time.time() - started, 2),
-                    "questions": [{"id": item["id"], "kind": item["kind"], "scale": item.get("scale")} for item in case["questions"]],
+                    "questions": [{"id": item["id"], "kind": item["kind"], "scale": item.get("scale"), "options": item.get("options")} for item in case["questions"]],
                     "checks": checks,
                     "llmTrace": {
                         key: value
                         for key, value in result.get("llmTrace", {}).items()
                         if key != "rawResponses"
                     },
+                    "sample_categorical_answers": result.get("categoricalAnswers", [])[:3],
                     "sample_open_answers": result.get("openAnswers", [])[:3],
                     "questionStats": result.get("questionStats", []),
+                    "runLog": result.get("runLog"),
+                    "runLogError": result.get("runLogError"),
                 }
             )
         except Exception as exc:  # noqa: BLE001
@@ -59,6 +65,19 @@ def main() -> int:
     return 0 if report["ok"] else 1
 
 
+def run_payload(payload: dict[str, Any], *, endpoint: str) -> dict[str, Any]:
+    if not endpoint:
+        return run_silicon_llm_sampling(payload)
+    url = endpoint.rstrip("/") + "/api/silicon/llm-run"
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    req = request.Request(url, data=data, headers={"content-type": "application/json"}, method="POST")
+    with request.urlopen(req, timeout=180) as response:  # noqa: S310
+        result = json.loads(response.read().decode("utf-8"))
+    if "error" in result:
+        raise RuntimeError(str(result["error"]))
+    return result
+
+
 def validation_cases() -> list[dict[str, Any]]:
     return [
         {
@@ -66,12 +85,14 @@ def validation_cases() -> list[dict[str, Any]]:
             "questions": [
                 likert("approval_5", "현 정부 국정 운영을 어떻게 평가하십니까?", 5),
                 likert("medical_access_4", "거주 지역 의료 접근성에 만족하십니까?", 4),
+                categorical("life_priority", "삶에서 가장 중요한 것을 하나만 고르십시오.", ["돈", "명예", "건강"]),
                 open_q("local_problem", "거주 지역에서 가장 먼저 해결해야 할 문제는 무엇입니까?"),
             ],
         },
         {
             "case_id": "open_only_priorities",
             "questions": [
+                categorical("social_priority", "한국 사회가 가장 우선해야 할 가치를 고르십시오.", ["경제 성장", "사회 안전", "공정성", "환경"]),
                 open_q("top_issue", "한국 사회가 가장 먼저 해결해야 할 문제는 무엇이라고 보십니까?"),
                 open_q("policy_request", "새 정부나 지방자치단체에 가장 바라는 정책을 적어주십시오."),
             ],
@@ -81,6 +102,7 @@ def validation_cases() -> list[dict[str, Any]]:
             "questions": [
                 likert("vote_turnout_4", "다음 지방선거에 투표할 가능성�� 얼마나 높습니까?", 4),
                 likert("party_reflects_5", "주요 정당이 국민 의견을 잘 반영한다고 보십니까?", 5),
+                categorical("vote_factor", "투표할 때 가장 중요하게 보는 기준을 고르십시오.", ["후보 역량", "정당", "공약", "지역 현안"]),
                 likert("climate_cost_7", "탄소 감축 비용 부담 정책에 어느 정도 동의하십니까?", 7),
             ],
         },
@@ -88,6 +110,7 @@ def validation_cases() -> list[dict[str, Any]]:
             "case_id": "custom_korean_mix",
             "questions": [
                 likert("custom_transport_safety", "출퇴근길 대중교통 안전에 만족하십니까?", 5),
+                categorical("custom_life_choice", "지금 생활에서 가장 크게 필요한 것을 고르십시오.", ["시간", "소득", "건강", "관계"]),
                 open_q("custom_one_sentence", "본인의 생활에서 가장 크게 체감되는 정책 문제를 한 문장으로 적어주십시오."),
                 likert("custom_media_trust", "온라인 뉴스와 유튜브 정치 정보를 신뢰하십니까?", 5),
             ],
@@ -98,6 +121,7 @@ def validation_cases() -> list[dict[str, Any]]:
                 likert("economy_next_year", "향후 1년 한국 경제가 좋아질 것이라고 보십니까?", 5),
                 likert("household_life", "현재 가계 생활 형편에 얼마나 만족하십니까?", 5),
                 likert("institution_trust", "국회, 언론, 행정부 등 공공기관을 전반적으로 신뢰하십니까?", 5),
+                categorical("public_spend_priority", "정부 재정이 우선 투입되어야 할 분야를 고르십시오.", ["복지", "일자리", "교육", "안보", "기후"]),
                 open_q("free_reason", "그렇게 응답한 가장 큰 이유를 적어주십시오."),
             ],
         },
@@ -112,6 +136,17 @@ def open_q(question_id: str, title: str) -> dict[str, Any]:
     return {"id": question_id, "title": title, "source": "API validation", "category": "검증", "kind": "open"}
 
 
+def categorical(question_id: str, title: str, labels: list[str]) -> dict[str, Any]:
+    return {
+        "id": question_id,
+        "title": title,
+        "source": "API validation",
+        "category": "검증",
+        "kind": "categorical",
+        "options": [{"id": f"opt_{index + 1}", "label": label} for index, label in enumerate(labels)],
+    }
+
+
 def base_payload(agent_count: int, questions: list[dict[str, Any]], *, model: str) -> dict[str, Any]:
     return {
         "config": {
@@ -139,14 +174,18 @@ def base_payload(agent_count: int, questions: list[dict[str, Any]], *, model: st
 def validate_result(case_id: str, result: dict[str, Any], questions: list[dict[str, Any]], agent_count: int) -> list[dict[str, Any]]:
     checks: list[dict[str, Any]] = []
     likert_questions = [item for item in questions if item["kind"] == "likert"]
+    categorical_questions = [item for item in questions if item["kind"] == "categorical"]
     open_questions = [item for item in questions if item["kind"] == "open"]
     checks.append(check("respondent_count", len(result.get("respondents", [])) == agent_count, {"count": len(result.get("respondents", [])), "expected": agent_count}))
     checks.append(check("one_llm_call_per_agent", result.get("llmTrace", {}).get("calls") == agent_count, result.get("llmTrace", {})))
     checks.append(check("all_questions_in_config", [item["id"] for item in result.get("config", {}).get("questions", [])] == [item["id"] for item in questions], None))
     checks.append(check("likert_answer_count", len(result.get("likertAnswers", [])) == agent_count * len(likert_questions), {"count": len(result.get("likertAnswers", [])), "expected": agent_count * len(likert_questions)}))
+    checks.append(check("categorical_answer_count", len(result.get("categoricalAnswers", [])) == agent_count * len(categorical_questions), {"count": len(result.get("categoricalAnswers", [])), "expected": agent_count * len(categorical_questions)}))
     checks.append(check("open_answer_count", len(result.get("openAnswers", [])) == agent_count * len(open_questions), {"count": len(result.get("openAnswers", [])), "expected": agent_count * len(open_questions)}))
     checks.append(check("question_stats_count", len(result.get("questionStats", [])) == len(questions), {"count": len(result.get("questionStats", [])), "expected": len(questions)}))
     checks.append(check("parse_issues_empty", not result.get("llmTrace", {}).get("parseIssues"), result.get("llmTrace", {}).get("parseIssues")))
+    if result.get("runLog") or result.get("runLogError"):
+        checks.append(check("run_log_recorded", bool(result.get("runLog")) and not result.get("runLogError"), result.get("runLog") or result.get("runLogError")))
     for question in likert_questions:
         question_id = question["id"]
         scale = int(question.get("scale") or 5)
@@ -156,6 +195,14 @@ def validate_result(case_id: str, result: dict[str, Any], questions: list[dict[s
         checks.append(check(f"{case_id}:{question_id}:distribution_sum", sum(item.get("count", 0) for item in stat.get("distribution", [])) == agent_count, stat.get("distribution")))
         rationales = [answer.get("rationale") for answer in result.get("likertAnswers", []) if answer.get("questionId") == question_id]
         checks.append(check(f"{case_id}:{question_id}:likert_rationale", len(rationales) == agent_count and all(rationales), rationales[:2]))
+    for question in categorical_questions:
+        question_id = question["id"]
+        allowed = {option["id"] for option in question.get("options", [])}
+        answers = [answer for answer in result.get("categoricalAnswers", []) if answer.get("questionId") == question_id]
+        stat = next((item for item in result.get("questionStats", []) if item.get("questionId") == question_id), {})
+        checks.append(check(f"{case_id}:{question_id}:categorical_option", len(answers) == agent_count and all(answer.get("optionId") in allowed for answer in answers), answers[:2]))
+        checks.append(check(f"{case_id}:{question_id}:categorical_distribution_sum", sum(item.get("count", 0) for item in stat.get("distribution", [])) == agent_count, stat.get("distribution")))
+        checks.append(check(f"{case_id}:{question_id}:categorical_rationale", len(answers) == agent_count and all(answer.get("rationale") for answer in answers), answers[:2]))
     for question in open_questions:
         answers = [answer for answer in result.get("openAnswers", []) if answer.get("questionId") == question["id"]]
         checks.append(check(f"{case_id}:{question['id']}:open_text_theme", len(answers) == agent_count and all(answer.get("text") and answer.get("theme") for answer in answers), answers[:2]))

server.py

@@ -5,9 +5,10 @@ import os
 from http import HTTPStatus
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from urllib.parse import urlparse
+from urllib.parse import parse_qs, urlparse
 
 from persona_dataset import PersonaDatasetError, dataset_metadata, dataset_status, sample_personas
+from silicon_logs import log_status, recent_runs, record_run
 from silicon_llm import resolve_openai_api_key, run_silicon_llm_sampling
 
 
@@ -73,8 +74,17 @@ class Handler(BaseHTTPRequestHandler):
                     "ok": True,
                     "openai_api_key_set": bool(resolve_openai_api_key()),
                     "dataset": dataset_status(),
+                    "logs": log_status(),
                 },
             )
+        if path == "/api/logs/status":
+            return write_json(self, log_status())
+        if path == "/api/logs/recent":
+            token = os.getenv("SILICON_LOG_READ_TOKEN", "").strip()
+            provided = parse_qs(parsed.query).get("token", [""])[0]
+            if not token or provided != token:
+                return write_json(self, {"error": "log read token required", "status": log_status()}, HTTPStatus.FORBIDDEN)
+            return write_json(self, {"runs": recent_runs(20), "status": log_status()})
         if path == "/api/persona-dataset/metadata":
             try:
                 return write_json(self, dataset_metadata())
@@ -97,7 +107,19 @@ class Handler(BaseHTTPRequestHandler):
                 return write_json(self, {"error": str(exc), "status": dataset_status()}, HTTPStatus.BAD_REQUEST)
         if parsed.path == "/api/silicon/llm-run":
             try:
-                return write_json(self, run_silicon_llm_sampling(payload))
+                result = run_silicon_llm_sampling(payload)
+                try:
+                    result["runLog"] = record_run(
+                        payload,
+                        result,
+                        client={
+                            "userAgent": self.headers.get("user-agent", "")[:240],
+                            "referer": self.headers.get("referer", "")[:240],
+                        },
+                    )
+                except Exception as log_exc:  # noqa: BLE001
+                    result["runLogError"] = f"{type(log_exc).__name__}: {log_exc}"
+                return write_json(self, result)
             except ValueError as exc:
                 return write_json(self, {"error": str(exc)}, HTTPStatus.BAD_REQUEST)
             except RuntimeError as exc:

silicon_llm.py

@@ -74,6 +74,7 @@ class OpenAILLM:
                     "당신은 한국 설문조사의 가상 응답자입니다. "
                     "주어진 persona와 인구통계 정보를 일관되게 반영해 모든 문항에 답하십시오. "
                     "반드시 JSON만 반환하십시오. Likert 문항은 해당 척도 범위의 정수 value를, "
+                    "categorical 문항은 제공된 options 중 하나의 optionId와 label을, "
                     "open-ended 문항은 한국어 text와 짧은 theme를 반환하십시오. "
                     "모든 답변에는 왜 그렇게 답했는지 한 문장의 rationale을 포함하십시오."
                 ),
@@ -148,6 +149,19 @@ def build_silicon_llm_response_contract(questions: list[dict[str, Any]]) -> dict
                 "required": ["text", "theme", "rationale"],
                 "additionalProperties": True,
             }
+        elif question.get("kind") == "categorical":
+            options = [item for item in question.get("options", []) if isinstance(item, dict)]
+            option_ids = [str(item.get("id")) for item in options if item.get("id")]
+            answer_properties[question_id] = {
+                "type": "object",
+                "properties": {
+                    "optionId": {"type": "string", "enum": option_ids or ["opt_1"]},
+                    "label": {"type": "string"},
+                    "rationale": {"type": "string"},
+                },
+                "required": ["optionId", "label", "rationale"],
+                "additionalProperties": True,
+            }
         else:
             scale = int(question.get("scale") or 5)
             answer_properties[question_id] = {
@@ -186,6 +200,7 @@ def parse_silicon_agent_response(raw: str, questions: list[dict[str, Any]], *, r
         answers = {}
 
     likert_answers: list[dict[str, Any]] = []
+    categorical_answers: list[dict[str, Any]] = []
     open_answers: list[dict[str, Any]] = []
     issues: list[dict[str, Any]] = []
     for question in questions:
@@ -205,6 +220,21 @@ def parse_silicon_agent_response(raw: str, questions: list[dict[str, Any]], *, r
                 rationale = "해당 persona와 인구통계 조건을 기준으로 자유응답을 생성했습니다."
                 issues.append({"questionId": question_id, "type": "missing_rationale"})
             open_answers.append({"respondentId": respondent_id, "questionId": question_id, "text": text, "theme": theme[:40], "rationale": rationale[:500]})
+        elif question.get("kind") == "categorical":
+            options = [item for item in question.get("options", []) if isinstance(item, dict)]
+            option_by_id = {str(item.get("id")): str(item.get("label") or item.get("id")) for item in options if item.get("id")}
+            fallback_id = next(iter(option_by_id), "opt_1")
+            option_id = str(answer.get("optionId") or answer.get("option_id") or answer.get("value") or "").strip()
+            if option_id not in option_by_id:
+                matched = next((oid for oid, label in option_by_id.items() if label == str(answer.get("label") or answer.get("answer") or "").strip()), "")
+                option_id = matched or fallback_id
+                issues.append({"questionId": question_id, "type": "invalid_categorical_option"})
+            label = option_by_id.get(option_id, str(answer.get("label") or option_id))
+            rationale = str(answer.get("rationale") or answer.get("reason") or answer.get("explanation") or "").strip()
+            if not rationale:
+                rationale = "해당 persona와 인구통계 조건에 가장 가까운 선택지를 골랐습니다."
+                issues.append({"questionId": question_id, "type": "missing_rationale"})
+            categorical_answers.append({"respondentId": respondent_id, "questionId": question_id, "optionId": option_id, "label": label, "rationale": rationale[:500]})
         else:
             scale = int(question.get("scale") or 5)
             value = coerce_int(answer.get("value", answer.get("score", answer.get("rating"))), default=math.ceil(scale / 2))
@@ -214,7 +244,7 @@ def parse_silicon_agent_response(raw: str, questions: list[dict[str, Any]], *, r
                 rationale = "해당 persona와 인구통계 조건을 기준으로 척도 응답을 선택했습니다."
                 issues.append({"questionId": question_id, "type": "missing_rationale"})
             likert_answers.append({"respondentId": respondent_id, "questionId": question_id, "value": value, "rationale": rationale[:500]})
-    return {"likertAnswers": likert_answers, "openAnswers": open_answers, "issues": issues}
+    return {"likertAnswers": likert_answers, "categoricalAnswers": categorical_answers, "openAnswers": open_answers, "issues": issues}
 
 
 def run_silicon_llm_sampling(payload: dict[str, Any], *, llm: Any | None = None) -> dict[str, Any]:
@@ -234,6 +264,7 @@ def run_silicon_llm_sampling(payload: dict[str, Any], *, llm: Any | None = None)
     model = str(execution.get("model") or os.getenv("SILICON_LLM_MODEL", "gpt-4o-mini"))
     llm = llm or OpenAILLM(model=model, timeout=float(execution.get("timeout_seconds") or 60))
     likert_answers: list[dict[str, Any]] = []
+    categorical_answers: list[dict[str, Any]] = []
     open_answers: list[dict[str, Any]] = []
     parse_issues: list[dict[str, Any]] = []
     raw_responses: list[dict[str, str]] = []
@@ -243,17 +274,19 @@ def run_silicon_llm_sampling(payload: dict[str, Any], *, llm: Any | None = None)
         raw_responses.append({"respondentId": respondent["id"], "text": raw[:4000]})
         parsed = parse_silicon_agent_response(raw, questions, respondent_id=respondent["id"])
         likert_answers.extend(parsed["likertAnswers"])
+        categorical_answers.extend(parsed["categoricalAnswers"])
         open_answers.extend(parsed["openAnswers"])
         parse_issues.extend({"respondentId": respondent["id"], **issue} for issue in parsed["issues"])
 
-    primary_question_id = next((str(item.get("id")) for item in questions if item.get("kind") != "open"), None)
+    primary_question_id = next((str(item.get("id")) for item in questions if item.get("kind") == "likert"), None)
     result = {
         "config": config,
         "respondents": respondents,
         "likertAnswers": likert_answers,
+        "categoricalAnswers": categorical_answers,
         "openAnswers": open_answers,
         "regionStats": build_region_stats(config, respondents, likert_answers, open_answers, questions),
-        "questionStats": build_question_stats(questions, likert_answers),
+        "questionStats": build_question_stats(questions, likert_answers, categorical_answers),
         "primaryQuestionId": primary_question_id,
         "llmTrace": {
             "engine": "openai_chat_completions" if isinstance(llm, OpenAILLM) else "injected_llm",
@@ -329,13 +362,30 @@ def allocation_pool(items: Any, target_size: int, fallback: str) -> list[str]:
     return pool[:target_size]
 
 
-def build_question_stats(questions: list[dict[str, Any]], likert_answers: list[dict[str, Any]]) -> list[dict[str, Any]]:
+def build_question_stats(questions: list[dict[str, Any]], likert_answers: list[dict[str, Any]], categorical_answers: list[dict[str, Any]]) -> list[dict[str, Any]]:
     stats: list[dict[str, Any]] = []
     for question in questions:
         question_id = str(question.get("id"))
         if question.get("kind") == "open":
             stats.append({"questionId": question_id, "title": question.get("title", question_id), "kind": "open"})
             continue
+        if question.get("kind") == "categorical":
+            answers = [answer for answer in categorical_answers if answer.get("questionId") == question_id]
+            options = [item for item in question.get("options", []) if isinstance(item, dict)]
+            distribution = []
+            for option in options:
+                option_id = str(option.get("id"))
+                count = len([answer for answer in answers if answer.get("optionId") == option_id])
+                distribution.append(
+                    {
+                        "optionId": option_id,
+                        "label": str(option.get("label") or option_id),
+                        "count": count,
+                        "share": count / len(answers) if answers else 0,
+                    }
+                )
+            stats.append({"questionId": question_id, "title": question.get("title", question_id), "kind": "categorical", "distribution": distribution})
+            continue
         scale = int(question.get("scale") or 5)
         values = [int(answer["value"]) for answer in likert_answers if answer.get("questionId") == question_id]
         distribution = [{"value": value, "count": values.count(value), "share": values.count(value) / len(values) if values else 0} for value in range(1, scale + 1)]
@@ -355,7 +405,7 @@ def build_question_stats(questions: list[dict[str, Any]], likert_answers: list[d
 
 
 def build_region_stats(config: dict[str, Any], respondents: list[dict[str, Any]], likert_answers: list[dict[str, Any]], open_answers: list[dict[str, Any]], questions: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    primary = next((question for question in questions if question.get("kind") != "open"), None)
+    primary = next((question for question in questions if question.get("kind") == "likert"), None)
     primary_id = str(primary.get("id")) if primary else None
     scale = int(primary.get("scale") or 5) if primary else 5
     positive_cut = max(3, math.ceil(scale * 0.7))

silicon_logs.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+APP_DIR = Path(__file__).resolve().parent
+
+
+def default_log_path() -> Path:
+    configured = os.getenv("SILICON_LOG_DB", "").strip()
+    if configured:
+        return Path(configured).expanduser()
+    data_dir = Path("/data")
+    if data_dir.exists() and os.access(data_dir, os.W_OK):
+        return data_dir / "silicon_logs.sqlite3"
+    return APP_DIR / "runs" / "silicon_logs.sqlite3"
+
+
+def log_status() -> dict[str, Any]:
+    path = default_log_path()
+    return {
+        "enabled": True,
+        "path": str(path),
+        "exists": path.exists(),
+        "storage": "persistent_bucket" if str(path).startswith("/data/") else "local_ephemeral",
+        "runCount": count_runs(path) if path.exists() else 0,
+    }
+
+
+def record_run(payload: dict[str, Any], result: dict[str, Any], client: dict[str, Any] | None = None) -> dict[str, Any]:
+    path = default_log_path()
+    ensure_schema(path)
+    run_id = f"run_{uuid.uuid4().hex[:16]}"
+    created_at = datetime.now(timezone.utc).isoformat()
+    config = payload.get("config", {}) if isinstance(payload.get("config"), dict) else {}
+    result_summary = build_result_summary(result)
+    with sqlite3.connect(path) as conn:
+        conn.execute(
+            """
+            INSERT INTO runs(
+              run_id,
+              created_at,
+              sample_size,
+              respondent_settings_json,
+              questions_json,
+              result_summary_json,
+              client_json
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                run_id,
+                created_at,
+                int(config.get("sampleSize") or len(result.get("respondents", [])) or 0),
+                json.dumps(build_respondent_settings(config), ensure_ascii=False, sort_keys=True),
+                json.dumps(build_question_log(config), ensure_ascii=False, sort_keys=True),
+                json.dumps(result_summary, ensure_ascii=False, sort_keys=True),
+                json.dumps(client or {}, ensure_ascii=False, sort_keys=True),
+            ),
+        )
+    return {"runId": run_id, "createdAt": created_at, "storage": log_status()["storage"], "path": str(path)}
+
+
+def recent_runs(limit: int = 20) -> list[dict[str, Any]]:
+    path = default_log_path()
+    if not path.exists():
+        return []
+    ensure_schema(path)
+    with sqlite3.connect(path) as conn:
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            """
+            SELECT run_id, created_at, sample_size, respondent_settings_json, questions_json, result_summary_json
+            FROM runs
+            ORDER BY created_at DESC
+            LIMIT ?
+            """,
+            (max(1, min(100, int(limit))),),
+        ).fetchall()
+    return [
+        {
+            "runId": row["run_id"],
+            "createdAt": row["created_at"],
+            "sampleSize": row["sample_size"],
+            "respondentSettings": parse_json(row["respondent_settings_json"]),
+            "questions": parse_json(row["questions_json"]),
+            "resultSummary": parse_json(row["result_summary_json"]),
+        }
+        for row in rows
+    ]
+
+
+def ensure_schema(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with sqlite3.connect(path) as conn:
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS runs(
+              run_id TEXT PRIMARY KEY,
+              created_at TEXT NOT NULL,
+              sample_size INTEGER NOT NULL,
+              respondent_settings_json TEXT NOT NULL,
+              questions_json TEXT NOT NULL,
+              result_summary_json TEXT NOT NULL,
+              client_json TEXT NOT NULL
+            )
+            """
+        )
+        conn.execute("CREATE INDEX IF NOT EXISTS idx_runs_created_at ON runs(created_at)")
+
+
+def count_runs(path: Path) -> int:
+    try:
+        ensure_schema(path)
+        with sqlite3.connect(path) as conn:
+            return int(conn.execute("SELECT COUNT(*) FROM runs").fetchone()[0])
+    except sqlite3.Error:
+        return 0
+
+
+def build_respondent_settings(config: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "sampleSize": int(config.get("sampleSize") or 0),
+        "genders": enabled_weighted(config.get("genders")),
+        "ages": enabled_weighted(config.get("ages")),
+        "locations": enabled_locations(config),
+        "personaAttributes": enabled_weighted(config.get("personaAttributes")),
+        "nemotronFields": [str(item) for item in config.get("nemotronFields", []) if item],
+        "seed": config.get("seed"),
+    }
+
+
+def build_question_log(config: dict[str, Any]) -> list[dict[str, Any]]:
+    questions = config.get("questions", []) if isinstance(config.get("questions"), list) else []
+    logged: list[dict[str, Any]] = []
+    for question in questions:
+        if not isinstance(question, dict):
+            continue
+        logged.append(
+            {
+                "id": question.get("id"),
+                "title": question.get("title"),
+                "source": question.get("source"),
+                "category": question.get("category"),
+                "kind": question.get("kind"),
+                "scale": question.get("scale"),
+                "lowLabel": question.get("lowLabel"),
+                "highLabel": question.get("highLabel"),
+                "options": question.get("options") if question.get("kind") == "categorical" else None,
+            }
+        )
+    return logged
+
+
+def build_result_summary(result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "respondents": len(result.get("respondents", [])),
+        "likertAnswers": len(result.get("likertAnswers", [])),
+        "categoricalAnswers": len(result.get("categoricalAnswers", [])),
+        "openAnswers": len(result.get("openAnswers", [])),
+        "primaryQuestionId": result.get("primaryQuestionId"),
+        "questionStats": result.get("questionStats", []),
+        "regionStats": result.get("regionStats", []),
+        "llmTrace": {
+            key: value
+            for key, value in (result.get("llmTrace", {}) if isinstance(result.get("llmTrace"), dict) else {}).items()
+            if key not in {"rawResponses"}
+        },
+    }
+
+
+def enabled_weighted(items: Any) -> list[dict[str, Any]]:
+    return [
+        {"id": str(item.get("id")), "weight": item.get("weight")}
+        for item in items or []
+        if isinstance(item, dict) and item.get("enabled")
+    ]
+
+
+def enabled_locations(config: dict[str, Any]) -> list[dict[str, Any]]:
+    labels = {
+        str(item.get("id")): {
+            "label": item.get("label"),
+            "parentRegion": item.get("parentRegion"),
+            "level": item.get("level"),
+        }
+        for item in config.get("locationOptions", [])
+        if isinstance(item, dict)
+    }
+    rows = []
+    for item in config.get("locations", []) or []:
+        if not isinstance(item, dict) or not item.get("enabled"):
+            continue
+        location_id = str(item.get("id"))
+        rows.append({"id": location_id, "weight": item.get("weight"), **labels.get(location_id, {})})
+    return rows
+
+
+def parse_json(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return None