triflux 9.1.0 → 9.2.1

package/bin/triflux.mjs

@@ -11,6 +11,7 @@ import { detectMultiplexer, getSessionAttachedCount, killSession, listSessions,
 import { forceCleanupTeam } from "../hub/team/nativeProxy.mjs";
 import { cleanupStaleOmcTeams, inspectStaleOmcTeams } from "../hub/team/staleState.mjs";
 import { getPipelineStateDbPath } from "../hub/pipeline/state.mjs";
+import { ensureGeminiProfiles } from "../scripts/lib/gemini-profiles.mjs";
 
 const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const CLAUDE_DIR = join(homedir(), ".claude");
@@ -18,6 +19,9 @@ const CODEX_DIR = join(homedir(), ".codex");
 const CODEX_CONFIG_PATH = join(CODEX_DIR, "config.toml");
 const PKG = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
 
+// 이 배열에 포함된 버전에서만 star prompt를 표시한다 (빈 배열 = 모든 버전에서 표시)
+const STAR_PROMPT_VERSIONS = ["9.2.1"];
+
 const REQUIRED_CODEX_PROFILES = [
   {
     name: "codex53_high",
@@ -662,6 +666,11 @@ function getSetupSyncTargets() {
       dst: join(CLAUDE_DIR, "scripts", "lib", "keyword-rules.mjs"),
       label: "lib/keyword-rules.mjs",
     },
+    {
+      src: join(PKG_ROOT, "scripts", "lib", "gemini-profiles.mjs"),
+      dst: join(CLAUDE_DIR, "scripts", "lib", "gemini-profiles.mjs"),
+      label: "lib/gemini-profiles.mjs",
+    },
     {
       src: join(PKG_ROOT, "scripts", "tfx-route-worker.mjs"),
       dst: join(CLAUDE_DIR, "scripts", "tfx-route-worker.mjs"),
@@ -816,7 +825,7 @@ function buildSetupDryRunPlan() {
 }
 
 function cmdSetup(options = {}) {
-  const { dryRun = false } = options;
+  const { dryRun = false, fromUpdate = false } = options;
   if (dryRun) {
     printJson(buildSetupDryRunPlan());
     return;
@@ -869,19 +878,42 @@ function cmdSetup(options = {}) {
     }
   }
 
+  // ── 결과 추적 ──
+  const summary = [];
+
   const codexProfileResult = ensureCodexProfiles();
   if (!codexProfileResult.ok) {
     warn(`Codex profiles 설정 실패: ${codexProfileResult.message}`);
+    summary.push({ item: "Codex profiles", status: "⚠️", detail: codexProfileResult.message });
   } else if (codexProfileResult.added > 0) {
     ok(`Codex profiles: ${codexProfileResult.added}개 추가됨 (~/.codex/config.toml)`);
+    summary.push({ item: "Codex profiles", status: "✅", detail: `${codexProfileResult.added}개 추가됨` });
   } else {
     ok("Codex profiles: 이미 준비됨");
+    summary.push({ item: "Codex profiles", status: "✅", detail: "이미 준비됨" });
+  }
+
+  // Gemini 프로필
+  const geminiResult = ensureGeminiProfiles();
+  if (!geminiResult.ok) {
+    warn(`Gemini profiles 설정 실패: ${geminiResult.message}`);
+    summary.push({ item: "Gemini profiles", status: "⚠️", detail: geminiResult.message });
+  } else if (geminiResult.created) {
+    ok(`Gemini profiles: ${geminiResult.count}개 생성됨 (~/.gemini/triflux-profiles.json)`);
+    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.count}개 생성됨` });
+  } else if (geminiResult.added > 0) {
+    ok(`Gemini profiles: ${geminiResult.added}개 추가됨`);
+    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.added}개 추가됨 (총 ${geminiResult.count}개)` });
+  } else {
+    ok(`Gemini profiles: ${geminiResult.count}개 준비됨`);
+    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.count}개 준비됨` });
   }
 
   // hub MCP 사전 등록 (서버 미실행이어도 설정만 등록 — hub start 시 즉시 사용 가능)
   if (existsSync(join(PKG_ROOT, "hub", "server.mjs"))) {
     const defaultHubUrl = `http://127.0.0.1:${process.env.TFX_HUB_PORT || "27888"}/mcp`;
     autoRegisterMcp(defaultHubUrl);
+    summary.push({ item: "Hub MCP", status: "✅", detail: "등록됨" });
     console.log("");
   }
 
@@ -900,6 +932,7 @@ function cmdSetup(options = {}) {
       const currentCmd = settings.statusLine?.command || "";
       if (currentCmd.includes("hud-qos-status.mjs")) {
         ok("statusLine 이미 설정됨");
+        summary.push({ item: "HUD statusLine", status: "✅", detail: "이미 설정됨" });
       } else {
         const nodePath = process.execPath.replace(/\\/g, "/");
         const hudForward = hudPath.replace(/\\/g, "/");
@@ -917,6 +950,7 @@ function cmdSetup(options = {}) {
 
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
         ok("statusLine 설정 완료 — 세션 재시작 후 HUD 표시");
+        summary.push({ item: "HUD statusLine", status: "✅", detail: "설정 완료" });
       }
     } catch (e) {
       throw createCliError(`settings.json 처리 실패: ${e.message}`, {
@@ -928,9 +962,50 @@ function cmdSetup(options = {}) {
     }
   } else {
     warn("HUD 파일 없음 — 먼저 파일 동기화 필요");
+    summary.push({ item: "HUD statusLine", status: "⚠️", detail: "HUD 파일 없음" });
   }
 
-  console.log(`\n${DIM}설치 위치: ${CLAUDE_DIR}${RESET}\n`);
+  // CLI 존재 확인
+  const cliChecks = [
+    { name: "codex", install: "npm i -g @openai/codex" },
+    { name: "gemini", install: "npm i -g @google/gemini-cli" },
+  ];
+  for (const { name, install } of cliChecks) {
+    if (which(name)) {
+      summary.push({ item: `${name} CLI`, status: "✅", detail: "설치됨" });
+    } else {
+      summary.push({ item: `${name} CLI`, status: "⏭️", detail: `미설치 (${install})` });
+    }
+  }
+
+  // Star request (버전 게이팅)
+  const showStar = !fromUpdate && (STAR_PROMPT_VERSIONS.length === 0 || STAR_PROMPT_VERSIONS.includes(PKG.version));
+  if (showStar) {
+    try {
+      execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      try {
+        execFileSync("gh", ["api", "user/starred/tellang/triflux"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        console.log();
+        ok(`이미 함께하고 계시군요. ${AMBER}⭐${RESET}`);
+      } catch {
+        console.log();
+        info(`${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. ${CYAN}https://github.com/tellang/triflux${RESET}`);
+      }
+    } catch {
+      console.log();
+      info(`${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. ${CYAN}https://github.com/tellang/triflux${RESET}`);
+    }
+  }
+
+  // ── 결과 요약 테이블 ──
+  console.log(`\n${BOLD}── 설정 요약 ──${RESET}`);
+  const maxItem = Math.max(...summary.map((s) => s.item.length));
+  for (const { item, status, detail } of summary) {
+    console.log(`  ${status} ${item.padEnd(maxItem)}  ${DIM}${detail}${RESET}`);
+  }
+
+  console.log(`\n${DIM}설치 위치: ${CLAUDE_DIR}${RESET}`);
+  console.log(`${DIM}버전: v${PKG.version}${RESET}\n`);
 }
 
 function addDoctorCheck(report, entry) {
@@ -1849,7 +1924,7 @@ function cmdUpdate() {
     return;
   }
 
-  // 3. setup 재실행 (tfx-route.sh, HUD, 스킬 동기화)
+  // 3. setup 재실행 (파일 동기화, 프로파일, HUD, CLI 확인)
   if (updated) {
     console.log("");
     // 업데이트 후 새 버전 읽기
@@ -1865,18 +1940,17 @@ function cmdUpdate() {
       ok(`버전: v${oldVer} (이미 최신)`);
     }
 
-    // setup 재실행
-    console.log("");
-    info("setup 재실행 중...");
-    cmdSetup();
+    // setup 재실행 — 개선된 cmdSetup()이 Gemini 프로필, CLI 확인, 요약 테이블 포함
+    console.log(`\n${CYAN}── 설정 동기화 ──${RESET}`);
+    cmdSetup({ fromUpdate: true });
 
     if (stoppedHubInfo) {
-      if (startHubAfterUpdate(stoppedHubInfo)) info("hub 재기동 완료");
+      if (startHubAfterUpdate(stoppedHubInfo)) ok("hub 재기동 완료");
       else warn("hub 재기동 실패 — `tfx hub start`로 수동 시작 필요");
     }
   }
 
-  console.log(`${GREEN}${BOLD}업데이트 완료${RESET}\n`);
+  console.log(`${GREEN}${BOLD}✓ 업데이트 완료${RESET}\n`);
 }
 
 function cmdList(options = {}) {

package/hub/team/dashboard-layout.mjs

@@ -3,6 +3,7 @@ const USER_DASHBOARD_LAYOUTS = new Set([
   "split-2col",
   "split-3col",
   "auto",
+  "lite",
 ]);
 
 const DASHBOARD_LAYOUTS = new Set([
@@ -23,6 +24,7 @@ export function parseDashboardLayout(value) {
 
 export function resolveDashboardLayout(value, workerCount = 0) {
   const normalized = normalizeDashboardLayout(value, { allowAuto: true });
+  if (normalized === "lite") return "lite";
   if (normalized !== "auto") return normalized;
   if (workerCount >= 4) return "summary+detail";
   if (workerCount === 3) return "split-3col";

package/hub/team/headless.mjs

@@ -24,6 +24,7 @@ import { getBackend } from "./backend.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
 import { normalizeDashboardAnchor } from "./dashboard-anchor.mjs";
 import { createLogDashboard } from "./tui.mjs";
+import { createLiteDashboard } from "./tui-lite.mjs";
 
 const RESULT_DIR = join(tmpdir(), "tfx-headless");
 
@@ -357,12 +358,15 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
   let tui = null;
   const resolvedLayout = resolveDashboardLayout(dashboardLayout, assignments.length);
   if (dashboard && process.stdout.isTTY) {
-    tui = createLogDashboard({
+    const dashOpts = {
       stream: process.stdout,
       input: process.stdin,
       refreshMs: 200,
       layout: resolvedLayout,
-    });
+    };
+    tui = resolvedLayout === "lite"
+      ? createLiteDashboard(dashOpts)
+      : createLogDashboard(dashOpts);
     tui.setStartTime(Date.now());
     // 초기 워커 상태 등록
     for (let i = 0; i < assignments.length; i++) {

package/hub/team/tui-lite.mjs

@@ -0,0 +1,276 @@
+import { altScreenOff, altScreenOn, BG, bold, box, clearScreen, color, cursorHide, cursorHome, cursorShow, dim, FG, MOCHA, padRight, progressBar, statusBadge, stripAnsi, truncate, wcswidth } from "./ansi.mjs";
+
+const FALLBACK_COLUMNS = 100, FALLBACK_ROWS = 24;
+const VALID_TABS = new Set(["log", "detail", "files"]);
+
+let VERSION = "lite";
+try { const { createRequire } = await import("node:module"); VERSION = createRequire(import.meta.url)("../../package.json").version; } catch {}
+
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+
+function sanitizeBlock(text, rawMode = false) {
+  const value = String(text || "").replace(/\r/g, "");
+  const cleaned = rawMode
+    ? value
+    : value
+        .replace(/```[\s\S]*?(?:```|$)/g, "\n")
+        .replace(/^\s*```.*$/gm, "")
+        .replace(/^(?:PS\s+\S[^\n]*?>|>\s+|\$\s+)[^\n]*/gm, "");
+  return cleaned
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((line) => line !== "--- HANDOFF ---")
+    .join("\n")
+    .trim();
+}
+
+function sanitizeOneLine(text, fallback = "") {
+  return sanitizeBlock(text).replace(/\s+/g, " ").trim() || fallback;
+}
+
+function sanitizeFiles(files) {
+  const list = Array.isArray(files) ? files : String(files || "").split(",");
+  return list.map((entry) => sanitizeOneLine(entry)).filter(Boolean);
+}
+
+function normalizeTokens(tokens) {
+  if (tokens === null || tokens === undefined || tokens === "") return "";
+  if (typeof tokens === "number" && Number.isFinite(tokens)) return tokens;
+  const raw = sanitizeOneLine(tokens);
+  const match = raw.match(/(\d+(?:[.,]\d+)?\s*[kKmM]?)/);
+  return match ? match[1].replace(/\s+/g, "").toLowerCase() : raw;
+}
+
+function formatTokens(tokens) {
+  if (!tokens && tokens !== 0) return "n/a";
+  if (typeof tokens === "number") {
+    if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}m`;
+    if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`;
+  }
+  return String(tokens);
+}
+
+function wrap(text, width) {
+  const limit = Math.max(8, width);
+  const lines = [];
+  for (const rawLine of sanitizeBlock(text).split("\n")) {
+    const words = rawLine.split(/\s+/).filter(Boolean);
+    if (words.length === 0) continue;
+    let current = "";
+    for (const word of words) {
+      const next = current ? `${current} ${word}` : word;
+      if (wcswidth(next) <= limit) {
+        current = next;
+        continue;
+      }
+      if (current) lines.push(current);
+      current = word;
+      while (wcswidth(current) > limit) {
+        lines.push(current.slice(0, limit));
+        current = current.slice(limit);
+      }
+    }
+    if (current) lines.push(current);
+  }
+  return lines;
+}
+
+const runtimeStatus = (worker) => worker?.handoff?.status || worker?.status || "pending";
+
+function normalizeWorkerState(existing = {}, state = {}) {
+  const handoff = state.handoff === undefined
+    ? existing.handoff
+    : {
+        ...(existing.handoff || {}),
+        ...(state.handoff || {}),
+        verdict: state.handoff?.verdict !== undefined ? sanitizeOneLine(state.handoff.verdict) : existing.handoff?.verdict,
+        confidence: state.handoff?.confidence !== undefined ? sanitizeOneLine(state.handoff.confidence) : existing.handoff?.confidence,
+        status: state.handoff?.status !== undefined ? sanitizeOneLine(state.handoff.status) : existing.handoff?.status,
+        files_changed: state.handoff?.files_changed !== undefined ? sanitizeFiles(state.handoff.files_changed) : existing.handoff?.files_changed,
+      };
+  return {
+    ...existing,
+    ...state,
+    cli: state.cli !== undefined ? sanitizeOneLine(state.cli, existing.cli || "codex") : (existing.cli || "codex"),
+    status: state.status !== undefined ? sanitizeOneLine(state.status, existing.status || "pending") : (existing.status || "pending"),
+    snapshot: state.snapshot !== undefined ? sanitizeBlock(state.snapshot) : existing.snapshot,
+    summary: state.summary !== undefined ? sanitizeBlock(state.summary) : existing.summary,
+    detail: state.detail !== undefined ? sanitizeBlock(state.detail) : existing.detail,
+    findings: state.findings !== undefined ? sanitizeFiles(state.findings) : existing.findings,
+    files_changed: state.files_changed !== undefined ? sanitizeFiles(state.files_changed) : existing.files_changed,
+    confidence: state.confidence !== undefined ? sanitizeOneLine(state.confidence) : existing.confidence,
+    tokens: state.tokens !== undefined ? normalizeTokens(state.tokens) : existing.tokens,
+    progress: state.progress !== undefined ? clamp(Number(state.progress) || 0, 0, 1) : existing.progress,
+    handoff,
+  };
+}
+
+function frame(lines, width, border = MOCHA.border) {
+  const body = lines.length ? lines : [dim("내용 없음")];
+  const rendered = box(body.map((line) => padRight(truncate(line, width - 4), width - 4)), width, border);
+  return [rendered.top, ...rendered.body, rendered.bot];
+}
+
+function fitHeight(lines, width, height) {
+  const out = lines.slice(0, Math.max(3, height));
+  while (out.length < Math.max(3, height)) out.push(" ".repeat(width));
+  return out;
+}
+
+function buildHeader(width, names, workers, pipeline, startedAt) {
+  const counts = { ok: 0, partial: 0, failed: 0, running: 0 };
+  for (const name of names) {
+    const status = runtimeStatus(workers.get(name));
+    if (status === "ok" || status === "completed") counts.ok++;
+    else if (status === "partial") counts.partial++;
+    else if (status === "failed") counts.failed++;
+    else if (status === "running" || status === "in_progress") counts.running++;
+  }
+  const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
+  const line1 = color(` triflux ${VERSION} `, FG.black, BG.header)
+    + ` ${bold(`phase ${pipeline.phase || "exec"}`)}`
+    + ` ${dim(`+${elapsed}s`)} ${names.length} workers`;
+  const line2 = `${color(`ok ${counts.ok}`, MOCHA.ok)}  ${color(`partial ${counts.partial}`, MOCHA.partial)}  ${color(`failed ${counts.failed}`, MOCHA.fail)}  ${color(`running ${counts.running}`, MOCHA.executing)}`;
+  return [padRight(line1, width), padRight(line2, width)];
+}
+
+function buildWorkerRail(names, workers, selectedWorker, width) {
+  const lines = names.length
+    ? names.map((name, index) => {
+        const worker = workers.get(name);
+        const status = runtimeStatus(worker);
+        const pct = Math.round(((worker?.progress ?? (status === "completed" ? 1 : 0)) || 0) * 100);
+        const token = worker?.tokens ? ` tok ${formatTokens(worker.tokens)}` : "";
+        const prefix = name === selectedWorker ? color("▶", MOCHA.blue) : dim("·");
+        return `${prefix} ${index + 1}.${name} ${stripAnsi(statusBadge(status))} ${pct}%${token}`;
+      })
+    : [dim("workers 없음")];
+  return frame(lines, width);
+}
+
+function buildDetail(workerName, worker, width, tab, helpVisible) {
+  if (helpVisible) {
+    return frame(
+      [
+        bold("tui-lite"),
+        "selectWorker(name) / setFocusTab(tab) / render()",
+        "tabs: log | detail | files",
+        "toggleDetail(false) 로 상세 패널 숨김",
+      ],
+      width,
+      MOCHA.blue,
+    );
+  }
+  if (!workerName || !worker) return frame([dim("선택된 워커 없음")], width);
+  const detailLines = [
+    bold(workerName),
+    `status ${runtimeStatus(worker)}`,
+    `progress ${Math.round((worker.progress || 0) * 100)}% ${progressBar(Math.round((worker.progress || 0) * 100), 12)}`,
+    `tokens ${formatTokens(worker.tokens)}`,
+    `confidence ${worker.handoff?.confidence || worker.confidence || "n/a"}`,
+    `verdict ${worker.handoff?.verdict || worker.summary || worker.snapshot || "-"}`,
+  ];
+  if (tab === "files") {
+    const files = [...sanitizeFiles(worker.handoff?.files_changed), ...sanitizeFiles(worker.files_changed)];
+    detailLines.push(...(files.length ? files.map((file) => `files ${file}`) : ["files 없음"]));
+  } else if (tab === "detail") {
+    detailLines.push(...wrap(worker.detail || worker.summary || worker.snapshot || "", width - 4));
+  } else {
+    detailLines.push(...wrap(worker.summary || worker.snapshot || worker.detail || "", width - 4));
+  }
+  return frame(detailLines, width, MOCHA.thinking);
+}
+
+export function createLiteDashboard(opts = {}) {
+  const {
+    stream = process.stdout,
+    refreshMs = 1000,
+    columns,
+    rows,
+    layout = "auto",
+    forceTTY = false,
+  } = opts;
+
+  const isTTY = forceTTY || !!stream?.isTTY;
+  const workers = new Map();
+  let pipeline = { phase: "exec", fix_attempt: 0 };
+  let startedAt = Date.now();
+  let timer = null;
+  let closed = false;
+  let frameCount = 0;
+  let selectedWorker = null;
+  let detailExpanded = true;
+  let focusTab = "log";
+  let helpVisible = false;
+
+  const write = (text) => { if (!closed) stream.write(text); };
+  const workerNames = () => [...workers.keys()].sort();
+  const viewportColumns = () => Math.max(48, columns || stream?.columns || process.stdout?.columns || FALLBACK_COLUMNS);
+  const viewportRows = () => Math.max(10, rows || stream?.rows || process.stdout?.rows || FALLBACK_ROWS);
+  const ensureSelection = (names) => { if (names.length && (!selectedWorker || !workers.has(selectedWorker))) selectedWorker = names[0]; };
+
+  function buildRows() {
+    const names = workerNames();
+    ensureSelection(names);
+    const width = viewportColumns();
+    const height = viewportRows();
+    const header = buildHeader(width, names, workers, pipeline, startedAt);
+    const railOnly = !detailExpanded || names.length <= 1 || width < 100 || layout === "single";
+    if (railOnly) {
+      const sections = [header, ...buildWorkerRail(names, workers, selectedWorker, width)];
+      if (detailExpanded) sections.push(...buildDetail(selectedWorker, workers.get(selectedWorker), width, focusTab, helpVisible));
+      return fitHeight(sections, width, height);
+    }
+    const railWidth = Math.max(28, Math.floor(width * 0.32));
+    const detailWidth = width - railWidth - 1;
+    const bodyHeight = Math.max(6, height - header.length);
+    const rail = fitHeight(buildWorkerRail(names, workers, selectedWorker, railWidth), railWidth, bodyHeight);
+    const detail = fitHeight(buildDetail(selectedWorker, workers.get(selectedWorker), detailWidth, focusTab, helpVisible), detailWidth, bodyHeight);
+    return [
+      ...header,
+      ...Array.from({ length: bodyHeight }, (_, index) => `${rail[index]}${dim("│")}${detail[index]}`),
+    ];
+  }
+
+  function render() {
+    if (closed) return;
+    frameCount++;
+    const rowsOut = buildRows();
+    if (isTTY) write(cursorHome + clearScreen + rowsOut.join("\n"));
+    else write(`${rowsOut.join("\n")}\n`);
+  }
+
+  function close() {
+    if (closed) return;
+    if (timer) clearInterval(timer);
+    if (isTTY) write(cursorShow + altScreenOff);
+    closed = true;
+  }
+
+  if (isTTY) write(altScreenOn + cursorHide + clearScreen + cursorHome);
+  if (refreshMs > 0) {
+    timer = setInterval(render, refreshMs);
+    if (timer.unref) timer.unref();
+  }
+
+  return {
+    updateWorker(name, state) { workers.set(name, normalizeWorkerState(workers.get(name), state)); ensureSelection(workerNames()); },
+    updatePipeline(state) { pipeline = { ...pipeline, ...state }; },
+    setStartTime(ms) { startedAt = ms; },
+    selectWorker(name) { if (workers.has(name)) selectedWorker = name; },
+    toggleDetail(force) { detailExpanded = typeof force === "boolean" ? force : !detailExpanded; },
+    render,
+    getWorkers() { return new Map(workers); },
+    getFrameCount() { return frameCount; },
+    getPipelineState() { return { ...pipeline }; },
+    getSelectedWorker() { return selectedWorker; },
+    isDetailExpanded() { return detailExpanded; },
+    getFocusTab() { return focusTab; },
+    setFocusTab(tab) { if (VALID_TABS.has(tab)) focusTab = tab; },
+    getLayout() { return layout; },
+    toggleHelp(force) { helpVisible = typeof force === "boolean" ? force : !helpVisible; },
+    isHelpVisible() { return helpVisible; },
+    close,
+  };
+}

package/hub/team/tui-viewer.mjs

@@ -8,6 +8,7 @@ import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { createLogDashboard } from "./tui.mjs";
+import { createLiteDashboard } from "./tui-lite.mjs";
 import { processHandoff } from "./handoff.mjs";
 import { statusBadge } from "./ansi.mjs";
 
@@ -45,7 +46,8 @@ const MAX_BODY_BYTES = 10240;
 // ── TUI 초기화 ──
 // WT pane에서 spawn 시 process.stdout.isTTY=false일 수 있음
 // forceTTY 시 alternate screen이 WT pane에서 렌더링 안 되는 문제 → append-only 유지
-const tui = createLogDashboard({
+const tuiFactory = LAYOUT === "lite" ? createLiteDashboard : createLogDashboard;
+const tui = tuiFactory({
   refreshMs: 0,          // render 루프를 직접 제어
   stream: process.stdout,
   input: process.stdin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "9.1.0",
+  "version": "9.2.1",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/lib/gemini-profiles.mjs

@@ -0,0 +1,85 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_GEMINI_PROFILES = {
+  model: "gemini-3.1-pro-preview",
+  profiles: {
+    pro31: { model: "gemini-3.1-pro-preview", hint: "3.1 Pro — 플래그십 (1M ctx, 멀티모달)" },
+    flash3: { model: "gemini-3-flash-preview", hint: "3.0 Flash — 빠른 응답, 비용 효율" },
+    pro25: { model: "gemini-2.5-pro", hint: "2.5 Pro — 안정 (추론 강화)" },
+    flash25: { model: "gemini-2.5-flash", hint: "2.5 Flash — 경량 범용" },
+    lite25: { model: "gemini-2.5-flash-lite", hint: "2.5 Flash Lite — 최경량" },
+  },
+};
+
+const DEFAULT_PROFILE_COUNT = Object.keys(DEFAULT_GEMINI_PROFILES.profiles).length;
+
+function ensureGeminiProfiles({
+  geminiDir = join(homedir(), ".gemini"),
+  profilesPath = join(geminiDir, "triflux-profiles.json"),
+} = {}) {
+  try {
+    if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
+
+    if (!existsSync(profilesPath)) {
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    let cfg;
+    try {
+      cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
+    } catch {
+      try { copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`); } catch {}
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) cfg = {};
+    if (!cfg.profiles || typeof cfg.profiles !== "object" || Array.isArray(cfg.profiles)) cfg.profiles = {};
+
+    let added = 0;
+    for (const [name, value] of Object.entries(DEFAULT_GEMINI_PROFILES.profiles)) {
+      if (!cfg.profiles[name]) {
+        cfg.profiles[name] = value;
+        added++;
+      }
+    }
+    if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
+
+    if (added > 0) {
+      writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+    }
+
+    return {
+      ok: true,
+      created: false,
+      added,
+      count: Object.keys(cfg.profiles).length,
+      message: null,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      created: false,
+      added: 0,
+      count: 0,
+      message: error.message,
+    };
+  }
+}
+
+export { DEFAULT_GEMINI_PROFILES, ensureGeminiProfiles };

package/scripts/setup.mjs

@@ -11,6 +11,7 @@ import { spawn, execFileSync } from "child_process";
 import { fileURLToPath } from "url";
 import { cleanupTmpFiles } from "./tmp-cleanup.mjs";
 import { buildAll as buildCacheWarmup } from "./cache-warmup.mjs";
+import { ensureGeminiProfiles } from "./lib/gemini-profiles.mjs";
 
 const PLUGIN_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const CLAUDE_DIR = join(homedir(), ".claude");
@@ -220,6 +221,11 @@ const SYNC_MAP = [
     dst: join(CLAUDE_DIR, "scripts", "lib", "keyword-rules.mjs"),
     label: "lib/keyword-rules.mjs",
   },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "lib", "gemini-profiles.mjs"),
+    dst: join(CLAUDE_DIR, "scripts", "lib", "gemini-profiles.mjs"),
+    label: "lib/gemini-profiles.mjs",
+  },
   {
     src: join(PLUGIN_ROOT, "hub", "team", "agent-map.json"),
     dst: join(CLAUDE_DIR, "hub", "team", "agent-map.json"),
@@ -813,6 +819,13 @@ if (codexProfilesAdded > 0) {
   synced++;
 }
 
+// ── Gemini 프로필 자동 보정 ──
+
+const geminiProfilesAdded = ensureGeminiProfiles().added;
+if (geminiProfilesAdded > 0) {
+  synced++;
+}
+
 // ── MCP 인벤토리 백그라운드 갱신 ──
 
 const mcpCheck = join(PLUGIN_ROOT, "scripts", "mcp-check.mjs");

package/skills/star-prompt/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: star-prompt
+description: >-
+  CLI 프로젝트의 setup/postinstall 흐름에 GitHub 스타 요청 프롬프트를 추가한다.
+  gh CLI 인증 확인 → 이미 스타 여부 감지 → 인터랙티브 confirm → gh API로 자동 스타.
+  Apple 스타일 UX 카피 포함. 'star prompt', '스타 요청', '리포 스타', 'star request',
+  '깃헙 스타 넣어줘', 'star 눌러달라고', '응원 요청' 같은 요청에 사용한다.
+---
+
+# tfx-star-prompt — GitHub Star Request Prompt
+
+CLI 도구의 setup 완료 시점에 GitHub 리포 스타를 요청하는 프롬프트를 추가한다.
+사용자 경험을 해치지 않으면서, 이미 스타한 사용자에겐 감사를 표하고, 아직 안 한 사용자에겐 부담 없이 한 번 물어본다.
+
+## 동작 흐름
+
+```
+gh auth status ─── 실패 → URL만 표시 (비인터랙티브 폴백)
+       │
+       ✓ 인증됨
+       │
+gh api user/starred/{owner}/{repo} ─── 성공 → "이미 함께하고 계시군요. ⭐"
+       │
+       ✗ 미스타
+       │
+confirm("⭐ 하나가 큰 차이를 만듭니다.") ─── N → URL 조용히 표시
+       │
+       Y
+       │
+gh api -X PUT /user/starred/{owner}/{repo} → "함께해 주셔서 감사합니다. ⭐"
+       │
+       실패 → URL 폴백
+```
+
+## 구현 패턴
+
+### 인터랙티브 (TUI / readline confirm)
+
+setup 위저드 완료 후 호출. `confirm()` 으로 Y/n 입력 받고 `gh api`로 자동 스타.
+
+```javascript
+async function starRequest() {
+  let ghOk = false;
+  try {
+    execFileSync("gh", ["auth", "status"], {
+      timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
+    });
+    ghOk = true;
+  } catch {}
+
+  if (!ghOk) {
+    // gh 미설치/미인증 — URL만 표시
+    info(`⭐ 하나가 큰 차이를 만듭니다. https://github.com/{owner}/{repo}`);
+    return;
+  }
+
+  let alreadyStarred = false;
+  try {
+    execFileSync("gh", ["api", "user/starred/{owner}/{repo}"], {
+      timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
+    });
+    alreadyStarred = true;
+  } catch {}
+
+  if (alreadyStarred) {
+    ok(`이미 함께하고 계시군요. ⭐`);
+    return;
+  }
+
+  if (await confirm(`⭐ 하나가 큰 차이를 만듭니다.`, true)) {
+    try {
+      execFileSync("gh", ["api", "-X", "PUT", "/user/starred/{owner}/{repo}"], {
+        timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      ok(`함께해 주셔서 감사합니다. ⭐`);
+    } catch {
+      info(`https://github.com/{owner}/{repo}`);
+    }
+  } else {
+    // 거절 시 URL만 조용히
+    console.log(`     https://github.com/{owner}/{repo}`);
+  }
+}
+```
+
+### 비인터랙티브 (postinstall / CLI banner)
+
+confirm 불가한 환경. 이미 스타 여부만 감지하고 메시지 분기.
+
+```javascript
+try {
+  execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: ["pipe","pipe","pipe"] });
+  try {
+    execFileSync("gh", ["api", "user/starred/{owner}/{repo}"], { timeout: 5000, stdio: ["pipe","pipe","pipe"] });
+    ok(`이미 함께하고 계시군요. ⭐`);
+  } catch {
+    info(`⭐ 하나가 큰 차이를 만듭니다. https://github.com/{owner}/{repo}`);
+  }
+} catch {
+  info(`⭐ 하나가 큰 차이를 만듭니다. https://github.com/{owner}/{repo}`);
+}
+```
+
+## 적용 시 규칙
+
+1. `{owner}/{repo}`를 대상 리포로 치환한다
+2. 프로젝트의 기존 ANSI 컬러 상수(AMBER, CYAN, RESET 등)를 사용한다
+3. setup 완료 직후, 최종 요약 다음에 호출한다 — 핵심 설정 흐름을 방해하지 않는다
+4. 모든 gh 호출은 `timeout: 5000`, `stdio: ["pipe","pipe","pipe"]`로 감싸서 실패해도 setup을 블로킹하지 않는다
+5. 거절 시 죄책감을 주지 않는다 — URL만 조용히 남긴다
+
+## UX 카피 톤
+
+Apple 스타일: 짧고, 자신감 있고, 부담 없이.
+
+| 상황 | 멘트 |
+|------|------|
+| 이미 스타 | `이미 함께하고 계시군요. ⭐` |
+| 요청 | `⭐ 하나가 큰 차이를 만듭니다.` |
+| 수락 후 | `함께해 주셔서 감사합니다. ⭐` |
+| 거절 | URL만 |
+| gh 없음 | `⭐ 하나가 큰 차이를 만듭니다.` + URL |

package/tui/setup.mjs

@@ -11,6 +11,7 @@ import {
   RESET, DIM, BOLD, CYAN, AMBER, GREEN, RED, YELLOW, WHITE, GRAY,
   onExit, showCursor,
 } from "./core.mjs";
+import { DEFAULT_GEMINI_PROFILES } from "../scripts/lib/gemini-profiles.mjs";
 
 const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const CLAUDE_DIR = join(homedir(), ".claude");
@@ -101,20 +102,13 @@ function stepProfiles() {
 function stepGeminiProfiles() {
   const configPath = join(GEMINI_DIR, "triflux-profiles.json");
   if (!existsSync(configPath)) {
-    // 기본 프로필 자동 생성
-    const defaultConfig = {
-      model: "gemini-3.1-pro-preview",
-      profiles: {
-        pro31:   { model: "gemini-3.1-pro-preview",   hint: "3.1 Pro — 플래그십 (1M ctx, 멀티모달)" },
-        flash3:  { model: "gemini-3-flash-preview",   hint: "3.0 Flash — 빠른 응답, 비용 효율" },
-        pro25:   { model: "gemini-2.5-pro",           hint: "2.5 Pro — 안정 (추론 강화)" },
-        flash25: { model: "gemini-2.5-flash",         hint: "2.5 Flash — 경량 범용" },
-        lite25:  { model: "gemini-2.5-flash-lite",    hint: "2.5 Flash Lite — 최경량" },
-      },
-    };
     if (!existsSync(GEMINI_DIR)) mkdirSync(GEMINI_DIR, { recursive: true });
-    writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf8");
-    return { ok: true, detail: "기본 프로필 5개 자동 생성됨", action: "created" };
+    writeFileSync(configPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", "utf8");
+    return {
+      ok: true,
+      detail: `기본 프로필 ${Object.keys(DEFAULT_GEMINI_PROFILES.profiles).length}개 자동 생성됨`,
+      action: "created",
+    };
   }
 
   try {
@@ -326,10 +320,60 @@ function showSummary(results) {
   }
 }
 
+// ── Star Request ──
+
+async function starRequest() {
+  let ghOk = false;
+  try {
+    execFileSync("gh", ["auth", "status"], {
+      timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
+    });
+    ghOk = true;
+  } catch {}
+
+  if (!ghOk) {
+    console.log();
+    info(`${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. ${CYAN}https://github.com/tellang/triflux${RESET}`);
+    console.log();
+    return;
+  }
+
+  // gh 인증됨 — 스타 여부 확인
+  let alreadyStarred = false;
+  try {
+    execFileSync("gh", ["api", "user/starred/tellang/triflux"], {
+      timeout: 5000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"],
+    });
+    alreadyStarred = true;
+  } catch {}
+
+  console.log();
+
+  if (alreadyStarred) {
+    ok(`이미 함께하고 계시군요. ${AMBER}⭐${RESET}`);
+    console.log();
+    return;
+  }
+
+  if (await confirm(`${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다.`, false)) {
+    try {
+      execFileSync("gh", ["api", "-X", "PUT", "/user/starred/tellang/triflux"], {
+        timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      ok(`함께해 주셔서 감사합니다. ${AMBER}⭐${RESET}`);
+    } catch {
+      info(`${CYAN}https://github.com/tellang/triflux${RESET}`);
+    }
+  } else {
+    console.log(`     ${DIM}${CYAN}https://github.com/tellang/triflux${RESET}`);
+  }
+  console.log();
+}
+
 // ── Main Menu ──
 
 const MENU = [
-  { label: "전체 설정 (Full Setup)",   hint: "5단계 순서 실행" },
+  { label: "전체 설정 (Full Setup)",   hint: "6단계 순서 실행" },
   { label: "단계별 선택 (Selective)",   hint: "특정 단계만 실행" },
   { label: "현재 상태 확인 (Status)",   hint: "설정 없이 진단만" },
   { label: "종료",                      hint: "Ctrl+C" },
@@ -357,6 +401,7 @@ async function main() {
       case 0: {
         const results = await runWizard();
         showSummary(results);
+        await starRequest();
         break;
       }