sales-frontend-ju-hong-e 0.0.2

package/dist/be.cjs

@@ -0,0 +1,4446 @@
+#!/usr/bin/env node
+'use strict';
+
+var child_process = require('child_process');
+var fs7 = require('fs');
+var path6 = require('path');
+var util = require('util');
+var fs2 = require('fs/promises');
+var os = require('os');
+var url = require('url');
+var process$1 = require('process');
+var readline = require('readline');
+var posthogNode = require('posthog-node');
+require('crypto');
+require('http');
+var module$1 = require('module');
+require('net');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs7__default = /*#__PURE__*/_interopDefault(fs7);
+var path6__default = /*#__PURE__*/_interopDefault(path6);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var readline__default = /*#__PURE__*/_interopDefault(readline);
+
+var AI_SERVICES = ["codex", "gemini", "claude"];
+var DEFAULT_HISTORY_LIMIT = 5;
+var DEFAULT_HISTORY_CHAR_LIMIT = 14e3;
+var PROMPT_HISTORY_LIMIT = 100;
+var CONVERSATION_HISTORY_SCOPES = [
+  "chat",
+  "commit",
+  "review",
+  "gen-html",
+  "gen-storybook",
+  "local-server",
+  "mcp",
+  "native-command",
+  "security-policy",
+  "show-stream",
+  "service-change"
+];
+var TRACE_MESSAGES = [];
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+function getTimestampParts(now = /* @__PURE__ */ new Date()) {
+  return {
+    year: now.getFullYear(),
+    month: pad(now.getMonth() + 1),
+    day: pad(now.getDate()),
+    hour: pad(now.getHours()),
+    minute: pad(now.getMinutes()),
+    second: pad(now.getSeconds())
+  };
+}
+function getNowString(now = /* @__PURE__ */ new Date()) {
+  const { year, month, day, hour, minute, second } = getTimestampParts(now);
+  return `${year}-${month}-${day}_${hour}-${minute}-${second}`;
+}
+function getHumanReadableNow(now = /* @__PURE__ */ new Date()) {
+  const { year, month, day, hour, minute, second } = getTimestampParts(now);
+  return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+function getStoragePaths(rootDir = process.cwd()) {
+  const baseDir = path6__default.default.join(rootDir, ".ju-hong-e");
+  const codeReviewDir = path6__default.default.join(baseDir, "code-review");
+  const historyDir = path6__default.default.join(baseDir, "ai-history");
+  const mcpDir = path6__default.default.join(baseDir, "mcp");
+  return {
+    baseDir,
+    codeReviewDir,
+    conversationHistoryPath: path6__default.default.join(baseDir, "conversation-history.jsonl"),
+    errorDir: path6__default.default.join(baseDir, "error"),
+    historyDir,
+    historyIndexPath: path6__default.default.join(historyDir, "index.md"),
+    mcpDir,
+    mcpRegistryPath: path6__default.default.join(mcpDir, "servers.json"),
+    promptHistoryPath: path6__default.default.join(baseDir, "prompt-history.json"),
+    rootDir,
+    securityPolicyPath: path6__default.default.join(baseDir, "security-policy.json"),
+    serviceFilePath: path6__default.default.join(baseDir, "service"),
+    servicesDir: path6__default.default.join(historyDir, "services"),
+    streamOutputConfigPath: path6__default.default.join(baseDir, "show-stream.json"),
+    testDir: path6__default.default.join(baseDir, "test"),
+    tmpDir: path6__default.default.join(baseDir, "tmp"),
+    turnsDir: path6__default.default.join(historyDir, "turns")
+  };
+}
+function ensureStorageDirectories(paths) {
+  [paths.baseDir, paths.codeReviewDir, paths.historyDir, paths.turnsDir, paths.servicesDir, paths.testDir, paths.errorDir, paths.tmpDir, paths.mcpDir].forEach((directory) => {
+    fs7__default.default.mkdirSync(directory, { recursive: true });
+  });
+}
+function parseCliArgs(args = process.argv.slice(2)) {
+  const parsed = {
+    help: false,
+    testMode: false,
+    traceMode: false
+  };
+  const getNextValue = (index) => {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+      return "";
+    }
+    return value;
+  };
+  args.forEach((arg, index) => {
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    }
+    if (arg === "--test") {
+      parsed.testMode = true;
+    }
+    if (arg === "--trace") {
+      parsed.traceMode = true;
+    }
+    if (arg === "--model") {
+      parsed.model = getNextValue(index) || void 0;
+    }
+    if (arg === "--service") {
+      const service = getNextValue(index);
+      if (AI_SERVICES.includes(service)) {
+        parsed.service = service;
+      }
+    }
+    if (arg === "--reasoning-effort") {
+      const effort = getNextValue(index);
+      if (["minimal", "low", "medium", "high"].includes(effort)) {
+        parsed.reasoningEffort = effort;
+      }
+    }
+  });
+  return parsed;
+}
+function clearTraceMessages() {
+  TRACE_MESSAGES.length = 0;
+}
+function getTraceMessages() {
+  return [...TRACE_MESSAGES];
+}
+function createTraceLogger(scope, args) {
+  const enabled = args.testMode || args.traceMode;
+  return (step, detail) => {
+    const message = `[${(/* @__PURE__ */ new Date()).toISOString()}][TRACE][${scope}] ${step}${detail ? ` | ${detail}` : ""}`;
+    TRACE_MESSAGES.push(message);
+    if (enabled) {
+      console.log(message);
+    }
+  };
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function stringifyUnknown(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value.toString("utf8");
+  }
+  if (value instanceof Error) {
+    return value.stack || value.message;
+  }
+  return util.inspect(value, { depth: 6, breakLength: 120 });
+}
+function getErrorSummary(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return stringifyUnknown(error) || "Unknown error";
+}
+function serializeError(error) {
+  const serialized = {
+    summary: getErrorSummary(error)
+  };
+  if (error instanceof Error) {
+    serialized.name = error.name;
+    serialized.message = error.message;
+    serialized.stack = error.stack;
+  } else {
+    serialized.value = stringifyUnknown(error);
+  }
+  if (error && typeof error === "object") {
+    const errorLike = error;
+    ["code", "errno", "syscall", "path", "cmd", "status", "signal"].forEach((key) => {
+      if (errorLike[key] !== void 0) {
+        serialized[key] = errorLike[key];
+      }
+    });
+    const stdout2 = stringifyUnknown(errorLike.stdout);
+    if (stdout2) {
+      serialized.stdout = stdout2;
+    }
+    const stderr = stringifyUnknown(errorLike.stderr);
+    if (stderr) {
+      serialized.stderr = stderr;
+    }
+  }
+  return serialized;
+}
+function runGitCommand(rootDir, command) {
+  return child_process.execSync(command, {
+    cwd: rootDir,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 20,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
+}
+function isGitRepository(rootDir) {
+  try {
+    runGitCommand(rootDir, "git rev-parse --show-toplevel");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function captureWorkspaceSnapshot(rootDir) {
+  if (!isGitRepository(rootDir)) {
+    return {
+      available: false,
+      branch: "",
+      diffNameStatus: "",
+      diffStat: "",
+      gitRoot: "",
+      note: "\uD604\uC7AC \uC791\uC5C5 \uACBD\uB85C\uAC00 Git \uC800\uC7A5\uC18C\uAC00 \uC544\uB2D9\uB2C8\uB2E4.",
+      recentCommits: [],
+      statusLines: []
+    };
+  }
+  const gitRoot = runGitCommand(rootDir, "git rev-parse --show-toplevel");
+  const branch = runGitCommand(rootDir, "git branch --show-current");
+  const statusOutput = runGitCommand(rootDir, "git status --short");
+  const diffStat = runGitCommand(rootDir, "git diff --stat");
+  const diffNameStatus = runGitCommand(rootDir, "git diff --name-status");
+  const recentCommits = runGitCommand(rootDir, "git log --oneline -5");
+  return {
+    available: true,
+    branch,
+    diffNameStatus,
+    diffStat,
+    gitRoot,
+    note: "",
+    recentCommits: recentCommits ? recentCommits.split("\n").filter(Boolean) : [],
+    statusLines: statusOutput ? statusOutput.split("\n").filter(Boolean) : []
+  };
+}
+function statusLineToPath(statusLine) {
+  const normalized = statusLine.trim();
+  if (!normalized) {
+    return "";
+  }
+  const pathValue = normalized.slice(3).split(" -> ").pop();
+  return pathValue?.trim() || normalized;
+}
+function diffWorkspaceSnapshots(before, after) {
+  const beforeSet = new Set(before.statusLines);
+  const afterSet = new Set(after.statusLines);
+  const beforeOnly = before.statusLines.filter((line) => !afterSet.has(line));
+  const afterOnly = after.statusLines.filter((line) => !beforeSet.has(line));
+  const touchedFiles = Array.from(
+    new Set([...beforeOnly.map(statusLineToPath), ...afterOnly.map(statusLineToPath)].filter(Boolean))
+  );
+  return {
+    afterOnly,
+    beforeOnly,
+    touchedFiles
+  };
+}
+function formatCodeBlock(content, language = "") {
+  return `\`\`\`${language}
+${content || "(\uC5C6\uC74C)"}
+\`\`\``;
+}
+function formatWorkspaceSnapshot(snapshot) {
+  if (!snapshot.available) {
+    return snapshot.note;
+  }
+  return [
+    `- Git Root: \`${snapshot.gitRoot}\``,
+    `- Branch: \`${snapshot.branch || "(detached)"}\``,
+    "",
+    "### git status --short",
+    formatCodeBlock(snapshot.statusLines.join("\n")),
+    "",
+    "### git diff --stat",
+    formatCodeBlock(snapshot.diffStat),
+    "",
+    "### git diff --name-status",
+    formatCodeBlock(snapshot.diffNameStatus),
+    "",
+    "### \uCD5C\uADFC \uCEE4\uBC0B",
+    formatCodeBlock(snapshot.recentCommits.join("\n"))
+  ].join("\n");
+}
+function formatWorkspaceDelta(delta) {
+  return [
+    "### \uC0C8\uB85C \uAC10\uC9C0\uB41C \uC0C1\uD0DC",
+    formatCodeBlock(delta.afterOnly.join("\n")),
+    "",
+    "### \uC0AC\uB77C\uC9C4 \uC774\uC804 \uC0C1\uD0DC",
+    formatCodeBlock(delta.beforeOnly.join("\n")),
+    "",
+    "### \uC601\uD5A5 \uD30C\uC77C",
+    formatCodeBlock(delta.touchedFiles.join("\n"))
+  ].join("\n");
+}
+function safeExcerpt(content, limit = 3e3) {
+  if (!content) {
+    return "";
+  }
+  if (content.length <= limit) {
+    return content;
+  }
+  return `${content.slice(0, limit)}
+... (truncated ${content.length - limit} chars)`;
+}
+function isConversationHistoryScope(value) {
+  return CONVERSATION_HISTORY_SCOPES.includes(value);
+}
+function parseConversationHistoryEntry(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    if (typeof parsed.timestamp !== "string" || typeof parsed.title !== "string" || typeof parsed.summary !== "string" || typeof parsed.scope !== "string" || typeof parsed.service !== "string") {
+      return void 0;
+    }
+    if (!isConversationHistoryScope(parsed.scope) || !AI_SERVICES.includes(parsed.service)) {
+      return void 0;
+    }
+    const previousService = typeof parsed.previousService === "string" && (parsed.previousService === "" || AI_SERVICES.includes(parsed.previousService)) ? parsed.previousService : void 0;
+    const nextService = typeof parsed.nextService === "string" && AI_SERVICES.includes(parsed.nextService) ? parsed.nextService : void 0;
+    return {
+      input: typeof parsed.input === "string" ? parsed.input : void 0,
+      nextService,
+      output: typeof parsed.output === "string" ? parsed.output : void 0,
+      previousService,
+      scope: parsed.scope,
+      service: parsed.service,
+      summary: parsed.summary,
+      timestamp: parsed.timestamp,
+      title: parsed.title
+    };
+  } catch {
+    return void 0;
+  }
+}
+function appendConversationHistory(paths, entry) {
+  const normalizedEntry = {
+    ...entry,
+    summary: entry.summary.trim() || entry.title.trim(),
+    timestamp: entry.timestamp || getHumanReadableNow(),
+    title: entry.title.trim()
+  };
+  fs7__default.default.appendFileSync(paths.conversationHistoryPath, `${JSON.stringify(normalizedEntry)}
+`, "utf8");
+  return normalizedEntry;
+}
+function loadConversationHistory(paths, limit = DEFAULT_HISTORY_LIMIT) {
+  if (!fs7__default.default.existsSync(paths.conversationHistoryPath)) {
+    return [];
+  }
+  const lines = fs7__default.default.readFileSync(paths.conversationHistoryPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length === 0) {
+    return [];
+  }
+  return lines.map(parseConversationHistoryEntry).filter((entry) => entry !== void 0).slice(-limit);
+}
+function formatConversationHistoryEntry(entry, limit) {
+  const inputLimit = Math.max(180, Math.floor(limit * 0.35));
+  const outputLimit = Math.max(220, limit - inputLimit);
+  const lines = [`## ${entry.timestamp} | ${entry.scope} | ${entry.service}`, `\uC81C\uBAA9: ${entry.title}`];
+  if (entry.scope === "service-change") {
+    lines.push(`\uC11C\uBE44\uC2A4 \uBCC0\uACBD: ${entry.previousService || "(\uC5C6\uC74C)"} -> ${entry.nextService || entry.service}`);
+    lines.push(`\uC694\uC57D: ${safeExcerpt(entry.summary, outputLimit)}`);
+    return lines.join("\n");
+  }
+  if (entry.input) {
+    lines.push("");
+    lines.push("\uC0AC\uC6A9\uC790 \uC785\uB825");
+    lines.push(formatCodeBlock(safeExcerpt(entry.input, inputLimit)));
+  }
+  if (entry.output) {
+    lines.push("");
+    lines.push("\uC774\uC804 \uACB0\uACFC \uC694\uC57D");
+    lines.push(formatCodeBlock(safeExcerpt(entry.output, outputLimit)));
+  } else if (entry.summary) {
+    lines.push("");
+    lines.push("\uACB0\uACFC \uC694\uC57D");
+    lines.push(formatCodeBlock(safeExcerpt(entry.summary, outputLimit)));
+  }
+  return lines.join("\n");
+}
+function formatConversationHistory(entries, charLimit) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const entryLimit = Math.max(400, Math.floor(charLimit / Math.max(entries.length, 1)));
+  const content = entries.map((entry) => formatConversationHistoryEntry(entry, entryLimit)).join("\n\n");
+  return safeExcerpt(content, charLimit);
+}
+function loadRecentHistoryContext(paths, limit = DEFAULT_HISTORY_LIMIT, charLimit = DEFAULT_HISTORY_CHAR_LIMIT) {
+  const conversationEntries = loadConversationHistory(paths, limit);
+  return formatConversationHistory(conversationEntries, charLimit);
+}
+function getAvailableFilePath(directory, baseName, extension) {
+  const first = path6__default.default.join(directory, `${baseName}${extension}`);
+  if (!fs7__default.default.existsSync(first)) {
+    return first;
+  }
+  let next = first;
+  let count = 1;
+  while (fs7__default.default.existsSync(next)) {
+    next = path6__default.default.join(directory, `${baseName}-${count}${extension}`);
+    if (!fs7__default.default.existsSync(next)) {
+      break;
+    }
+    count += 1;
+  }
+  return next;
+}
+function readSavedService(paths) {
+  if (!fs7__default.default.existsSync(paths.serviceFilePath)) {
+    return "";
+  }
+  const service = fs7__default.default.readFileSync(paths.serviceFilePath, "utf8").trim();
+  return AI_SERVICES.includes(service) ? service : "";
+}
+function saveService(paths, service) {
+  fs7__default.default.writeFileSync(paths.serviceFilePath, `${service}
+`, "utf8");
+}
+function loadPromptHistory(paths, limit = PROMPT_HISTORY_LIMIT) {
+  if (!fs7__default.default.existsSync(paths.promptHistoryPath)) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(fs7__default.default.readFileSync(paths.promptHistoryPath, "utf8"));
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean).slice(-limit);
+  } catch {
+    return [];
+  }
+}
+function savePromptHistory(paths, history) {
+  const normalized = history.map((entry) => entry.trim()).filter(Boolean).slice(-100);
+  fs7__default.default.writeFileSync(paths.promptHistoryPath, JSON.stringify(normalized, null, 2), "utf8");
+}
+function appendPromptHistory(paths, value) {
+  const normalizedValue = value.trim();
+  if (!normalizedValue) {
+    return loadPromptHistory(paths);
+  }
+  const existing = loadPromptHistory(paths).filter((entry) => entry !== normalizedValue);
+  const nextHistory = [...existing, normalizedValue].slice(-100);
+  savePromptHistory(paths, nextHistory);
+  return nextHistory;
+}
+function appendHistoryIndex(paths, summary, relativeFilePath) {
+  const line = `- ${getHumanReadableNow()} | ${summary} | file: \`${relativeFilePath}\`
+`;
+  fs7__default.default.appendFileSync(paths.historyIndexPath, line, "utf8");
+}
+function renderSections(sections = []) {
+  if (sections.length === 0) {
+    return "";
+  }
+  return sections.map((section) => `
+## ${section.heading}
+
+${section.markdown}
+`).join("\n");
+}
+function writeTurnHistory(paths, record) {
+  const baseName = `${getNowString()}-${record.scope}`;
+  const filePath = getAvailableFilePath(paths.turnsDir, baseName, ".md");
+  const markdown = `# ${record.title}
+
+- \uC2DC\uAC01: ${getHumanReadableNow()}
+- scope: \`${record.scope}\`
+- service: \`${record.service}\`
+- skipped: \`${record.skipped}\`
+
+## \uC0AC\uC6A9\uC790 \uC785\uB825
+
+${formatCodeBlock(record.input)}
+
+## AI \uC751\uB2F5
+
+${record.output || "(\uC751\uB2F5 \uC5C6\uC74C)"}
+
+## \uCD5C\uADFC \uD788\uC2A4\uD1A0\uB9AC \uC8FC\uC785
+
+${formatCodeBlock(record.historyContext)}
+
+## \uC2E4\uD589 \uBA85\uB839\uC5B4 \uBBF8\uB9AC\uBCF4\uAE30
+
+${formatCodeBlock(record.previewCommand, "sh")}
+
+## \uC791\uC5C5 \uC804 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4
+
+${formatWorkspaceSnapshot(record.workspaceBefore)}
+
+## \uC791\uC5C5 \uD6C4 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4
+
+${formatWorkspaceSnapshot(record.workspaceAfter)}
+
+## \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uBCC0\uD654
+
+${formatWorkspaceDelta(record.workspaceDelta)}${renderSections(record.extraSections)}
+`;
+  fs7__default.default.writeFileSync(filePath, markdown, "utf8");
+  appendHistoryIndex(paths, `${record.scope} | ${record.service} | ${record.title}`, path6__default.default.relative(paths.rootDir, filePath));
+  return filePath;
+}
+function writeServiceChangeHistory(paths, previousService, nextService, historyContext) {
+  const baseName = `${getNowString()}-service-change`;
+  const filePath = getAvailableFilePath(paths.servicesDir, baseName, ".md");
+  const markdown = `# Service Change
+
+- \uC2DC\uAC01: ${getHumanReadableNow()}
+- \uC774\uC804 \uC11C\uBE44\uC2A4: \`${previousService || "(\uC5C6\uC74C)"}\`
+- \uB2E4\uC74C \uC11C\uBE44\uC2A4: \`${nextService}\`
+
+## \uC8FC\uC785 \uC608\uC815 \uD788\uC2A4\uD1A0\uB9AC
+
+${formatCodeBlock(historyContext)}
+`;
+  fs7__default.default.writeFileSync(filePath, markdown, "utf8");
+  appendHistoryIndex(paths, `service-change | ${previousService || "(\uC5C6\uC74C)"} -> ${nextService}`, path6__default.default.relative(paths.rootDir, filePath));
+  return filePath;
+}
+function writeTestReport(paths, title, markdown) {
+  const filePath = getAvailableFilePath(paths.testDir, `${getNowString()}-test`, ".md");
+  const content = `# ${title}
+
+- \uC2DC\uAC01: ${getHumanReadableNow()}
+
+${markdown}
+`;
+  fs7__default.default.writeFileSync(filePath, content, "utf8");
+  return filePath;
+}
+function writeErrorReport(paths, error, options) {
+  const filePath = getAvailableFilePath(paths.errorDir, `${getNowString()}-error`, ".md");
+  const serializedError = serializeError(error);
+  const traceMessages = options.traceMessages ?? getTraceMessages();
+  const markdown = `# Error Report
+
+- \uC2DC\uAC01: ${getHumanReadableNow()}
+- scope: \`${options.scope}\`
+- \uC791\uC5C5 \uACBD\uB85C: \`${paths.rootDir}\`
+- \uC2E4\uD589 \uC778\uC790: \`${JSON.stringify(options.args ?? process.argv.slice(2))}\`
+
+## Summary
+
+${serializedError.summary || "Unknown error"}
+
+## Error
+
+\`\`\`json
+${JSON.stringify(serializedError, null, 2)}
+\`\`\`
+
+## Trace
+
+\`\`\`json
+${JSON.stringify(traceMessages, null, 2)}
+\`\`\`${renderSections(options.extraSections)}
+`;
+  fs7__default.default.writeFileSync(filePath, markdown, "utf8");
+  return filePath;
+}
+
+// src/common/prompts/assets/chat/forms/chat-response.md
+var chat_response_default = "- \uBCC0\uACBD\uD55C \uD30C\uC77C \uBAA9\uB85D\n- \uD575\uC2EC \uACB0\uACFC 3\uC904 \uC774\uB0B4 \uC694\uC57D\n- \uCD94\uAC00 \uD655\uC778\uC774 \uD544\uC694\uD55C \uD56D\uBAA9\n";
+
+// src/common/prompts/assets/chat/instructions/chat-request.md
+var chat_request_default = "\uC0AC\uC6A9\uC790 \uC694\uCCAD\uC744 \uD574\uACB0\uD55C\uB2E4.\n\n- \uD544\uC694\uD55C \uACBD\uC6B0 \uC9C1\uC811 \uD30C\uC77C\uC744 \uC218\uC815\uD55C\uB2E4.\n- \uCF54\uB4DC\uB098 \uAD6C\uC870\uB97C \uC124\uBA85\uD560 \uB54C\uB294 \uC2E4\uC81C \uBCC0\uACBD \uB0B4\uC6A9 \uAE30\uC900\uC73C\uB85C \uC815\uB9AC\uD55C\uB2E4.\n- \uC751\uB2F5\uC740 \uC2E4\uD589 \uAC00\uB2A5\uD55C \uB2E4\uC74C \uC561\uC158\uC774 \uB4DC\uB7EC\uB098\uB3C4\uB85D \uC791\uC131\uD55C\uB2E4.\n";
+
+// src/common/prompts/assets/common/base-instructions.md
+var base_instructions_default = "- \uBAA8\uB4E0 \uC751\uB2F5\uC740 \uD55C\uAD6D\uC5B4\uB85C \uC791\uC131\uD55C\uB2E4.\n- \uD604\uC7AC \uC791\uC5C5 \uB514\uB809\uD130\uB9AC \uAE30\uC900\uC73C\uB85C \uD544\uC694\uD55C \uD30C\uC77C\uC744 \uC9C1\uC811 \uC218\uC815\uD560 \uC218 \uC788\uC73C\uBA74 \uC218\uC815\uD55C\uB2E4.\n- \uC218\uC815\uC774 \uC5B4\uB835\uAC70\uB098 \uB3C4\uAD6C \uC81C\uC57D\uC774 \uC788\uC73C\uBA74 \uC0DD\uC131\uD574\uC57C \uD560 \uD30C\uC77C\uACFC \uCF54\uB4DC \uB0B4\uC6A9\uC744 \uBA85\uD655\uD788 \uC81C\uC2DC\uD55C\uB2E4.\n- \uBCC0\uACBD\uC0AC\uD56D\uC740 \uC720\uC9C0\uBCF4\uC218\uC640 \uD655\uC7A5\uC131\uC744 \uC6B0\uC120\uC73C\uB85C \uACE0\uB824\uD55C\uB2E4.\n";
+
+// src/common/prompts/index.ts
+function buildCommonPrompt(options) {
+  return {
+    forms: options.forms,
+    historyContext: options.historyContext,
+    instructions: [base_instructions_default, ...options.instructions || []],
+    rules: options.rules,
+    sections: options.sections,
+    service: options.service,
+    title: options.title,
+    workspaceSnapshot: options.workspaceSnapshot
+  };
+}
+function buildChatPrompt(options) {
+  return buildCommonPrompt({
+    forms: [chat_response_default],
+    historyContext: options.historyContext,
+    instructions: [chat_request_default],
+    sections: [
+      {
+        heading: "\uC0AC\uC6A9\uC790 \uC694\uCCAD",
+        markdown: options.userInput
+      }
+    ],
+    service: options.service,
+    title: "Ju-hong-e Chat",
+    workspaceSnapshot: options.workspaceSnapshot
+  });
+}
+var execFileAsync = util.promisify(child_process.execFile);
+var MAX_REFERENCED_RESOURCES = 16;
+var MAX_TEXT_LENGTH = 12e4;
+var MAX_FILE_BUFFER = 1024 * 1024 * 4;
+var MAX_REMOTE_BUFFER = 1024 * 1024 * 5;
+var COMMAND_TIMEOUT_MS = 15e3;
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cjs",
+  ".conf",
+  ".css",
+  ".csv",
+  ".d.ts",
+  ".env",
+  ".html",
+  ".htm",
+  ".ini",
+  ".java",
+  ".js",
+  ".json",
+  ".jsx",
+  ".kt",
+  ".less",
+  ".log",
+  ".md",
+  ".mjs",
+  ".php",
+  ".py",
+  ".rb",
+  ".rs",
+  ".scss",
+  ".sh",
+  ".sql",
+  ".svg",
+  ".swift",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".zsh"
+]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".bmp", ".gif", ".heic", ".jpeg", ".jpg", ".png", ".tif", ".tiff", ".webp"]);
+var TEXTUTIL_EXTENSIONS = /* @__PURE__ */ new Set([".doc", ".docx", ".odt", ".rtf", ".rtfd", ".webarchive"]);
+var REMOTE_URL_PATTERN = /\bhttps?:\/\/[^\s<>()"'`]+/gi;
+var FILE_URL_PATTERN = /\bfile:\/\/[^\s<>()"'`]+/gi;
+var LOCAL_PATH_WITH_PREFIX_PATTERN = /(?:^|[\s("'`])((?:~|\.{1,2}\/|\/)[^\s<>()"'`]+)/g;
+var RELATIVE_PATH_WITH_SEPARATOR_PATTERN = /(?:^|[\s("'`])((?:[A-Za-z0-9._-]+\/)+[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+)/g;
+function trimTrailingPunctuation(value) {
+  return value.replace(/[),.;:!?`'"\]}]+$/g, "").trim();
+}
+function limitTextContent(value) {
+  if (!value) {
+    return "";
+  }
+  const normalized = value.replace(/\0/g, "").trim();
+  if (normalized.length <= MAX_TEXT_LENGTH) {
+    return normalized;
+  }
+  return normalized.slice(0, MAX_TEXT_LENGTH);
+}
+function isLikelyTextMimeType(mimeType) {
+  return mimeType.startsWith("text/") || mimeType.includes("json") || mimeType.includes("javascript") || mimeType.includes("xml") || mimeType.includes("yaml") || mimeType.includes("svg");
+}
+function isLikelyImageMimeType(mimeType) {
+  return mimeType.startsWith("image/");
+}
+function collectMatches(text, pattern) {
+  const values = [];
+  for (const match of text.matchAll(pattern)) {
+    const candidate = trimTrailingPunctuation((match[1] || match[0] || "").trim());
+    if (!candidate) {
+      continue;
+    }
+    values.push(candidate);
+  }
+  return values;
+}
+function resolveLocalResource(value, rootDir) {
+  try {
+    if (value.startsWith("file://")) {
+      return path6__default.default.normalize(url.fileURLToPath(value));
+    }
+  } catch {
+    return void 0;
+  }
+  if (value.startsWith("~")) {
+    return path6__default.default.normalize(path6__default.default.join(os__default.default.homedir(), value.slice(1)));
+  }
+  if (path6__default.default.isAbsolute(value)) {
+    return path6__default.default.normalize(value);
+  }
+  if (!rootDir) {
+    return void 0;
+  }
+  return path6__default.default.normalize(path6__default.default.resolve(rootDir, value));
+}
+function toReferencedResources(values, rootDir) {
+  const seen = /* @__PURE__ */ new Set();
+  const resources = [];
+  for (const value of values) {
+    for (const candidate of collectMatches(value, REMOTE_URL_PATTERN)) {
+      const normalized = trimTrailingPunctuation(candidate);
+      if (!normalized || seen.has(normalized)) {
+        continue;
+      }
+      seen.add(normalized);
+      resources.push({
+        kind: "remote-url",
+        location: normalized
+      });
+    }
+    for (const candidate of [...collectMatches(value, FILE_URL_PATTERN), ...collectMatches(value, LOCAL_PATH_WITH_PREFIX_PATTERN), ...collectMatches(value, RELATIVE_PATH_WITH_SEPARATOR_PATTERN)]) {
+      const resolved = resolveLocalResource(candidate, rootDir);
+      if (!resolved || seen.has(resolved)) {
+        continue;
+      }
+      seen.add(resolved);
+      resources.push({
+        kind: "local-file",
+        location: resolved
+      });
+    }
+    if (resources.length >= MAX_REFERENCED_RESOURCES) {
+      return resources.slice(0, MAX_REFERENCED_RESOURCES);
+    }
+  }
+  return resources;
+}
+async function detectLocalMimeType(filePath) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("file", ["--brief", "--mime-type", filePath], {
+      maxBuffer: 64 * 1024,
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    return stdout2.trim().toLowerCase();
+  } catch {
+    return "";
+  }
+}
+async function readTextFile(filePath) {
+  try {
+    const buffer = await fs2__default.default.readFile(filePath);
+    return limitTextContent(buffer.subarray(0, MAX_FILE_BUFFER).toString("utf8"));
+  } catch {
+    return "";
+  }
+}
+async function readTextViaTextutil(filePath) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("textutil", ["-convert", "txt", "-stdout", filePath], {
+      maxBuffer: MAX_FILE_BUFFER,
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    return limitTextContent(stdout2);
+  } catch {
+    return "";
+  }
+}
+async function readTextViaMetadata(filePath) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("mdls", ["-raw", "-name", "kMDItemTextContent", filePath], {
+      maxBuffer: MAX_FILE_BUFFER,
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    const normalized = stdout2.trim();
+    if (!normalized || normalized === "(null)") {
+      return "";
+    }
+    return limitTextContent(normalized);
+  } catch {
+    return "";
+  }
+}
+async function readTextViaStrings(filePath) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("strings", ["-n", "6", filePath], {
+      maxBuffer: MAX_FILE_BUFFER,
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    return limitTextContent(stdout2);
+  } catch {
+    return "";
+  }
+}
+async function readTextViaTesseract(filePath) {
+  try {
+    const { stdout: stdout2 } = await execFileAsync("tesseract", [filePath, "stdout", "--psm", "6"], {
+      maxBuffer: MAX_FILE_BUFFER,
+      timeout: COMMAND_TIMEOUT_MS
+    });
+    return limitTextContent(stdout2);
+  } catch {
+    return "";
+  }
+}
+async function readLocalResourceText(filePath) {
+  try {
+    const stats = await fs2__default.default.stat(filePath);
+    if (!stats.isFile()) {
+      return "";
+    }
+  } catch {
+    return "";
+  }
+  const extension = path6__default.default.extname(filePath).toLowerCase();
+  const mimeType = await detectLocalMimeType(filePath);
+  if (IMAGE_EXTENSIONS.has(extension) || isLikelyImageMimeType(mimeType)) {
+    return await readTextViaTesseract(filePath) || await readTextViaMetadata(filePath);
+  }
+  if (TEXT_EXTENSIONS.has(extension) || isLikelyTextMimeType(mimeType)) {
+    return readTextFile(filePath);
+  }
+  if (TEXTUTIL_EXTENSIONS.has(extension)) {
+    return await readTextViaTextutil(filePath) || await readTextViaMetadata(filePath);
+  }
+  return await readTextViaMetadata(filePath) || await readTextViaStrings(filePath);
+}
+async function readRemoteBuffer(location) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), COMMAND_TIMEOUT_MS);
+  try {
+    const response = await fetch(location, {
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const contentLength = Number(response.headers.get("content-length") || "0");
+    if (contentLength > MAX_REMOTE_BUFFER) {
+      return void 0;
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    if (buffer.byteLength > MAX_REMOTE_BUFFER) {
+      return void 0;
+    }
+    return {
+      buffer,
+      contentType: (response.headers.get("content-type") || "").toLowerCase()
+    };
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function withTemporaryFile(extension, buffer, task) {
+  const tempPath = path6__default.default.join(os__default.default.tmpdir(), `ju-hong-e-security-${Date.now()}-${Math.random().toString(16).slice(2)}${extension}`);
+  try {
+    await fs2__default.default.writeFile(tempPath, buffer);
+    return await task(tempPath);
+  } finally {
+    await fs2__default.default.rm(tempPath, { force: true });
+  }
+}
+async function readRemoteResourceText(location) {
+  const response = await readRemoteBuffer(location);
+  if (!response) {
+    return "";
+  }
+  let extension = "";
+  try {
+    extension = path6__default.default.extname(new URL(location).pathname).toLowerCase();
+  } catch {
+    extension = "";
+  }
+  if (IMAGE_EXTENSIONS.has(extension) || isLikelyImageMimeType(response.contentType)) {
+    return withTemporaryFile(extension || ".img", response.buffer, readTextViaTesseract);
+  }
+  if (TEXT_EXTENSIONS.has(extension) || isLikelyTextMimeType(response.contentType)) {
+    return limitTextContent(response.buffer.toString("utf8"));
+  }
+  if (TEXTUTIL_EXTENSIONS.has(extension)) {
+    return withTemporaryFile(extension, response.buffer, async (filePath) => await readTextViaTextutil(filePath) || await readTextViaMetadata(filePath));
+  }
+  return "";
+}
+async function collectReferencedResourceContents(values, rootDir) {
+  const resources = toReferencedResources(values, rootDir);
+  const contents = [];
+  for (const resource of resources) {
+    const content = resource.kind === "local-file" ? await readLocalResourceText(resource.location) : await readRemoteResourceText(resource.location);
+    if (!content) {
+      continue;
+    }
+    contents.push({
+      location: resource.location,
+      value: content
+    });
+  }
+  return contents;
+}
+
+// src/common/security/registry.ts
+var securityRegistryState = globalThis.__JUHONG_E_SECURITY_REGISTRY__ ?? (globalThis.__JUHONG_E_SECURITY_REGISTRY__ = {
+  patternRules: /* @__PURE__ */ new Map(),
+  validatorRules: /* @__PURE__ */ new Map()
+});
+var GLOBAL_PATTERN_RULES = securityRegistryState.patternRules;
+var GLOBAL_VALIDATOR_RULES = securityRegistryState.validatorRules;
+function resetRegex(pattern) {
+  pattern.lastIndex = 0;
+  return pattern;
+}
+function collectStringValues(value) {
+  if (typeof value === "string") {
+    return value.trim() ? [value] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => collectStringValues(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).flatMap((item) => collectStringValues(item));
+  }
+  return [];
+}
+function collectCandidateValues(value, source) {
+  return collectStringValues(value).map((entry) => ({
+    source,
+    value: entry
+  }));
+}
+async function collectSecurityStringValues(payload, options) {
+  const directValues = [
+    ...collectCandidateValues(payload.input, "input"),
+    ...collectCandidateValues(payload.rawCommand, "rawCommand"),
+    ...collectCandidateValues(payload.rawArgs, "rawArgs"),
+    ...collectCandidateValues(payload.args, "args"),
+    ...options.inspectPrompt ? collectCandidateValues(payload.prompt, "prompt") : []
+  ];
+  if (!options.inspectResources) {
+    return directValues;
+  }
+  const referencedContents = await collectReferencedResourceContents(
+    directValues.map((entry) => entry.value),
+    payload.promptRootDir
+  );
+  return [
+    ...directValues,
+    ...referencedContents.map(
+      (entry) => ({
+        location: entry.location,
+        source: "resource",
+        value: entry.value
+      })
+    )
+  ];
+}
+function getPatternRules(config) {
+  return [...GLOBAL_PATTERN_RULES.values(), ...config?.patterns || []];
+}
+function getValidatorRules(config) {
+  return [...GLOBAL_VALIDATOR_RULES.values(), ...config?.validators || []];
+}
+function addGlobalSecurityPattern(rule) {
+  GLOBAL_PATTERN_RULES.set(rule.name, rule);
+}
+async function validateSecurityPayload(payload, config, options = {
+  inspectPrompt: true,
+  inspectResources: true,
+  mode: "prompt-with-resources"
+}) {
+  const stringValues = await collectSecurityStringValues(payload, options);
+  for (const rule of getPatternRules(config)) {
+    const matched = findMatchedCandidate(stringValues, rule);
+    if (matched) {
+      return {
+        detail: {
+          location: matched.location,
+          matchedText: matched.matchedText,
+          source: matched.source
+        },
+        message: rule.message,
+        ok: false,
+        ruleName: rule.name
+      };
+    }
+  }
+  for (const rule of getValidatorRules(config)) {
+    const result = await rule.validate(payload);
+    if (result === true) {
+      continue;
+    }
+    return {
+      detail: {
+        source: payload.prompt ? "prompt" : payload.input ? "input" : "args"
+      },
+      message: typeof result === "string" && result.trim() ? result : rule.message,
+      ok: false,
+      ruleName: rule.name
+    };
+  }
+  return {
+    ok: true
+  };
+}
+function findMatchedCandidate(stringValues, rule) {
+  for (const candidate of stringValues) {
+    const matchedText = extractMatchedText(candidate.value, rule);
+    if (!matchedText) {
+      continue;
+    }
+    return {
+      location: candidate.location,
+      matchedText,
+      source: candidate.source
+    };
+  }
+  return void 0;
+}
+function extractMatchedText(value, rule) {
+  const match = resetRegex(rule.pattern).exec(value);
+  if (!match?.[0]) {
+    return "";
+  }
+  const formattedMatch = rule.formatMatch ? rule.formatMatch(match[0]) : match[0];
+  return safeExcerpt(formattedMatch, 120);
+}
+
+// src/common/security/default-rules.ts
+var initialized = false;
+function formatResidentRegistrationNumber(matchedText) {
+  const digits = matchedText.replace(/\D/g, "");
+  if (digits.length !== 13) {
+    return `${matchedText.slice(0, 3)}***`;
+  }
+  return `${digits.slice(0, 6)}-${digits[6]}******`;
+}
+function ensureDefaultSecurityRules() {
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+  addGlobalSecurityPattern({
+    formatMatch: formatResidentRegistrationNumber,
+    message: "\uBCF4\uC548 \uC815\uCC45\uC5D0 \uC758\uD574 \uC8FC\uBBFC\uB4F1\uB85D\uBC88\uD638 \uD615\uD0DC\uC758 \uAC12\uC774 \uD3EC\uD568\uB41C \uC785\uB825\uC740 \uC2E4\uD589\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    name: "resident-registration-number",
+    pattern: /\b\d{6}[- ]?[1-4]\d{6}\b/
+  });
+}
+var DEFAULT_SECURITY_POLICY_MODE = "prompt-with-resources";
+var SECURITY_POLICY_OPTIONS = [
+  {
+    description: "\uBCF4\uC548 \uAC80\uC0AC\uB97C \uC644\uC804\uD788 \uBE44\uD65C\uC131\uD654\uD569\uB2C8\uB2E4. \uBBFC\uAC10\uC815\uBCF4\uAC00 \uD3EC\uD568\uB418\uC5B4\uB3C4 \uCC28\uB2E8\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    label: "\uBCF4\uC548 \uAC80\uC0AC \uC0AC\uC6A9 \uC548 \uD568",
+    mode: "disabled",
+    summary: "\uBCF4\uC548 \uAC80\uC0AC \uBE44\uD65C\uC131\uD654"
+  },
+  {
+    description: "\uC0AC\uC6A9\uC790 \uC785\uB825\uACFC \uBA85\uB839 \uC778\uC790\uB9CC \uAC80\uC0AC\uD569\uB2C8\uB2E4. \uD504\uB86C\uD504\uD2B8 \uBCF8\uBB38\uACFC \uCC38\uC870 \uB9AC\uC18C\uC2A4\uB294 \uC77D\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    label: "\uC785\uB825/\uBA85\uB839\uB9CC \uAC80\uC0AC",
+    mode: "input-only",
+    summary: "\uC785\uB825/\uBA85\uB839 \uBB38\uC790\uC5F4\uB9CC \uAC80\uC0AC"
+  },
+  {
+    description: "\uC785\uB825\uACFC AI \uD504\uB86C\uD504\uD2B8 \uBB38\uC790\uC5F4\uAE4C\uC9C0 \uAC80\uC0AC\uD569\uB2C8\uB2E4. \uACBD\uB85C/URL\uC774 \uAC00\uB9AC\uD0A4\uB294 \uB0B4\uC6A9\uC740 \uC77D\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+    label: "\uD504\uB86C\uD504\uD2B8 \uD14D\uC2A4\uD2B8\uAE4C\uC9C0 \uAC80\uC0AC",
+    mode: "prompt-only",
+    summary: "\uD504\uB86C\uD504\uD2B8 \uBB38\uC790\uC5F4\uAE4C\uC9C0 \uAC80\uC0AC"
+  },
+  {
+    description: "\uC785\uB825, \uD504\uB86C\uD504\uD2B8, \uACBD\uB85C/URL\uC774 \uAC00\uB9AC\uD0A4\uB294 \uCC38\uC870 \uB9AC\uC18C\uC2A4 \uB0B4\uC6A9\uAE4C\uC9C0 \uD568\uAED8 \uAC80\uC0AC\uD569\uB2C8\uB2E4.",
+    label: "\uD504\uB86C\uD504\uD2B8\uC640 \uCC38\uC870 \uB9AC\uC18C\uC2A4\uAE4C\uC9C0 \uC2EC\uCE35 \uAC80\uC0AC",
+    mode: "prompt-with-resources",
+    summary: "\uD504\uB86C\uD504\uD2B8\uC640 \uCC38\uC870 \uB9AC\uC18C\uC2A4\uAE4C\uC9C0 \uC2EC\uCE35 \uAC80\uC0AC"
+  }
+];
+function createDefaultSecurityPolicy() {
+  return {
+    mode: DEFAULT_SECURITY_POLICY_MODE
+  };
+}
+function isSecurityPolicyMode(value) {
+  return SECURITY_POLICY_OPTIONS.some((option) => option.mode === value);
+}
+function readSecurityPolicy(paths) {
+  if (!paths?.securityPolicyPath || !fs7__default.default.existsSync(paths.securityPolicyPath)) {
+    return createDefaultSecurityPolicy();
+  }
+  try {
+    const parsed = JSON.parse(fs7__default.default.readFileSync(paths.securityPolicyPath, "utf8"));
+    if (!isSecurityPolicyMode(parsed.mode)) {
+      return createDefaultSecurityPolicy();
+    }
+    return {
+      mode: parsed.mode
+    };
+  } catch {
+    return createDefaultSecurityPolicy();
+  }
+}
+function getSecurityPolicyOption(mode) {
+  return SECURITY_POLICY_OPTIONS.find((option) => option.mode === mode) || SECURITY_POLICY_OPTIONS.at(-1);
+}
+function describeSecurityPolicyMode(mode) {
+  return getSecurityPolicyOption(mode).label;
+}
+function isSecurityPolicyEnabled(mode) {
+  return mode !== "disabled";
+}
+function resolveSecurityValidationOptions(mode) {
+  switch (mode) {
+    case "disabled":
+      return {
+        inspectPrompt: false,
+        inspectResources: false,
+        mode
+      };
+    case "input-only":
+      return {
+        inspectPrompt: false,
+        inspectResources: false,
+        mode
+      };
+    case "prompt-only":
+      return {
+        inspectPrompt: true,
+        inspectResources: false,
+        mode
+      };
+    case "prompt-with-resources":
+    default:
+      return {
+        inspectPrompt: true,
+        inspectResources: true,
+        mode
+      };
+  }
+}
+
+// src/common/security/guard.ts
+function toSecuritySourceLabel(source, location) {
+  switch (source) {
+    case "input":
+      return "\uC0AC\uC6A9\uC790 \uC785\uB825";
+    case "rawCommand":
+      return "\uC6D0\uBCF8 \uBA85\uB839\uC5B4";
+    case "rawArgs":
+      return "\uC6D0\uBCF8 \uBA85\uB839 \uC778\uC790";
+    case "args":
+      return "\uBA85\uB839 \uC778\uC790";
+    case "prompt":
+      return "AI \uD504\uB86C\uD504\uD2B8";
+    case "resource":
+      return location ? `\uCC38\uC870 \uB9AC\uC18C\uC2A4 (${location})` : "\uCC38\uC870 \uB9AC\uC18C\uC2A4";
+    default:
+      return source;
+  }
+}
+function buildSecurityBlockSections(result, policyModeLabel) {
+  const detailLines = [`- policyMode: ${policyModeLabel}`, `- rule: \`${result.ruleName}\``, `- message: ${result.message}`];
+  if (result.detail) {
+    detailLines.push(`- source: ${toSecuritySourceLabel(result.detail.source, result.detail.location)}`);
+    if (result.detail.matchedText) {
+      detailLines.push(`- matched: \`${result.detail.matchedText}\``);
+    }
+  }
+  return [
+    {
+      heading: "Security Block",
+      markdown: detailLines.join("\n")
+    }
+  ];
+}
+function buildSecurityBlockUserMessage(result, policyModeLabel, errorReportPath) {
+  const lines = ["\uBCF4\uC548 \uC815\uCC45\uC5D0 \uC758\uD574 \uC694\uCCAD\uC744 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4.", result.message, `- \uD604\uC7AC \uC815\uCC45: ${policyModeLabel}`, `- \uBCF4\uC548 \uADDC\uCE59: \`${result.ruleName}\``];
+  if (result.detail) {
+    lines.push(`- \uAC10\uC9C0 \uC704\uCE58: ${toSecuritySourceLabel(result.detail.source, result.detail.location)}`);
+    if (result.detail.matchedText) {
+      lines.push(`- \uAC10\uC9C0 \uB0B4\uC6A9: \`${result.detail.matchedText}\``);
+    }
+  }
+  if (errorReportPath) {
+    lines.push(`- \uC5D0\uB7EC \uB9AC\uD3EC\uD2B8: ${errorReportPath}`);
+  }
+  return lines.join("\n");
+}
+async function guardSecurityPayload(options) {
+  ensureDefaultSecurityRules();
+  const policy = readSecurityPolicy(options.paths);
+  const policyModeLabel = describeSecurityPolicyMode(policy.mode);
+  if (!isSecurityPolicyEnabled(policy.mode)) {
+    options.trace("security:skip", `${options.traceLabel} | ${policy.mode}`);
+    return {
+      ok: true
+    };
+  }
+  const validationOptions = resolveSecurityValidationOptions(policy.mode);
+  const result = await validateSecurityPayload(options.payload, options.config, validationOptions);
+  if (!result.ok) {
+    options.trace("security:block", `${options.traceLabel} | ${result.ruleName}`);
+    const errorReportPath = options.paths ? writeErrorReport(
+      options.paths,
+      {
+        detail: result.detail,
+        message: result.message,
+        name: "SecurityPolicyBlockedError",
+        payload: {
+          command: options.payload.command,
+          requestedService: options.payload.requestedService,
+          service: options.payload.service
+        },
+        ruleName: result.ruleName
+      },
+      {
+        extraSections: buildSecurityBlockSections(result, policyModeLabel),
+        scope: options.reportScope || `security:${options.traceLabel}`
+      }
+    ) : void 0;
+    const userMessage = buildSecurityBlockUserMessage(result, policyModeLabel, errorReportPath);
+    console.error(userMessage);
+    return {
+      ...result,
+      errorReportPath,
+      userMessage
+    };
+  }
+  return result;
+}
+var POSTHOG_API_KEY = "phc_MX929Nca94SLcOo7b5Mdvhv9KQi7lSESFNKRhAJRKi9";
+var POSTHOG_HOST = "https://us.i.posthog.com";
+var POSTHOG_SHUTDOWN_TIMEOUT_MS = 5e3;
+var telemetryRuntimeState = globalThis.__JU_HONG_E_POSTHOG_RUNTIME_STATE__ ?? (globalThis.__JU_HONG_E_POSTHOG_RUNTIME_STATE__ = {});
+function getPostHogClient() {
+  if (!telemetryRuntimeState.posthogClient) {
+    telemetryRuntimeState.posthogClient = new posthogNode.PostHog(POSTHOG_API_KEY, {
+      host: POSTHOG_HOST
+    });
+  }
+  return telemetryRuntimeState.posthogClient;
+}
+function readGitConfigValue(rootDir, configKey) {
+  if (!isGitRepository(rootDir)) {
+    return null;
+  }
+  try {
+    return runGitCommand(rootDir, `git config --get ${configKey}`) || null;
+  } catch {
+    return null;
+  }
+}
+function resolveDistinctId(gitUserName, gitUserEmail) {
+  if (gitUserEmail) {
+    return `git-email:${gitUserEmail}`;
+  }
+  if (gitUserName) {
+    return `git-name:${gitUserName}`;
+  }
+  try {
+    const currentUser = os.userInfo();
+    return `os-user:${currentUser.username}@${os.hostname()}`;
+  } catch {
+    return `host:${os.hostname()}`;
+  }
+}
+function resolveGitTelemetryMetadata(rootDir) {
+  const gitUserName = readGitConfigValue(rootDir, "user.name");
+  const gitUserEmail = readGitConfigValue(rootDir, "user.email");
+  return {
+    distinctId: resolveDistinctId(gitUserName, gitUserEmail),
+    gitUserEmail,
+    gitUserName
+  };
+}
+function resolveUserIpAddressValue() {
+  const ipAddresses = /* @__PURE__ */ new Set();
+  Object.values(os.networkInterfaces()).forEach((records) => {
+    records?.forEach((record) => {
+      if (!record || record.internal) {
+        return;
+      }
+      ipAddresses.add(record.address);
+    });
+  });
+  return [...ipAddresses].join(", ");
+}
+function buildCommandParameterProperties(args) {
+  const parameterProperties = {};
+  if (args.length === 0) {
+    parameterProperties["\uBA85\uB839\uC5B4\uC5D0\uC0AC\uC6A9\uB41C\uD30C\uB77C\uBBF8\uD1301"] = null;
+    return parameterProperties;
+  }
+  args.forEach((arg, index) => {
+    parameterProperties[`\uBA85\uB839\uC5B4\uC5D0\uC0AC\uC6A9\uB41C\uD30C\uB77C\uBBF8\uD130${index + 1}`] = arg;
+  });
+  return parameterProperties;
+}
+function beginSlashCommandTelemetryInputCollection(initialArgs) {
+  telemetryRuntimeState.slashCommandTelemetryInputValues = [...initialArgs];
+}
+function appendSlashCommandTelemetryInputValue(value) {
+  if (!telemetryRuntimeState.slashCommandTelemetryInputValues) {
+    return;
+  }
+  telemetryRuntimeState.slashCommandTelemetryInputValues.push(...normalizeSlashCommandTelemetryValues(value));
+}
+function endSlashCommandTelemetryInputCollection() {
+  const values = [...telemetryRuntimeState.slashCommandTelemetryInputValues || []];
+  telemetryRuntimeState.slashCommandTelemetryInputValues = void 0;
+  return values;
+}
+function normalizeSlashCommandTelemetryValues(value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (value === null) {
+    return [null];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => normalizeSlashCommandTelemetryValues(item));
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return [String(value)];
+  }
+  if (typeof value === "object") {
+    const objectValue = value;
+    if (typeof objectValue.url === "string" && objectValue.url) {
+      return [objectValue.url];
+    }
+    if (typeof objectValue.hash === "string" && objectValue.hash) {
+      return [objectValue.hash];
+    }
+    if (typeof objectValue.name === "string" && objectValue.name) {
+      return [objectValue.name];
+    }
+    if (typeof objectValue.label === "string" && objectValue.label) {
+      return [objectValue.label];
+    }
+    try {
+      return [JSON.stringify(objectValue)];
+    } catch {
+      return ["[object]"];
+    }
+  }
+  return [String(value)];
+}
+function trackSlashCommandExecution(options) {
+  try {
+    const gitMetadata = resolveGitTelemetryMetadata(options.rootDir);
+    getPostHogClient().capture({
+      distinctId: gitMetadata.distinctId,
+      event: options.command,
+      properties: {
+        "userinfo-git-user-email": gitMetadata.gitUserEmail,
+        "userinfo-git-user-name": gitMetadata.gitUserName,
+        "userinfo-ip": resolveUserIpAddressValue(),
+        "command-kind": options.kind,
+        "command-service": options.service,
+        "command-status": options.status,
+        "requested-service": options.requestedService ?? null,
+        ...buildCommandParameterProperties(options.args)
+      }
+    });
+    options.trace?.("posthog:slash-command:capture", `${options.command} status=${options.status}`);
+  } catch (error) {
+    options.trace?.("posthog:slash-command:skip", getErrorSummary(error));
+  }
+}
+async function shutdownPostHogClient() {
+  if (!telemetryRuntimeState.posthogClient) {
+    return;
+  }
+  if (!telemetryRuntimeState.shutdownPromise) {
+    const client = telemetryRuntimeState.posthogClient;
+    telemetryRuntimeState.shutdownPromise = Promise.resolve(client.shutdown(POSTHOG_SHUTDOWN_TIMEOUT_MS)).catch(() => void 0).finally(() => {
+      telemetryRuntimeState.posthogClient = void 0;
+      telemetryRuntimeState.shutdownPromise = void 0;
+    });
+  }
+  await telemetryRuntimeState.shutdownPromise;
+}
+
+// src/common/core/cancellation.ts
+var USER_CANCELLED_ERROR_CODE = "JUHONG_E_USER_CANCELLED";
+var USER_TERMINATED_ERROR_CODE = "JUHONG_E_USER_TERMINATED";
+function createUserCancelledError(message = "\uC0AC\uC6A9\uC790\uAC00 \uD604\uC7AC \uC791\uC5C5\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4.") {
+  const error = new Error(message);
+  error.name = "UserCancelledError";
+  error.code = USER_CANCELLED_ERROR_CODE;
+  return error;
+}
+function isUserCancelledError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === USER_CANCELLED_ERROR_CODE
+  );
+}
+function createUserTerminatedError(message = "\uC0AC\uC6A9\uC790\uAC00 \uC138\uC158 \uC885\uB8CC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4.") {
+  const error = new Error(message);
+  error.name = "UserTerminatedError";
+  error.code = USER_TERMINATED_ERROR_CODE;
+  return error;
+}
+function isUserTerminatedError(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === USER_TERMINATED_ERROR_CODE
+  );
+}
+
+// src/common/ui/index.ts
+var ANSI = {
+  blue: "\x1B[34m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  gray: "\x1B[90m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+var ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+var COMBINING_MARK_PATTERN = /\p{Mark}/u;
+var GRAPHEME_SEGMENTER = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter("ko", { granularity: "grapheme" }) : null;
+var STATUS_FRAMES = ["-", "\\", "|", "/"];
+function colorize(text, color) {
+  return `${color}${text}${ANSI.reset}`;
+}
+function formatStatusPrefix(title) {
+  return `${colorize(`[${title}]`, `${ANSI.bold}${ANSI.cyan}`)}`;
+}
+function formatElapsed(startedAt) {
+  return `${Math.max(0, Math.floor((Date.now() - startedAt) / 1e3))}s`;
+}
+function buildStatusRenderLayout(prefix, body) {
+  return buildPromptRenderLayout(`${prefix} `, body);
+}
+function clearRenderedStatus(previousState) {
+  if (previousState?.totalLines && previousState.totalLines > 1) {
+    readline__default.default.moveCursor(process$1.stdout, 0, -(previousState.totalLines - 1));
+  }
+  readline__default.default.cursorTo(process$1.stdout, 0);
+  readline__default.default.clearScreenDown(process$1.stdout);
+}
+function renderStatusLayout(layout, previousState) {
+  clearRenderedStatus(previousState);
+  process$1.stdout.write(layout.lines.join("\n"));
+  return {
+    totalLines: layout.totalLines
+  };
+}
+function createSessionActionStatus(title) {
+  const prefix = formatStatusPrefix(title);
+  const print = (message) => {
+    console.log(`${prefix} ${message}`);
+  };
+  return {
+    fail(message) {
+      print(colorize(message, ANSI.red));
+    },
+    step(message) {
+      print(message);
+    },
+    async track(message, task) {
+      if (!process$1.stdout.isTTY) {
+        print(`${message}...`);
+        return task();
+      }
+      const startedAt = Date.now();
+      let frameIndex = 0;
+      let renderState;
+      const render = () => {
+        const frame = STATUS_FRAMES[frameIndex % STATUS_FRAMES.length];
+        frameIndex += 1;
+        renderState = renderStatusLayout(buildStatusRenderLayout(`${prefix} ${frame}`, `${message} (${formatElapsed(startedAt)})`), renderState);
+      };
+      render();
+      const timer = setInterval(render, 120);
+      try {
+        const result = await task();
+        clearInterval(timer);
+        renderState = renderStatusLayout(
+          buildStatusRenderLayout(`${prefix} done`, `${message} (${formatElapsed(startedAt)})`),
+          renderState
+        );
+        process$1.stdout.write("\n");
+        return result;
+      } catch (error) {
+        clearInterval(timer);
+        renderState = renderStatusLayout(
+          buildStatusRenderLayout(`${prefix} fail`, `${message} (${formatElapsed(startedAt)})`),
+          renderState
+        );
+        process$1.stdout.write("\n");
+        throw error;
+      }
+    }
+  };
+}
+function segmentGraphemes(value) {
+  if (!GRAPHEME_SEGMENTER) {
+    return [...value];
+  }
+  return [...GRAPHEME_SEGMENTER.segment(value)].map(({ segment }) => segment);
+}
+function getGraphemeWidth(grapheme) {
+  let width = 0;
+  for (const character of grapheme) {
+    const codePoint = character.codePointAt(0);
+    if (!codePoint || COMBINING_MARK_PATTERN.test(character) || codePoint === 8205) {
+      continue;
+    }
+    if (codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999) {
+      continue;
+    }
+    if (isWideCodePoint(codePoint) || isEmojiCodePoint(codePoint)) {
+      width = Math.max(width, 2);
+      continue;
+    }
+    width = Math.max(width, 1);
+  }
+  return width;
+}
+function tokenizeVisibleText(value) {
+  const tokens = [];
+  let lastIndex = 0;
+  for (const match of value.matchAll(ANSI_PATTERN)) {
+    const index = match.index ?? 0;
+    if (index > lastIndex) {
+      tokens.push(...tokenizePlainText(value.slice(lastIndex, index)));
+    }
+    tokens.push({
+      value: match[0],
+      visibleWidth: 0
+    });
+    lastIndex = index + match[0].length;
+  }
+  if (lastIndex < value.length) {
+    tokens.push(...tokenizePlainText(value.slice(lastIndex)));
+  }
+  return tokens;
+}
+function tokenizePlainText(value) {
+  return segmentGraphemes(value).map((segment) => ({
+    value: segment,
+    visibleWidth: getGraphemeWidth(segment)
+  }));
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12871 && codePoint !== 12351 || codePoint >= 12880 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42182 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65131 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127488 && codePoint <= 127569 || codePoint >= 131072 && codePoint <= 262141);
+}
+function isEmojiCodePoint(codePoint) {
+  return codePoint >= 127462 && codePoint <= 127487 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 9728 && codePoint <= 10175;
+}
+function visibleLength(value) {
+  return tokenizeVisibleText(value).reduce((total, token) => total + token.visibleWidth, 0);
+}
+function sliceVisible(value, width) {
+  if (width <= 0) {
+    return "";
+  }
+  let currentWidth = 0;
+  let output = "";
+  let truncated = false;
+  let containsAnsi = false;
+  for (const token of tokenizeVisibleText(value)) {
+    if (token.visibleWidth === 0) {
+      output += token.value;
+      containsAnsi = true;
+      continue;
+    }
+    if (currentWidth + token.visibleWidth > width) {
+      truncated = true;
+      break;
+    }
+    output += token.value;
+    currentWidth += token.visibleWidth;
+  }
+  if (truncated && containsAnsi && !output.endsWith(ANSI.reset)) {
+    output += ANSI.reset;
+  }
+  return output;
+}
+function padVisible(value, width) {
+  const slicedValue = sliceVisible(value, width);
+  const length = visibleLength(slicedValue);
+  if (length >= width) {
+    return slicedValue;
+  }
+  return `${slicedValue}${" ".repeat(width - length)}`;
+}
+function getViewportWidth() {
+  const columns = process$1.stdout.columns || 100;
+  return Math.max(Math.min(columns - 2, 108), 4);
+}
+function getTerminalColumns() {
+  return Math.max(process$1.stdout.columns || 100, 4);
+}
+function renderBadge(text, tone) {
+  const theme = tone === "service" ? ANSI.cyan : tone === "accent" ? ANSI.green : tone === "warn" ? ANSI.yellow : ANSI.gray;
+  return colorize(`[${text}]`, theme);
+}
+function createBox(title, lines, footerLines = []) {
+  const contentLines = lines.length > 0 ? lines : [""];
+  const footer = footerLines.length > 0 ? ["", ...footerLines] : [];
+  const width = getViewportWidth();
+  const top = `+${"-".repeat(width - 2)}+`;
+  const titleLine = `| ${padVisible(colorize(title, ANSI.bold), width - 4)} |`;
+  const body = [...contentLines, ...footer].map((line) => `| ${padVisible(line, width - 4)} |`);
+  return [top, titleLine, top, ...body, top];
+}
+function renderScreenBox(title, lines, footerLines = []) {
+  console.clear();
+  console.log(createBox(title, lines, footerLines).join("\n"));
+}
+function getPromptPrefix(service, testMode = false, traceMode = false) {
+  return [
+    colorize("ju-hong-e", `${ANSI.bold}${ANSI.cyan}`),
+    renderBadge(service, "service"),
+    testMode ? renderBadge("TEST", "warn") : "",
+    traceMode ? renderBadge("TRACE", "muted") : ""
+  ].filter(Boolean).join(" ");
+}
+function isSlashCommandQuery(input) {
+  const trimmed = input.trimStart();
+  return trimmed.startsWith("/") || /^\[(codex|gemini|claude)\]\s+\/?/i.test(trimmed);
+}
+function getVisibleCommandOptions(commands, input) {
+  if (!isSlashCommandQuery(input)) {
+    return [];
+  }
+  const keyword = input.toLowerCase();
+  return commands.filter((command) => {
+    const candidates = [command.command, command.insertValue, ...command.matchKeywords || []].filter((candidate) => Boolean(candidate)).map((candidate) => candidate.toLowerCase());
+    return candidates.some((candidate) => candidate.startsWith(keyword));
+  });
+}
+function renderCommandPalette(commands, cursor) {
+  const windowSize = 8;
+  const start = Math.max(0, Math.min(cursor - Math.floor(windowSize / 2), Math.max(commands.length - windowSize, 0)));
+  const visible = commands.slice(start, start + windowSize);
+  return createBox(
+    "Slash Commands",
+    visible.map((command, index) => {
+      const commandIndex = start + index;
+      const prefix = cursor === commandIndex ? colorize(">", ANSI.green) : " ";
+      const label = cursor === commandIndex ? colorize(command.command, ANSI.green) : command.command;
+      const description = colorize(command.description, ANSI.gray);
+      return `${prefix} ${padVisible(label, 28)} ${description}`;
+    }),
+    [
+      `${colorize("\uD45C\uC2DC \uBC94\uC704", ANSI.gray)} ${start + 1}-${Math.min(start + visible.length, commands.length)} / ${commands.length}`,
+      `${colorize("Tab", ANSI.yellow)} \uC120\uD0DD \uC801\uC6A9`,
+      `${colorize("Up/Down", ANSI.yellow)} \uBA85\uB839 \uC774\uB3D9`,
+      `${colorize("Shift+Up/Down", ANSI.yellow)} \uD788\uC2A4\uD1A0\uB9AC \uC774\uB3D9`,
+      `${colorize("ESC", ANSI.yellow)} \uD604\uC7AC \uC785\uB825 \uC9C0\uC6B0\uAE30`,
+      `${colorize("Ctrl+C", ANSI.yellow)} \uC138\uC158 \uC885\uB8CC`,
+      `${colorize("Enter", ANSI.yellow)} \uD604\uC7AC \uC785\uB825 \uC2E4\uD589`
+    ]
+  );
+}
+function commitInteractiveLine(prefix, buffer) {
+  readline__default.default.cursorTo(process$1.stdout, 0);
+  readline__default.default.clearScreenDown(process$1.stdout);
+  process$1.stdout.write(`${prefix} ${colorize(">", ANSI.blue)} ${buffer}
+`);
+}
+function wrapPlainText(value, firstLineWidth, continuationLineWidth) {
+  const renderedLines = [];
+  const safeFirstLineWidth = Math.max(firstLineWidth, 1);
+  const safeContinuationLineWidth = Math.max(continuationLineWidth, 1);
+  const normalizedValue = value.replace(/\r\n?/g, "\n");
+  const pushWrappedLine = (line) => {
+    if (line.length === 0) {
+      renderedLines.push("");
+      return;
+    }
+    let currentLine = "";
+    let currentWidth = 0;
+    let currentLineWidth = renderedLines.length === 0 ? safeFirstLineWidth : safeContinuationLineWidth;
+    for (const segment of segmentGraphemes(line)) {
+      const segmentWidth = Math.max(getGraphemeWidth(segment), 1);
+      if (currentLine && currentWidth + segmentWidth > currentLineWidth) {
+        renderedLines.push(currentLine);
+        currentLine = "";
+        currentWidth = 0;
+        currentLineWidth = safeContinuationLineWidth;
+      }
+      currentLine += segment;
+      currentWidth += segmentWidth;
+    }
+    renderedLines.push(currentLine);
+  };
+  normalizedValue.split("\n").forEach(pushWrappedLine);
+  return renderedLines.length > 0 ? renderedLines : [""];
+}
+function buildPromptRenderLayout(promptLabel, buffer, placeholder) {
+  const columns = getTerminalColumns();
+  const promptLabelWidth = visibleLength(promptLabel);
+  const continuationIndentWidth = Math.min(promptLabelWidth, Math.max(columns - 1, 0));
+  const continuationIndent = " ".repeat(continuationIndentWidth);
+  const firstLineWidth = Math.max(columns - promptLabelWidth, 1);
+  const continuationLineWidth = Math.max(columns - continuationIndentWidth, 1);
+  const hasBuffer = buffer.length > 0;
+  const contentLines = hasBuffer ? wrapPlainText(buffer, firstLineWidth, continuationLineWidth) : wrapPlainText(placeholder || "", firstLineWidth, continuationLineWidth);
+  const cursorLines = hasBuffer ? contentLines : [""];
+  const renderedPromptLines = contentLines.map((line, index) => {
+    const linePrefix = index === 0 ? promptLabel : continuationIndent;
+    return `${linePrefix}${hasBuffer ? line : colorize(line, ANSI.dim)}`;
+  });
+  const activeCursorLine = cursorLines.at(-1) || "";
+  const activeCursorLinePrefixWidth = cursorLines.length <= 1 ? promptLabelWidth : continuationIndentWidth;
+  return {
+    cursorColumn: activeCursorLinePrefixWidth + visibleLength(activeCursorLine),
+    cursorRowOffset: Math.max(cursorLines.length - 1, 0),
+    lines: renderedPromptLines,
+    totalLines: renderedPromptLines.length
+  };
+}
+function clearRenderedPrompt(previousState) {
+  if (previousState?.cursorRowOffset) {
+    readline__default.default.moveCursor(process$1.stdout, 0, -previousState.cursorRowOffset);
+  }
+  readline__default.default.cursorTo(process$1.stdout, 0);
+  readline__default.default.clearScreenDown(process$1.stdout);
+}
+function renderPromptLayout(layout, previousState) {
+  clearRenderedPrompt(previousState);
+  process$1.stdout.write(layout.lines.join("\n"));
+  const linesBelowCursor = layout.totalLines - 1 - layout.cursorRowOffset;
+  if (linesBelowCursor > 0) {
+    readline__default.default.moveCursor(process$1.stdout, 0, -linesBelowCursor);
+  }
+  readline__default.default.cursorTo(process$1.stdout, layout.cursorColumn);
+  return {
+    cursorRowOffset: layout.cursorRowOffset
+  };
+}
+function renderInteractivePrompt(prefix, buffer, commands, commandCursor, testMode = false, previousState) {
+  const promptLabel = `${prefix} ${colorize(">", ANSI.blue)} `;
+  const paletteLines = commands.length > 0 ? renderCommandPalette(commands, commandCursor) : [];
+  const hintLines = commands.length === 0 ? wrapPlainText("Tip: '/' \uB85C \uBA85\uB839 \uBA54\uB274\uB97C \uC5F4\uACE0, \uC11C\uBE44\uC2A4 \uBA85\uB839\uC740 [service] prefix\uB85C \uC801\uC6A9\uB429\uB2C8\uB2E4.", getTerminalColumns(), getTerminalColumns()).map(
+    (line) => colorize(line, ANSI.gray)
+  ) : [];
+  const promptLayout = buildPromptRenderLayout(promptLabel, buffer, "\uBA54\uC2DC\uC9C0\uB97C \uC785\uB825\uD558\uC138\uC694. '/' \uB85C \uBA85\uB839 \uBA54\uB274 \uC5F4\uAE30");
+  const lines = [...promptLayout.lines, ...hintLines, ...paletteLines];
+  if (testMode && !buffer && commands.length === 0) {
+    process$1.stdout.write("");
+  }
+  return renderPromptLayout(
+    {
+      ...promptLayout,
+      lines,
+      totalLines: lines.length
+    },
+    previousState
+  );
+}
+function restoreHistoryBuffer(history, historyCursor) {
+  if (historyCursor < 0 || historyCursor >= history.length) {
+    return "";
+  }
+  return history[historyCursor] || "";
+}
+function getHistoryNavigationDirection(key) {
+  if (key.shift && key.name === "up") {
+    return "up";
+  }
+  if (key.shift && key.name === "down") {
+    return "down";
+  }
+  return null;
+}
+function printSessionBanner(options) {
+  const commandSummary = options.commands.map((command) => `${command.command} ${colorize("-", ANSI.gray)} ${command.description}`);
+  console.log(
+    createBox(
+      "Ju-hong-e Interactive Session( \uD55C\uD654\uC0DD\uBA85 \uD1B5\uD569 AI-Tool )",
+      [
+        `${colorize("Service", ANSI.gray)} ${renderBadge(options.service, "service")}`,
+        `${colorize("Mode", ANSI.gray)} ${options.testMode ? renderBadge("TEST", "warn") : renderBadge("LIVE", "accent")}${options.traceMode ? ` ${renderBadge("TRACE", "muted")}` : ""}`,
+        `${colorize("AI Stream", ANSI.gray)} ${options.streamOutputEnabled ? renderBadge("ON", "accent") : renderBadge("OFF", "muted")}`,
+        "",
+        ...commandSummary
+      ],
+      [
+        colorize("Slash \uBA85\uB839\uC740 '/' \uC785\uB825 \uC2DC \uBCFC \uC218 \uC788\uACE0, \uC11C\uBE44\uC2A4 \uACE0\uC720 \uBA85\uB839\uC740 [service] prefix\uB85C \uD45C\uC2DC\uB429\uB2C8\uB2E4.", ANSI.gray),
+        colorize("\uC2E4\uC2DC\uAC04 \uC751\uB2F5 \uCD9C\uB825\uC740 /show-stream \uC73C\uB85C \uCF1C\uACE0 \uB04C \uC218 \uC788\uC2B5\uB2C8\uB2E4.", ANSI.gray),
+        colorize("ESC\uB294 \uD604\uC7AC \uC791\uC5C5 \uCDE8\uC18C, Ctrl+C\uB294 \uC138\uC158 \uC885\uB8CC\uC785\uB2C8\uB2E4.", ANSI.gray)
+      ]
+    ).join("\n")
+  );
+}
+function promptSessionInput(options) {
+  return new Promise((resolve, reject) => {
+    const { stdin } = process;
+    const rawState = "isRaw" in stdin ? Boolean(stdin.isRaw) : false;
+    const prefix = getPromptPrefix(options.service, options.testMode, options.traceMode);
+    let buffer = "";
+    let historyCursor = -1;
+    let historyDraft = "";
+    let commandCursor = 0;
+    let renderState;
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeyPress);
+      if (stdin.isTTY) {
+        stdin.setRawMode(rawState);
+      }
+      stdin.pause();
+    };
+    const applySelectedCommand = () => {
+      const commands = getVisibleCommandOptions(options.commands, buffer);
+      const selectedCommand = commands[commandCursor];
+      if (!selectedCommand) {
+        return false;
+      }
+      buffer = selectedCommand.insertValue || selectedCommand.command;
+      commandCursor = 0;
+      historyCursor = -1;
+      historyDraft = "";
+      return true;
+    };
+    const render = () => {
+      const commands = getVisibleCommandOptions(options.commands, buffer);
+      commandCursor = Math.max(0, Math.min(commandCursor, Math.max(commands.length - 1, 0)));
+      renderState = renderInteractivePrompt(prefix, buffer, commands, commandCursor, options.testMode, renderState);
+    };
+    const moveHistory = (direction) => {
+      if (options.history.length === 0) {
+        return;
+      }
+      if (historyCursor === -1) {
+        historyDraft = buffer;
+      }
+      if (direction === "up") {
+        historyCursor = historyCursor === -1 ? options.history.length - 1 : Math.max(historyCursor - 1, 0);
+        buffer = restoreHistoryBuffer(options.history, historyCursor);
+        return;
+      }
+      if (historyCursor === -1) {
+        return;
+      }
+      if (historyCursor >= options.history.length - 1) {
+        historyCursor = -1;
+        buffer = historyDraft;
+        return;
+      }
+      historyCursor += 1;
+      buffer = restoreHistoryBuffer(options.history, historyCursor);
+    };
+    const onKeyPress = (input, key) => {
+      const visibleCommands = getVisibleCommandOptions(options.commands, buffer);
+      const historyDirection = getHistoryNavigationDirection(key);
+      if (key.ctrl && key.name === "c") {
+        clearRenderedPrompt(renderState);
+        cleanup();
+        reject(createUserTerminatedError("\uC0AC\uC6A9\uC790\uAC00 \uC138\uC158 \uC885\uB8CC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4."));
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        if (buffer.trim() === "/" && visibleCommands.length > 0) {
+          applySelectedCommand();
+          render();
+          return;
+        }
+        const resolved = buffer.trim();
+        clearRenderedPrompt(renderState);
+        commitInteractiveLine(prefix, resolved);
+        cleanup();
+        resolve(resolved);
+        return;
+      }
+      if (key.name === "tab") {
+        if (applySelectedCommand()) {
+          render();
+        }
+        return;
+      }
+      if (key.name === "escape") {
+        if (buffer.length > 0) {
+          buffer = "";
+          commandCursor = 0;
+          historyCursor = -1;
+          historyDraft = "";
+          render();
+        }
+        return;
+      }
+      if (key.name === "backspace") {
+        if (buffer.length > 0) {
+          buffer = buffer.slice(0, -1);
+          historyCursor = -1;
+          historyDraft = "";
+          commandCursor = 0;
+          render();
+        }
+        return;
+      }
+      if (historyDirection) {
+        moveHistory(historyDirection);
+        render();
+        return;
+      }
+      if (key.name === "up") {
+        if (visibleCommands.length > 0) {
+          commandCursor = commandCursor === 0 ? visibleCommands.length - 1 : commandCursor - 1;
+        }
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        if (visibleCommands.length > 0) {
+          commandCursor = commandCursor === visibleCommands.length - 1 ? 0 : commandCursor + 1;
+        }
+        render();
+        return;
+      }
+      if (input && !key.ctrl && !key.meta) {
+        buffer += input;
+        historyCursor = -1;
+        historyDraft = "";
+        commandCursor = 0;
+        render();
+      }
+    };
+    readline__default.default.emitKeypressEvents(stdin);
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("keypress", onKeyPress);
+    render();
+  });
+}
+function selectSingleOption(title, options) {
+  return new Promise((resolve, reject) => {
+    if (options.length === 0) {
+      reject(new Error("\uC120\uD0DD \uAC00\uB2A5\uD55C \uD56D\uBAA9\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."));
+      return;
+    }
+    const { stdin } = process;
+    const rawState = "isRaw" in stdin ? Boolean(stdin.isRaw) : false;
+    let cursor = 0;
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeyPress);
+      if (stdin.isTTY) {
+        stdin.setRawMode(rawState);
+      }
+      stdin.pause();
+      console.clear();
+    };
+    const render = () => {
+      renderScreenBox(
+        title,
+        options.map((option, index) => {
+          const prefix = cursor === index ? colorize(">", ANSI.green) : " ";
+          const label = cursor === index ? colorize(option.label, ANSI.green) : option.label;
+          return `${prefix} ${padVisible(label, 24)} ${colorize(option.description || "", ANSI.gray)}`;
+        }),
+        [
+          `${colorize("Up/Down", ANSI.yellow)} \uC774\uB3D9`,
+          `${colorize("Enter", ANSI.yellow)} \uC120\uD0DD`,
+          `${colorize("ESC", ANSI.yellow)} \uCDE8\uC18C`,
+          `${colorize("Ctrl+C", ANSI.yellow)} \uC138\uC158 \uC885\uB8CC`
+        ]
+      );
+    };
+    const onKeyPress = (_input, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(createUserTerminatedError("\uC0AC\uC6A9\uC790\uAC00 \uC120\uD0DD \uC785\uB825 \uC911 \uC138\uC158 \uC885\uB8CC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4."));
+        return;
+      }
+      if (key.name === "escape") {
+        cleanup();
+        reject(createUserCancelledError("\uC0AC\uC6A9\uC790\uAC00 \uC120\uD0DD \uC785\uB825\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4."));
+        return;
+      }
+      if (key.name === "up") {
+        cursor = cursor === 0 ? options.length - 1 : cursor - 1;
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        cursor = cursor === options.length - 1 ? 0 : cursor + 1;
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const selected = options[cursor];
+        if (!selected) {
+          cleanup();
+          reject(new Error("\uC120\uD0DD\uD55C \uD56D\uBAA9\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        cleanup();
+        appendSlashCommandTelemetryInputValue(selected.value);
+        resolve(selected.value);
+      }
+    };
+    readline__default.default.emitKeypressEvents(stdin);
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("keypress", onKeyPress);
+    render();
+  });
+}
+
+// src/common/prompts/render.ts
+function normalizeMarkdown(markdown) {
+  return markdown.trim();
+}
+function renderMarkdownBlocks(markdownBlocks) {
+  const blocks = (markdownBlocks || []).map(normalizeMarkdown).filter(Boolean);
+  if (blocks.length === 0) {
+    return "";
+  }
+  return blocks.join("\n\n");
+}
+function renderLabeledSection(section) {
+  const markdown = normalizeMarkdown(section.markdown);
+  if (!markdown) {
+    return "";
+  }
+  return [`[${section.heading}]`, markdown].join("\n");
+}
+function toPromptSections(prompt) {
+  const sections = [
+    {
+      heading: "\uC9C0\uCE68",
+      markdown: renderMarkdownBlocks(prompt.instructions)
+    },
+    {
+      heading: "\uCD5C\uADFC \uD788\uC2A4\uD1A0\uB9AC",
+      markdown: prompt.historyContext || "(\uC5C6\uC74C)"
+    },
+    {
+      heading: "\uD604\uC7AC \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uC0C1\uD0DC",
+      markdown: prompt.workspaceSnapshot.available ? [
+        `Git Root: ${prompt.workspaceSnapshot.gitRoot}`,
+        `Branch: ${prompt.workspaceSnapshot.branch || "(detached)"}`,
+        "",
+        "[git status --short]",
+        prompt.workspaceSnapshot.statusLines.join("\n") || "(\uC5C6\uC74C)",
+        "",
+        "[git diff --stat]",
+        prompt.workspaceSnapshot.diffStat || "(\uC5C6\uC74C)",
+        "",
+        "[\uCD5C\uADFC \uCEE4\uBC0B]",
+        prompt.workspaceSnapshot.recentCommits.join("\n") || "(\uC5C6\uC74C)"
+      ].join("\n") : prompt.workspaceSnapshot.note
+    },
+    {
+      heading: "\uADDC\uCE59",
+      markdown: renderMarkdownBlocks(prompt.rules)
+    },
+    {
+      heading: "\uC751\uB2F5 \uC591\uC2DD",
+      markdown: renderMarkdownBlocks(prompt.forms)
+    },
+    ...prompt.sections || []
+  ];
+  return sections.filter((section) => normalizeMarkdown(section.markdown));
+}
+function renderPromptForService(prompt) {
+  if (typeof prompt === "string") {
+    return safeExcerpt(prompt, 2e5);
+  }
+  return [
+    `# ${prompt.title}`,
+    "",
+    `\uD604\uC7AC \uC120\uD0DD\uB41C AI \uC11C\uBE44\uC2A4: ${prompt.service}`,
+    ...toPromptSections(prompt).flatMap((section) => ["", renderLabeledSection(section)])
+  ].join("\n");
+}
+
+// src/common/ai-services/internal/shared.ts
+function quoteArgs(args) {
+  return args.map((arg) => shellQuote(arg)).join(" ");
+}
+function toUnique(values) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => {
+    if (!value || seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+    return true;
+  });
+}
+function createServiceCommandSpec(command, attempts) {
+  const normalizedAttempts = attempts.map(({ args, label }) => ({
+    args,
+    label,
+    preview: `${command} ${quoteArgs(args)}`
+  }));
+  return {
+    attempts: normalizedAttempts,
+    command,
+    preview: normalizedAttempts.map((attempt) => attempt.preview).join(" || ")
+  };
+}
+function getDefaultReasoningEffort(mode) {
+  if (mode === "review") {
+    return "high";
+  }
+  if (mode === "commit") {
+    return "medium";
+  }
+  if (mode === "gen-html") {
+    return "medium";
+  }
+  if (mode === "gen-storybook") {
+    return "medium";
+  }
+  return "low";
+}
+
+// src/common/ai-services/builders/claude.ts
+function normalizeClaudeEffort(effort) {
+  if (effort === "minimal") {
+    return "low";
+  }
+  return effort;
+}
+function resolveClaudePrimaryAlias(mode) {
+  if (mode === "review") {
+    return "opus";
+  }
+  return "sonnet";
+}
+function getClaudeAliasFallbacks(primaryAlias) {
+  if (primaryAlias === "opus") {
+    return ["opus", "sonnet", "haiku"];
+  }
+  if (primaryAlias === "haiku") {
+    return ["haiku", "sonnet"];
+  }
+  return [primaryAlias, "sonnet", "haiku"];
+}
+function buildClaudeArgs(prompt, effort, model, fallbackModel) {
+  const args = ["--permission-mode", "acceptEdits", "--effort", effort];
+  if (model) {
+    args.push("--model", model);
+  }
+  if (model && fallbackModel) {
+    args.push("--fallback-model", fallbackModel);
+  }
+  args.push("-p", prompt);
+  return args;
+}
+function buildClaudeCommand(prompt, mode, parsedArgs) {
+  const renderedPrompt = renderPromptForService(prompt);
+  const effort = normalizeClaudeEffort(parsedArgs.reasoningEffort ?? getDefaultReasoningEffort(mode));
+  const primaryAlias = resolveClaudePrimaryAlias(mode);
+  const aliasFallbacks = toUnique(getClaudeAliasFallbacks(primaryAlias));
+  const modelCandidates = toUnique(parsedArgs.model ? [parsedArgs.model, ...aliasFallbacks] : aliasFallbacks);
+  const attempts = modelCandidates.map((model, index) => ({
+    args: buildClaudeArgs(renderedPrompt, effort, model, modelCandidates[index + 1]),
+    label: `model:${model}`
+  }));
+  attempts.push({
+    args: buildClaudeArgs(renderedPrompt, effort),
+    label: "model:account-default"
+  });
+  return createServiceCommandSpec("claude", attempts);
+}
+
+// src/common/ai-services/builders/codex.ts
+function buildCodexArgs(prompt, reasoningEffort, model) {
+  const args = ["exec", "--full-auto"];
+  if (model) {
+    args.push("--model", model);
+  }
+  args.push("-c", `model_reasoning_effort="${reasoningEffort}"`, prompt);
+  return args;
+}
+function buildCodexCommand(prompt, mode, parsedArgs) {
+  const renderedPrompt = renderPromptForService(prompt);
+  const effort = parsedArgs.reasoningEffort ?? getDefaultReasoningEffort(mode);
+  const preferredModelAlias = "gpt-5";
+  const modelCandidates = toUnique(parsedArgs.model ? [parsedArgs.model, preferredModelAlias] : [preferredModelAlias]);
+  const attempts = modelCandidates.map((model) => ({
+    args: buildCodexArgs(renderedPrompt, effort, model),
+    label: `model:${model}`
+  }));
+  attempts.push({
+    args: buildCodexArgs(renderedPrompt, effort),
+    label: "model:account-default"
+  });
+  return createServiceCommandSpec("codex", attempts);
+}
+
+// src/common/ai-services/builders/gemini.ts
+function resolveGeminiPrimaryAlias(mode, reasoningEffort) {
+  if (mode === "review" || mode === "gen-html" || mode === "gen-storybook") {
+    return "pro";
+  }
+  if (reasoningEffort === "high") {
+    return "pro";
+  }
+  if (reasoningEffort === "minimal" || reasoningEffort === "low") {
+    return "flash";
+  }
+  return "auto";
+}
+function getGeminiAliasFallbacks(primaryAlias) {
+  if (primaryAlias === "pro") {
+    return ["pro", "flash", "auto"];
+  }
+  if (primaryAlias === "flash") {
+    return ["flash", "auto", "pro"];
+  }
+  return [primaryAlias, "auto", "flash", "pro"];
+}
+function buildGeminiArgs(prompt, model) {
+  const args = ["--approval-mode", "auto_edit", "--sandbox"];
+  if (!model) {
+    args.push("-p", prompt);
+    return args;
+  }
+  args.push("--model", model, "-p", prompt);
+  return args;
+}
+function buildGeminiCommand(prompt, mode, parsedArgs) {
+  const renderedPrompt = renderPromptForService(prompt);
+  const reasoningEffort = parsedArgs.reasoningEffort ?? getDefaultReasoningEffort(mode);
+  const primaryAlias = resolveGeminiPrimaryAlias(mode, reasoningEffort);
+  const aliasFallbacks = toUnique(getGeminiAliasFallbacks(primaryAlias));
+  const modelCandidates = toUnique(parsedArgs.model ? [parsedArgs.model, ...aliasFallbacks] : aliasFallbacks);
+  const attempts = modelCandidates.map((model) => ({
+    args: buildGeminiArgs(renderedPrompt, model),
+    label: `model:${model}`
+  }));
+  attempts.push({
+    args: buildGeminiArgs(renderedPrompt),
+    label: "model:account-default"
+  });
+  return createServiceCommandSpec("gemini", attempts);
+}
+
+// src/common/ai-services/internal/build-service-command.ts
+function buildServiceCommand(options) {
+  switch (options.service) {
+    case "codex":
+      return buildCodexCommand(options.prompt, options.mode, options.parsedArgs);
+    case "gemini":
+      return buildGeminiCommand(options.prompt, options.mode, options.parsedArgs);
+    case "claude":
+      return buildClaudeCommand(options.prompt, options.mode, options.parsedArgs);
+  }
+}
+function getBinaryName(service) {
+  switch (service) {
+    case "codex":
+      return "codex";
+    case "gemini":
+      return "gemini";
+    case "claude":
+      return "claude";
+  }
+}
+function getInstallPackageName(service) {
+  switch (service) {
+    case "codex":
+      return "@openai/codex";
+    case "gemini":
+      return "@google/gemini-cli";
+    case "claude":
+      return "@anthropic-ai/claude-code";
+  }
+}
+function isCliAvailable(service, trace) {
+  const binaryName = getBinaryName(service);
+  trace("cli-check:start", `${service} -> ${binaryName} --version`);
+  const result = child_process.spawnSync(binaryName, ["--version"], {
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 2
+  });
+  if (result.error || result.status !== 0) {
+    trace("cli-check:missing", getErrorSummary(result.error || result.stderr || result.status));
+    return false;
+  }
+  trace("cli-check:ok", `${service}`);
+  return true;
+}
+function installCli(service, trace) {
+  const packageName = getInstallPackageName(service);
+  trace("cli-install:start", `${service} -> ${packageName}`);
+  const result = child_process.spawnSync("npm", ["install", "-g", packageName], {
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 20,
+    stdio: "inherit"
+  });
+  if (result.error || result.status !== 0) {
+    trace("cli-install:failed", getErrorSummary(result.error || result.stderr || result.status));
+    throw new Error(`${service} CLI \uC124\uCE58\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4. package=${packageName}`);
+  }
+  trace("cli-install:done", `${service}`);
+}
+function ensureServiceCli(service, parsedArgs, trace) {
+  if (isCliAvailable(service, trace)) {
+    return true;
+  }
+  if (parsedArgs.testMode) {
+    trace("cli-install:skip:test-mode", service);
+    return false;
+  }
+  installCli(service, trace);
+  return isCliAvailable(service, trace);
+}
+function killServiceProcessTree(child, signal) {
+  if (!child.pid) {
+    return;
+  }
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-child.pid, signal ?? "SIGTERM");
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function writeStreamChunk(chunk, streamOutput, writer, updateTrailingState) {
+  if (!streamOutput) {
+    return;
+  }
+  writer.write(chunk);
+  updateTrailingState(!chunk.endsWith("\n"), writer);
+}
+function executeServiceCommandAttempt(command, args, trace, streamOutput = false) {
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn(command, args, {
+      cwd: process.cwd(),
+      detached: process.platform !== "win32",
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const { stdin } = process;
+    const rawState = "isRaw" in stdin ? Boolean(stdin.isRaw) : false;
+    let stopReason = null;
+    let settled = false;
+    let stdout2 = "";
+    let stderr = "";
+    let forceKillTimer;
+    let lastStreamWriter;
+    let needsTrailingNewline = false;
+    const flushTrailingNewline = () => {
+      if (!streamOutput || !needsTrailingNewline) {
+        return;
+      }
+      (lastStreamWriter || process.stdout).write("\n");
+      needsTrailingNewline = false;
+      lastStreamWriter = void 0;
+    };
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeyPress);
+      if (forceKillTimer) {
+        clearTimeout(forceKillTimer);
+      }
+      if (stdin.isTTY) {
+        stdin.setRawMode(rawState);
+      }
+      stdin.pause();
+    };
+    const finish = (handler) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      flushTrailingNewline();
+      cleanup();
+      handler();
+    };
+    const requestStop = (reason) => {
+      if (stopReason) {
+        return;
+      }
+      stopReason = reason;
+      trace(`service-command:${reason}:requested`, `${command} ${quoteArgs(args)}`);
+      killServiceProcessTree(child, process.platform === "win32" ? void 0 : "SIGTERM");
+      forceKillTimer = setTimeout(() => {
+        if (!settled) {
+          killServiceProcessTree(child, "SIGKILL");
+        }
+      }, 1500);
+      forceKillTimer.unref?.();
+    };
+    const onKeyPress = (_input, key) => {
+      if (key.name === "escape") {
+        requestStop("cancel");
+      }
+      if (key.ctrl && key.name === "c") {
+        requestStop("terminate");
+      }
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout2 += chunk;
+      writeStreamChunk(chunk, streamOutput, process.stdout, (nextNeedsTrailingNewline, nextWriter) => {
+        needsTrailingNewline = nextNeedsTrailingNewline;
+        lastStreamWriter = nextWriter;
+      });
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+      writeStreamChunk(chunk, streamOutput, process.stderr, (nextNeedsTrailingNewline, nextWriter) => {
+        needsTrailingNewline = nextNeedsTrailingNewline;
+        lastStreamWriter = nextWriter;
+      });
+    });
+    child.on("error", (error) => {
+      finish(() => {
+        if (stopReason === "cancel") {
+          reject(createUserCancelledError("ESC \uC785\uB825\uC73C\uB85C \uD604\uC7AC AI \uC791\uC5C5\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        if (stopReason === "terminate") {
+          reject(createUserTerminatedError("Ctrl+C \uC785\uB825\uC73C\uB85C \uC138\uC158 \uC885\uB8CC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        resolve({
+          status: null,
+          stderr: getErrorSummary(error),
+          streamedOutput: streamOutput,
+          stdout: stdout2
+        });
+      });
+    });
+    child.on("close", (status) => {
+      finish(() => {
+        if (stopReason === "cancel") {
+          reject(createUserCancelledError("ESC \uC785\uB825\uC73C\uB85C \uD604\uC7AC AI \uC791\uC5C5\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        if (stopReason === "terminate") {
+          reject(createUserTerminatedError("Ctrl+C \uC785\uB825\uC73C\uB85C \uC138\uC158 \uC885\uB8CC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4."));
+          return;
+        }
+        resolve({
+          status,
+          stderr,
+          streamedOutput: streamOutput,
+          stdout: stdout2
+        });
+      });
+    });
+    readline__default.default.emitKeypressEvents(stdin);
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("keypress", onKeyPress);
+  });
+}
+function createAttemptFailureError(service, failures) {
+  const failureSummary = failures.map(({ attempt, result }, index) => {
+    const status = result.status === null ? "spawn-error" : String(result.status);
+    const excerpt = safeExcerpt(result.stderr || result.stdout || `exit status ${status}`, 1200);
+    return [`[${index + 1}/${failures.length}] ${attempt.label}`, `status: ${status}`, excerpt].join("\n");
+  }).join("\n\n");
+  const lastFailure = failures.at(-1);
+  const error = new Error(`\uBAA8\uB4E0 ${service} \uBAA8\uB378 \uC2DC\uB3C4\uAC00 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.
+
+${failureSummary}`);
+  Object.assign(error, {
+    status: lastFailure?.result.status ?? 1,
+    stderr: failureSummary,
+    stdout: lastFailure?.result.stdout || ""
+  });
+  return error;
+}
+var DEFAULT_STREAM_OUTPUT_STATE = {
+  enabled: false
+};
+var streamOutputRuntimeState = globalThis.__JU_HONG_E_STREAM_OUTPUT_STATE__ ?? (globalThis.__JU_HONG_E_STREAM_OUTPUT_STATE__ = {
+  ...DEFAULT_STREAM_OUTPUT_STATE
+});
+function normalizeStreamOutputState(value) {
+  if (!value || typeof value !== "object") {
+    return { ...DEFAULT_STREAM_OUTPUT_STATE };
+  }
+  const enabled = "enabled" in value ? Boolean(value.enabled) : DEFAULT_STREAM_OUTPUT_STATE.enabled;
+  return {
+    enabled
+  };
+}
+function readStreamOutputConfig(paths) {
+  if (!fs7__default.default.existsSync(paths.streamOutputConfigPath)) {
+    return { ...DEFAULT_STREAM_OUTPUT_STATE };
+  }
+  try {
+    const parsed = JSON.parse(fs7__default.default.readFileSync(paths.streamOutputConfigPath, "utf8"));
+    return normalizeStreamOutputState(parsed);
+  } catch {
+    return { ...DEFAULT_STREAM_OUTPUT_STATE };
+  }
+}
+function hydrateStreamOutputState(paths) {
+  const nextState = readStreamOutputConfig(paths);
+  streamOutputRuntimeState.enabled = nextState.enabled;
+  return streamOutputRuntimeState.enabled;
+}
+function isStreamOutputEnabled(paths) {
+  if (paths) {
+    return hydrateStreamOutputState(paths);
+  }
+  return streamOutputRuntimeState.enabled;
+}
+
+// src/common/ai-services/index.ts
+async function runAIService(options) {
+  const streamOutputEnabled = hydrateStreamOutputState(options.paths);
+  const securityResult = await guardSecurityPayload({
+    paths: options.paths,
+    payload: {
+      args: [],
+      command: options.mode,
+      input: "",
+      prompt: options.prompt,
+      promptRootDir: options.paths.rootDir,
+      rawArgs: "",
+      rawCommand: "",
+      service: options.service
+    },
+    reportScope: `security:service:${options.mode}`,
+    trace: options.trace,
+    traceLabel: `service:${options.mode}`
+  });
+  if (!securityResult.ok) {
+    options.trace("service-command:blocked", options.mode);
+    return {
+      blocked: true,
+      cliAvailable: true,
+      exitCode: 0,
+      preview: "",
+      service: options.service,
+      skipped: true,
+      stderr: "",
+      streamedOutput: false,
+      stdout: securityResult.userMessage || ""
+    };
+  }
+  const cliAvailable = ensureServiceCli(options.service, options.parsedArgs, options.trace);
+  const commandSpec = buildServiceCommand({
+    mode: options.mode,
+    parsedArgs: options.parsedArgs,
+    prompt: options.prompt,
+    service: options.service
+  });
+  options.trace("service-command:prepared", commandSpec.preview);
+  if (options.parsedArgs.testMode || !cliAvailable) {
+    options.trace("service-command:skipped", options.parsedArgs.testMode ? "test-mode" : "cli-missing");
+    return {
+      blocked: false,
+      cliAvailable,
+      exitCode: 0,
+      preview: commandSpec.preview,
+      service: options.service,
+      skipped: true,
+      stderr: "",
+      streamedOutput: false,
+      stdout: [
+        "[TEST MODE] \uC2E4\uC81C AI \uD638\uCD9C\uC740 \uC0DD\uB7B5\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
+        "",
+        `service: ${options.service}`,
+        `cliAvailable: ${cliAvailable}`,
+        "",
+        "\uC0DD\uC131\uB420 \uBA85\uB839\uC5B4 \uBBF8\uB9AC\uBCF4\uAE30:",
+        commandSpec.preview
+      ].join("\n")
+    };
+  }
+  options.trace("service-command:exec:start", `attempts=${commandSpec.attempts.length}`);
+  const failures = [];
+  for (const [index, attempt] of commandSpec.attempts.entries()) {
+    const attemptOrder = `${index + 1}/${commandSpec.attempts.length}`;
+    options.trace("service-command:attempt:start", `${attemptOrder} ${attempt.label}`);
+    let result;
+    try {
+      result = await executeServiceCommandAttempt(
+        commandSpec.command,
+        attempt.args,
+        options.trace,
+        streamOutputEnabled
+      );
+    } catch (error) {
+      if (isUserCancelledError(error) || isUserTerminatedError(error)) {
+        options.trace(
+          isUserTerminatedError(error) ? "service-command:terminated" : "service-command:cancelled",
+          `${attemptOrder} ${attempt.label}`
+        );
+      }
+      throw error;
+    }
+    options.trace(
+      "service-command:attempt:end",
+      `${attemptOrder} ${attempt.label} status=${result.status ?? "spawn-error"}`
+    );
+    if (result.status === 0) {
+      options.trace("service-command:exec:end", `status=0 attempt=${attemptOrder} ${attempt.label}`);
+      return {
+        blocked: false,
+        cliAvailable,
+        exitCode: result.status ?? 0,
+        preview: commandSpec.preview,
+        service: options.service,
+        skipped: false,
+        stderr: result.stderr || "",
+        streamedOutput: result.streamedOutput,
+        stdout: result.stdout || ""
+      };
+    }
+    failures.push({ attempt, result });
+    options.trace(
+      "service-command:attempt:failed",
+      `${attemptOrder} ${attempt.label} ${safeExcerpt(result.stderr || result.stdout || "Unknown failure", 240)}`
+    );
+  }
+  options.trace("service-command:exec:end", `status=${failures.at(-1)?.result.status ?? 1}`);
+  throw createAttemptFailureError(options.service, failures);
+}
+
+// src/common/actions/shared.ts
+function formatActionError(error) {
+  return getErrorSummary(error);
+}
+async function runAIServiceWithStatus(options) {
+  if (isStreamOutputEnabled(options.paths)) {
+    options.status.step(options.streamingMessage || `${options.loadingMessage} - \uC2E4\uC2DC\uAC04 \uC751\uB2F5\uC744 \uADF8\uB300\uB85C \uCD9C\uB825\uD569\uB2C8\uB2E4.`);
+    return runAIService({
+      mode: options.mode,
+      parsedArgs: options.parsedArgs,
+      paths: options.paths,
+      prompt: options.prompt,
+      service: options.service,
+      trace: options.trace
+    });
+  }
+  return options.status.track(
+    options.loadingMessage,
+    () => runAIService({
+      mode: options.mode,
+      parsedArgs: options.parsedArgs,
+      paths: options.paths,
+      prompt: options.prompt,
+      service: options.service,
+      trace: options.trace
+    })
+  );
+}
+function printBufferedAIOutput(output, result, fallback = "(\uC751\uB2F5 \uC5C6\uC74C)") {
+  if (result.streamedOutput) {
+    return;
+  }
+  console.log(output || fallback);
+}
+
+// src/common/actions/chat.ts
+async function runChatAction(options) {
+  const securityResult = await guardSecurityPayload({
+    paths: options.paths,
+    payload: {
+      args: [],
+      command: "chat",
+      input: options.input,
+      rawArgs: "",
+      rawCommand: options.input,
+      service: options.service
+    },
+    reportScope: "security:chat",
+    trace: options.trace,
+    traceLabel: "chat"
+  });
+  if (!securityResult.ok) {
+    return void 0;
+  }
+  const status = createSessionActionStatus("\uB300\uD654");
+  status.step("1/4 \uB300\uD654 \uCEE8\uD14D\uC2A4\uD2B8\uC640 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uC0C1\uD0DC\uB97C \uC900\uBE44\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const workspaceBefore = captureWorkspaceSnapshot(options.paths.rootDir);
+  const historyContext = loadRecentHistoryContext(options.paths);
+  status.step("2/4 AI \uC694\uCCAD \uD504\uB86C\uD504\uD2B8\uB97C \uAD6C\uC131\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const prompt = buildChatPrompt({
+    historyContext,
+    service: options.service,
+    userInput: options.input,
+    workspaceSnapshot: workspaceBefore
+  });
+  const result = await runAIServiceWithStatus({
+    loadingMessage: `3/4 ${options.service} \uC751\uB2F5\uC744 \uAE30\uB2E4\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4`,
+    mode: "chat",
+    parsedArgs: options.parsedArgs,
+    paths: options.paths,
+    prompt,
+    service: options.service,
+    status,
+    streamingMessage: `3/4 ${options.service} \uC2E4\uC2DC\uAC04 \uC751\uB2F5\uC744 \uCD9C\uB825\uD558\uB294 \uC911\uC785\uB2C8\uB2E4. ESC \uCDE8\uC18C, Ctrl+C \uC138\uC158 \uC885\uB8CC`,
+    trace: options.trace
+  });
+  if (result.blocked) {
+    status.step("4/4 \uBCF4\uC548 \uC815\uCC45\uC73C\uB85C \uC778\uD574 AI \uD638\uCD9C\uC744 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4.");
+    return void 0;
+  }
+  status.step("4/4 \uC751\uB2F5\uC744 \uBC1B\uC558\uC2B5\uB2C8\uB2E4. \uC791\uC5C5 \uC774\uB825\uC744 \uC800\uC7A5\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const workspaceAfter = captureWorkspaceSnapshot(options.paths.rootDir);
+  const workspaceDelta = diffWorkspaceSnapshots(workspaceBefore, workspaceAfter);
+  const historyPath = writeTurnHistory(options.paths, {
+    historyContext,
+    input: options.input,
+    output: result.stdout,
+    previewCommand: result.preview,
+    scope: "chat",
+    service: options.service,
+    skipped: result.skipped,
+    title: `\uB300\uD654: ${safeExcerpt(options.input, 80)}`,
+    workspaceAfter,
+    workspaceBefore,
+    workspaceDelta
+  });
+  appendConversationHistory(options.paths, {
+    input: options.input,
+    output: result.stdout,
+    scope: "chat",
+    service: options.service,
+    summary: `\uB300\uD654 \uCC98\uB9AC \uC644\uB8CC: ${safeExcerpt(options.input, 60)}`,
+    title: `\uB300\uD654: ${safeExcerpt(options.input, 80)}`
+  });
+  printBufferedAIOutput(result.stdout, result);
+  return {
+    historyPath,
+    previewCommand: result.preview,
+    scope: "chat",
+    service: options.service,
+    skipped: result.skipped,
+    summary: `\uB300\uD654 \uCC98\uB9AC \uC644\uB8CC: ${safeExcerpt(options.input, 60)}`,
+    title: "\uB300\uD654",
+    traceMessages: []
+  };
+}
+
+// src/common/command-runtime/help.ts
+function formatSlashCommands(commands) {
+  return commands.map((command) => `  ${command.command.padEnd(24)} ${command.description}`).join("\n");
+}
+function createCliHelpText(commands, currentService, binaryName = "ju-hong-e") {
+  const serviceSection = "";
+  return `
+Usage: ${binaryName} [options]
+
+Options:
+  --service <codex|gemini|claude>   \uC2DC\uC791 \uC11C\uBE44\uC2A4 \uC9C0\uC815
+  --model <name>                    \uC11C\uBE44\uC2A4\uBCC4 \uBAA8\uB378 \uC9C0\uC815
+  --reasoning-effort <level>        minimal|low|medium|high
+  --test                            \uC2E4\uC81C AI \uD638\uCD9C \uC5C6\uC774 \uC804\uCCB4 \uD750\uB984 \uD14C\uC2A4\uD2B8
+  --trace                           trace \uB85C\uADF8\uB97C \uCF58\uC194\uC5D0 \uCD9C\uB825
+  --help                            \uB3C4\uC6C0\uB9D0 \uCD9C\uB825
+
+Slash Commands:
+${formatSlashCommands(commands)}
+
+Service Native Slash Commands:
+  /<command> ...             \uB0B4\uC7A5 \uBA85\uB839\uC774 \uC544\uB2C8\uBA74 \uD604\uC7AC \uC11C\uBE44\uC2A4 CLI\uC758 slash command\uB85C \uC704\uC784
+  [service] /<command> ...   \uC774\uB984\uC774 \uACB9\uCE58\uB294 \uACBD\uC6B0 \uD604\uC7AC \uC11C\uBE44\uC2A4 native command\uB97C \uBA85\uC2DC\uC801\uC73C\uB85C \uC2E4\uD589
+
+Shortcuts:
+  ESC                        \uD604\uC7AC \uC791\uC5C5 \uB610\uB294 \uC785\uB825\uB9CC \uCDE8\uC18C
+  Ctrl+C                     \uC138\uC158 \uC885\uB8CC
+  Shift+Up/Down              \uC785\uB825 \uD788\uC2A4\uD1A0\uB9AC \uC774\uB3D9
+
+${serviceSection}`.trim();
+}
+
+// src/common/runtime-profile.ts
+var runtimeState = globalThis.__JU_HONG_E_RUNTIME_PROFILE__ ?? (globalThis.__JU_HONG_E_RUNTIME_PROFILE__ = {
+  binaryName: "ju-hong-e",
+  profile: "all"
+});
+var ALL_PROFILE_CONFIGS = {
+  all: {
+    enableLocalServer: true
+  },
+  be: {
+    allowedBuiltinCommands: /* @__PURE__ */ new Set(["/review", "/commit", "/change-service", "/security-policy", "/show-stream", "/help", "/exit"]),
+    enableLocalServer: false
+  },
+  fe: {
+    enableLocalServer: true
+  }
+};
+function getProfileConfig(profile = runtimeState.profile) {
+  return ALL_PROFILE_CONFIGS[profile];
+}
+function configureCliRuntime(options) {
+  runtimeState.binaryName = options.binaryName;
+  runtimeState.profile = options.profile;
+}
+function shouldEnableLocalServer(profile = runtimeState.profile) {
+  return getProfileConfig(profile).enableLocalServer;
+}
+function getAllowedBuiltinCommands(profile = runtimeState.profile) {
+  return getProfileConfig(profile).allowedBuiltinCommands;
+}
+
+// src/common/actions/native-command.ts
+async function runNativeCommandAction(options) {
+  const status = createSessionActionStatus("\uB124\uC774\uD2F0\uBE0C \uBA85\uB839");
+  status.step("1/4 \uC11C\uBE44\uC2A4 \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC2E4\uD589\uC744 \uC900\uBE44\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const workspaceBefore = captureWorkspaceSnapshot(options.paths.rootDir);
+  const historyContext = loadRecentHistoryContext(options.paths);
+  status.step("2/4 \uC120\uD0DD\uB41C \uC11C\uBE44\uC2A4 CLI\uB85C \uC6D0\uBCF8 slash command\uB97C \uC804\uB2EC\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const result = await runAIServiceWithStatus({
+    loadingMessage: `3/4 ${options.service} \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC751\uB2F5\uC744 \uAE30\uB2E4\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4`,
+    mode: "native-command",
+    parsedArgs: options.parsedArgs,
+    paths: options.paths,
+    prompt: options.rawCommand,
+    service: options.service,
+    status,
+    streamingMessage: `3/4 ${options.service} \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC2E4\uC2DC\uAC04 \uC751\uB2F5\uC744 \uCD9C\uB825\uD558\uB294 \uC911\uC785\uB2C8\uB2E4. ESC \uCDE8\uC18C, Ctrl+C \uC138\uC158 \uC885\uB8CC`,
+    trace: options.trace
+  });
+  if (result.blocked) {
+    status.step("4/4 \uBCF4\uC548 \uC815\uCC45\uC73C\uB85C \uC778\uD574 \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC2E4\uD589\uC744 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4.");
+    return void 0;
+  }
+  status.step("4/4 \uC751\uB2F5\uACFC \uC791\uC5C5 \uC774\uB825\uC744 \uC800\uC7A5\uD558\uB294 \uC911\uC785\uB2C8\uB2E4.");
+  const workspaceAfter = captureWorkspaceSnapshot(options.paths.rootDir);
+  const workspaceDelta = diffWorkspaceSnapshots(workspaceBefore, workspaceAfter);
+  const output = result.stdout || result.stderr || "(\uC751\uB2F5 \uC5C6\uC74C)";
+  const historyPath = writeTurnHistory(options.paths, {
+    extraSections: [
+      {
+        heading: "\uC11C\uBE44\uC2A4 \uB124\uC774\uD2F0\uBE0C \uBA85\uB839",
+        markdown: [`- \uC0AC\uC6A9\uC790 \uC785\uB825: \`${options.input}\``, `- \uC2E4\uC81C \uC804\uB2EC \uBA85\uB839: \`${options.rawCommand}\``].join("\n")
+      }
+    ],
+    historyContext,
+    input: options.input,
+    output,
+    previewCommand: result.preview,
+    scope: "native-command",
+    service: options.service,
+    skipped: result.skipped,
+    title: `\uB124\uC774\uD2F0\uBE0C \uBA85\uB839: ${safeExcerpt(options.rawCommand, 80)}`,
+    workspaceAfter,
+    workspaceBefore,
+    workspaceDelta
+  });
+  appendConversationHistory(options.paths, {
+    input: options.input,
+    output,
+    scope: "native-command",
+    service: options.service,
+    summary: `\uC11C\uBE44\uC2A4 \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC2E4\uD589: ${safeExcerpt(options.rawCommand, 60)}`,
+    title: `\uB124\uC774\uD2F0\uBE0C \uBA85\uB839: ${safeExcerpt(options.rawCommand, 80)}`
+  });
+  printBufferedAIOutput(output, result);
+  return {
+    historyPath,
+    previewCommand: result.preview,
+    scope: "native-command",
+    service: options.service,
+    skipped: result.skipped,
+    summary: `\uC11C\uBE44\uC2A4 \uB124\uC774\uD2F0\uBE0C \uBA85\uB839 \uC2E4\uD589: ${safeExcerpt(options.rawCommand, 60)}`,
+    title: "\uB124\uC774\uD2F0\uBE0C \uBA85\uB839",
+    traceMessages: []
+  };
+}
+
+// src/common/command-runtime/registry.ts
+var registryState = globalThis.__JU_HONG_E_COMMAND_REGISTRY__ ?? (globalThis.__JU_HONG_E_COMMAND_REGISTRY__ = {
+  juHongECommands: /* @__PURE__ */ new Map(),
+  nativeCommands: /* @__PURE__ */ new Map()
+});
+var JU_HONG_E_COMMANDS = registryState.juHongECommands;
+var NATIVE_COMMANDS = registryState.nativeCommands;
+function sortByOrder(commands) {
+  return [...commands].sort((left, right) => {
+    const leftOrder = left.order ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = right.order ?? Number.MAX_SAFE_INTEGER;
+    if (leftOrder !== rightOrder) {
+      return leftOrder - rightOrder;
+    }
+    return left.command.localeCompare(right.command);
+  });
+}
+function toBuiltinSlashCommandOption(command) {
+  return {
+    command: command.command,
+    description: command.description,
+    insertValue: command.insertValue || command.command,
+    matchKeywords: command.matchKeywords
+  };
+}
+function toNativeSlashCommandOption(service, command) {
+  const prefixedCommand = `[${service}] ${command.command}`;
+  return {
+    command: prefixedCommand,
+    description: command.description,
+    insertValue: prefixedCommand,
+    matchKeywords: [command.command, prefixedCommand, ...command.matchKeywords || []]
+  };
+}
+function resolveTelemetryStatusFromError(error) {
+  if (isUserCancelledError(error)) {
+    return "cancelled";
+  }
+  if (isUserTerminatedError(error)) {
+    return "terminated";
+  }
+  return "error";
+}
+async function validateCommand(context, security) {
+  const result = await guardSecurityPayload({
+    config: security,
+    paths: context.paths,
+    payload: {
+      args: context.args,
+      command: context.command,
+      input: context.input,
+      rawArgs: context.rawArgs,
+      rawCommand: context.rawCommand,
+      requestedService: "requestedService" in context ? context.requestedService : void 0,
+      service: context.service
+    },
+    reportScope: `security:${context.command}`,
+    trace: context.trace,
+    traceLabel: context.command
+  });
+  return result.ok;
+}
+function clearCommandRegistry() {
+  JU_HONG_E_COMMANDS.clear();
+  NATIVE_COMMANDS.clear();
+}
+function applyBuiltinCommandFilter(allowedCommands) {
+  if (!allowedCommands) {
+    return;
+  }
+  for (const commandName of [...JU_HONG_E_COMMANDS.keys()]) {
+    if (!allowedCommands.has(commandName)) {
+      JU_HONG_E_COMMANDS.delete(commandName);
+    }
+  }
+}
+function getBuiltinCommands() {
+  return sortByOrder([...JU_HONG_E_COMMANDS.values()]);
+}
+function getBuiltinCommandNames() {
+  return getBuiltinCommands().map((command) => command.command);
+}
+function getNativeCommands(service) {
+  return sortByOrder([...NATIVE_COMMANDS.get(service)?.values() || []]);
+}
+function getBuiltinSlashCommands() {
+  return getBuiltinCommands().map(toBuiltinSlashCommandOption);
+}
+function getSessionCommandCatalog(service) {
+  const builtinCommands = getBuiltinCommands();
+  const nativeCommands = getNativeCommands(service);
+  return {
+    builtinCommands,
+    nativeCommands,
+    slashCommands: [...builtinCommands.map(toBuiltinSlashCommandOption), ...nativeCommands.map((command) => toNativeSlashCommandOption(service, command))]
+  };
+}
+function findJuHongECommand(command) {
+  return JU_HONG_E_COMMANDS.get(command);
+}
+function findNativeCommand(service, command) {
+  return NATIVE_COMMANDS.get(service)?.get(command);
+}
+async function executeJuHongECommand(definition, context) {
+  beginSlashCommandTelemetryInputCollection(context.args);
+  const resolveTelemetryArgs = () => endSlashCommandTelemetryInputCollection();
+  try {
+    const canExecute = await validateCommand(context, definition.security);
+    if (!canExecute) {
+      trackSlashCommandExecution({
+        args: resolveTelemetryArgs(),
+        command: context.command,
+        kind: "builtin",
+        rootDir: context.paths.rootDir,
+        service: context.service,
+        status: "blocked",
+        trace: context.trace
+      });
+      return {};
+    }
+    const result = await definition.execute({
+      ...context,
+      definition
+    });
+    trackSlashCommandExecution({
+      args: resolveTelemetryArgs(),
+      command: context.command,
+      kind: "builtin",
+      rootDir: context.paths.rootDir,
+      service: context.service,
+      status: "success",
+      trace: context.trace
+    });
+    return result;
+  } catch (error) {
+    trackSlashCommandExecution({
+      args: resolveTelemetryArgs(),
+      command: context.command,
+      kind: "builtin",
+      rootDir: context.paths.rootDir,
+      service: context.service,
+      status: resolveTelemetryStatusFromError(error),
+      trace: context.trace
+    });
+    throw error;
+  }
+}
+async function executeNativeCommand(definition, context) {
+  beginSlashCommandTelemetryInputCollection(context.args);
+  const resolveTelemetryArgs = () => endSlashCommandTelemetryInputCollection();
+  try {
+    const canExecute = await validateCommand(context, definition?.security);
+    if (!canExecute) {
+      trackSlashCommandExecution({
+        args: resolveTelemetryArgs(),
+        command: context.command,
+        kind: "native",
+        requestedService: context.requestedService,
+        rootDir: context.paths.rootDir,
+        service: context.service,
+        status: "blocked",
+        trace: context.trace
+      });
+      return {};
+    }
+    if (definition) {
+      const result = await definition.execute(context);
+      trackSlashCommandExecution({
+        args: resolveTelemetryArgs(),
+        command: context.command,
+        kind: "native",
+        requestedService: context.requestedService,
+        rootDir: context.paths.rootDir,
+        service: context.service,
+        status: "success",
+        trace: context.trace
+      });
+      return result;
+    }
+    const record = await runNativeCommandAction({
+      input: context.input,
+      parsedArgs: context.parsedArgs,
+      paths: context.paths,
+      rawCommand: context.rawCommand,
+      service: context.service,
+      trace: context.trace
+    });
+    trackSlashCommandExecution({
+      args: resolveTelemetryArgs(),
+      command: context.command,
+      kind: "native",
+      requestedService: context.requestedService,
+      rootDir: context.paths.rootDir,
+      service: context.service,
+      status: "success",
+      trace: context.trace
+    });
+    return {
+      record
+    };
+  } catch (error) {
+    trackSlashCommandExecution({
+      args: resolveTelemetryArgs(),
+      command: context.command,
+      kind: "native",
+      requestedService: context.requestedService,
+      rootDir: context.paths.rootDir,
+      service: context.service,
+      status: resolveTelemetryStatusFromError(error),
+      trace: context.trace
+    });
+    throw error;
+  }
+}
+
+// src/common/command-runtime/loader.ts
+var loadPromise;
+async function collectCommandModulePaths(directoryPath) {
+  const entries = await fs2__default.default.readdir(directoryPath, { withFileTypes: true });
+  const modulePaths = [];
+  for (const entry of entries) {
+    const nextPath = path6__default.default.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      modulePaths.push(...await collectCommandModulePaths(nextPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name === "index.js") {
+      modulePaths.push(nextPath);
+    }
+  }
+  return modulePaths;
+}
+async function isCommandModuleRootDirectory(directoryPath) {
+  try {
+    const entries = await fs2__default.default.readdir(directoryPath, { withFileTypes: true });
+    const directoryNames = new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+    return directoryNames.has("ju-hong-e") || directoryNames.has("native");
+  } catch {
+    return false;
+  }
+}
+async function resolveCommandModuleRootDirectoryPath() {
+  let currentDirectoryPath = path6__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('be.cjs', document.baseURI).href))));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidatePath = path6__default.default.join(currentDirectoryPath, "command-modules");
+    if (await isCommandModuleRootDirectory(candidatePath)) {
+      return candidatePath;
+    }
+    const parentDirectoryPath = path6__default.default.dirname(currentDirectoryPath);
+    if (parentDirectoryPath === currentDirectoryPath) {
+      break;
+    }
+    currentDirectoryPath = parentDirectoryPath;
+  }
+  throw new Error(`command-modules \uB8E8\uD2B8\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. start=${url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('be.cjs', document.baseURI).href)))}`);
+}
+async function loadCommandModulesInternal() {
+  clearCommandRegistry();
+  const commandModuleRootDirectoryPath = await resolveCommandModuleRootDirectoryPath();
+  const modulePaths = (await collectCommandModulePaths(commandModuleRootDirectoryPath)).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  for (const modulePath of modulePaths) {
+    await import(url.pathToFileURL(modulePath).href);
+  }
+  applyBuiltinCommandFilter(getAllowedBuiltinCommands());
+}
+async function loadCommandModules() {
+  if (!loadPromise) {
+    loadPromise = loadCommandModulesInternal();
+  }
+  return loadPromise;
+}
+
+// src/common/command-runtime/parser.ts
+var SERVICE_PREFIX_PATTERN = /^\[(codex|gemini|claude)\]\s+(\/\S+)(?:\s+(.*))?$/i;
+function splitCommandParts(commandLine) {
+  const trimmed = commandLine.trim();
+  if (!trimmed.startsWith("/")) {
+    return void 0;
+  }
+  const [command = "", ...args] = trimmed.split(/\s+/);
+  const rawArgs = trimmed.slice(command.length).trim();
+  return {
+    args,
+    command,
+    rawArgs,
+    rawCommand: trimmed
+  };
+}
+function resolveSlashCommandInput(input, builtinCommands) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const prefixedMatch = trimmed.match(SERVICE_PREFIX_PATTERN);
+  if (prefixedMatch) {
+    const [, requestedService = "", command = "", rawArgs = ""] = prefixedMatch;
+    const normalized2 = splitCommandParts([command, rawArgs].filter(Boolean).join(" "));
+    if (!normalized2) {
+      return void 0;
+    }
+    return {
+      ...normalized2,
+      kind: "native",
+      prefixed: true,
+      requestedService: requestedService.toLowerCase()
+    };
+  }
+  const normalized = splitCommandParts(trimmed);
+  if (!normalized) {
+    return void 0;
+  }
+  if (builtinCommands.includes(normalized.command)) {
+    return {
+      ...normalized,
+      kind: "builtin"
+    };
+  }
+  return {
+    ...normalized,
+    kind: "native",
+    prefixed: false
+  };
+}
+var STORY_FILE_PATTERN = /\.stories\.[cm]?[jt]sx?$/i;
+function normalizeOutputRelativePath(outputDirectory, filePath) {
+  return path6__default.default.relative(outputDirectory, filePath).split(path6__default.default.sep).join("/");
+}
+function listOutputFiles(outputDirectory) {
+  if (!fs7__default.default.existsSync(outputDirectory) || !fs7__default.default.statSync(outputDirectory).isDirectory()) {
+    return [];
+  }
+  const files = [];
+  const visitDirectory = (directoryPath) => {
+    const entries = fs7__default.default.readdirSync(directoryPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const entryPath = path6__default.default.join(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        visitDirectory(entryPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(normalizeOutputRelativePath(outputDirectory, entryPath));
+      }
+    }
+  };
+  visitDirectory(outputDirectory);
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function isGenHtmlPreviewDirectoryCandidate(outputDirectory) {
+  return listOutputFiles(outputDirectory).some((filePath) => STORY_FILE_PATTERN.test(filePath));
+}
+
+// src/common/local-server/index.ts
+var LOCAL_SERVER_NPM_VIEW_TIMEOUT_MS = 1e4;
+var LOCAL_SERVER_SASS_VERSION = "^1.86.3";
+var STORYBOOK_VERSION = "8.6.14";
+var LOCAL_SERVER_LEGACY_FILE_NAMES = ["server.mjs"];
+var LOCAL_SERVER_STYLE_EXPORT_FILE_PATTERN = /\.(?:css|s[ac]ss)$/i;
+var REQUIRED_LOCAL_SERVER_PUBLISHED_DEPENDENCIES = {
+  "sales-frontend-assets": "0.0.22",
+  "sales-frontend-components": "1.0.7",
+  "sales-frontend-design-system": "0.1.5"
+};
+var WORKSPACE_PACKAGE_GROUP_NAMES = ["apps", "packages"];
+var WORKSPACE_ROOT_MARKER_FILE_NAMES = ["pnpm-workspace.yaml", "pnpm-workspace.yml"];
+var LOCAL_SERVER_RUNTIME_PACKAGE_NAMES = ["react", "react-dom"];
+new Set(
+  module$1.builtinModules.flatMap((moduleName) => [moduleName, moduleName.replace(/^node:/, ""), `node:${moduleName.replace(/^node:/, "")}`])
+);
+var LOCAL_SERVER_DEFAULT_PACKAGE_JSON = {
+  dependencies: {
+    "@storybook/addon-essentials": STORYBOOK_VERSION,
+    "@storybook/react": STORYBOOK_VERSION,
+    "@storybook/react-vite": STORYBOOK_VERSION,
+    react: "^19.1.0",
+    "react-dom": "^19.1.0",
+    sass: LOCAL_SERVER_SASS_VERSION,
+    storybook: STORYBOOK_VERSION
+  },
+  name: "ju-hong-e-local-server",
+  private: true,
+  scripts: {
+    dev: "storybook dev -c ./.storybook",
+    start: "storybook dev -c ./.storybook"
+  },
+  type: "commonjs"
+};
+function getLocalServerPaths(paths) {
+  const directoryPath = path6__default.default.join(paths.baseDir, "local-server");
+  const storybookConfigDirectoryPath = path6__default.default.join(directoryPath, ".storybook");
+  return {
+    directoryPath,
+    logPath: path6__default.default.join(directoryPath, "server.log"),
+    packageJsonPath: path6__default.default.join(directoryPath, "package.json"),
+    previewTargetPath: path6__default.default.join(directoryPath, "preview-target.json"),
+    statePath: path6__default.default.join(directoryPath, "server-state.json"),
+    storybookConfigDirectoryPath,
+    storybookMainConfigPath: path6__default.default.join(storybookConfigDirectoryPath, "main.ts"),
+    storybookPreviewConfigPath: path6__default.default.join(storybookConfigDirectoryPath, "preview.ts")
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeDependencies(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  return Object.entries(value).reduce((accumulator, [key, dependencyValue]) => {
+    if (typeof dependencyValue === "string" && dependencyValue.trim()) {
+      accumulator[key] = dependencyValue;
+    }
+    return accumulator;
+  }, {});
+}
+function mergeLocalServerPackageJson(value, extraDependencies = {}) {
+  const current = isRecord(value) ? value : {};
+  const dependencies = normalizeDependencies(current.dependencies);
+  const scripts = normalizeDependencies(current.scripts);
+  return {
+    ...current,
+    dependencies: {
+      ...LOCAL_SERVER_DEFAULT_PACKAGE_JSON.dependencies,
+      ...extraDependencies,
+      ...dependencies
+    },
+    name: typeof current.name === "string" && current.name.trim() ? current.name : LOCAL_SERVER_DEFAULT_PACKAGE_JSON.name,
+    private: typeof current.private === "boolean" ? current.private : LOCAL_SERVER_DEFAULT_PACKAGE_JSON.private,
+    scripts: {
+      ...scripts,
+      ...LOCAL_SERVER_DEFAULT_PACKAGE_JSON.scripts
+    },
+    type: LOCAL_SERVER_DEFAULT_PACKAGE_JSON.type
+  };
+}
+function normalizePublishedPackageVersion(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (Array.isArray(value)) {
+    return value.find((entry) => typeof entry === "string" && entry.trim().length > 0)?.trim() || "";
+  }
+  return "";
+}
+function fetchLatestPublishedPackageVersion(packageName, trace) {
+  const result = child_process.spawnSync("npm", ["view", packageName, "version", "--json"], {
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: LOCAL_SERVER_NPM_VIEW_TIMEOUT_MS
+  });
+  if (result.error || result.status !== 0) {
+    trace("local-server:setup:published-version:failed", `${packageName} ${getErrorSummary(result.error || result.stderr || result.status)}`);
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(result.stdout || '""');
+    const normalizedVersion = normalizePublishedPackageVersion(parsed);
+    if (normalizedVersion) {
+      trace("local-server:setup:published-version:resolved", `${packageName}@${normalizedVersion}`);
+    }
+    return normalizedVersion;
+  } catch (error) {
+    trace("local-server:setup:published-version:parse-failed", `${packageName} ${getErrorSummary(error)}`);
+    return "";
+  }
+}
+function resolveRequiredLocalServerPublishedDependencies(paths, trace, options = {}) {
+  const packageJsonPaths = collectWorkspacePackageJsonPaths(paths.rootDir);
+  const workspaceVersions = /* @__PURE__ */ new Map();
+  for (const packageJsonPath of packageJsonPaths) {
+    const manifest = readJsonFile(packageJsonPath);
+    const packageName = typeof manifest?.name === "string" ? manifest.name.trim() : "";
+    const packageVersion = typeof manifest?.version === "string" ? manifest.version.trim() : "";
+    if (!packageName || !packageVersion) {
+      continue;
+    }
+    workspaceVersions.set(packageName, packageVersion);
+  }
+  const resolvedDependencies = {};
+  const unresolvedDependencyNames = [];
+  for (const [dependencyName, fallbackVersion] of Object.entries(REQUIRED_LOCAL_SERVER_PUBLISHED_DEPENDENCIES)) {
+    const latestVersion = options.refreshPublishedDependencies ? fetchLatestPublishedPackageVersion(dependencyName, trace) : "";
+    const resolvedVersion = latestVersion || workspaceVersions.get(dependencyName) || fallbackVersion;
+    if (!resolvedVersion) {
+      unresolvedDependencyNames.push(dependencyName);
+      continue;
+    }
+    resolvedDependencies[dependencyName] = resolvedVersion;
+  }
+  if (Object.keys(resolvedDependencies).length > 0) {
+    trace(
+      "local-server:setup:required-published-dependencies",
+      Object.entries(resolvedDependencies).map(([dependencyName, version]) => `${dependencyName}@${version}`).join(", ")
+    );
+  }
+  if (unresolvedDependencyNames.length > 0) {
+    trace("local-server:setup:missing-required-workspace-dependencies", unresolvedDependencyNames.join(", "));
+  }
+  return resolvedDependencies;
+}
+function readJsonFile(filePath) {
+  if (!fs7__default.default.existsSync(filePath)) {
+    return void 0;
+  }
+  const raw = fs7__default.default.readFileSync(filePath, "utf8").trim();
+  if (!raw) {
+    return void 0;
+  }
+  return JSON.parse(raw);
+}
+function writeJsonFile(filePath, value) {
+  fs7__default.default.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function resolveLocalServerStyleExportTarget(value) {
+  if (typeof value === "string") {
+    return LOCAL_SERVER_STYLE_EXPORT_FILE_PATTERN.test(value) ? value : "";
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const resolvedTarget = resolveLocalServerStyleExportTarget(entry);
+      if (resolvedTarget) {
+        return resolvedTarget;
+      }
+    }
+    return "";
+  }
+  if (isRecord(value)) {
+    return resolveLocalServerStyleExportTarget(value.default) || resolveLocalServerStyleExportTarget(value.import) || resolveLocalServerStyleExportTarget(value.require);
+  }
+  return "";
+}
+function buildLocalServerStyleExportBridgeContent(bridgeFilePath, targetFilePath) {
+  const relativeTargetPath = path6__default.default.relative(path6__default.default.dirname(bridgeFilePath), targetFilePath).split(path6__default.default.sep).join("/");
+  const normalizedTargetPath = relativeTargetPath.startsWith(".") ? relativeTargetPath : `./${relativeTargetPath}`;
+  if (path6__default.default.extname(targetFilePath).toLowerCase() === ".css") {
+    return `@import '${normalizedTargetPath}';
+`;
+  }
+  return `@forward '${normalizedTargetPath}';
+`;
+}
+function synchronizeLocalServerStyleExportBridges(paths, trace) {
+  const { directoryPath, packageJsonPath } = getLocalServerPaths(paths);
+  const localServerPackageJson = readJsonFile(packageJsonPath);
+  const dependencyNames = Object.keys(normalizeDependencies(localServerPackageJson?.dependencies));
+  for (const dependencyName of dependencyNames) {
+    const dependencyDirectoryPath = path6__default.default.join(directoryPath, "node_modules", ...dependencyName.split("/"));
+    const dependencyPackageJsonPath = path6__default.default.join(dependencyDirectoryPath, "package.json");
+    const dependencyPackageJson = readJsonFile(dependencyPackageJsonPath);
+    const dependencyExports = isRecord(dependencyPackageJson?.exports) ? dependencyPackageJson.exports : {};
+    for (const [exportKey, exportValue] of Object.entries(dependencyExports)) {
+      if (!exportKey.startsWith("./")) {
+        continue;
+      }
+      const exportTargetPath = resolveLocalServerStyleExportTarget(exportValue);
+      if (!exportTargetPath) {
+        continue;
+      }
+      const exportSubpath = exportKey.slice(2);
+      if (!exportSubpath) {
+        continue;
+      }
+      const targetFilePath = path6__default.default.resolve(dependencyDirectoryPath, exportTargetPath);
+      if (!fs7__default.default.existsSync(targetFilePath) || !fs7__default.default.statSync(targetFilePath).isFile()) {
+        trace("local-server:style-export-bridge:missing-target", `${dependencyName} ${exportKey} -> ${targetFilePath}`);
+        continue;
+      }
+      const bridgeFilePath = path6__default.default.join(
+        dependencyDirectoryPath,
+        ...exportSubpath.split("/").filter(Boolean)
+      ) + path6__default.default.extname(targetFilePath);
+      const bridgeContent = buildLocalServerStyleExportBridgeContent(bridgeFilePath, targetFilePath);
+      const currentBridgeContent = fs7__default.default.existsSync(bridgeFilePath) ? fs7__default.default.readFileSync(bridgeFilePath, "utf8") : "";
+      if (currentBridgeContent === bridgeContent) {
+        continue;
+      }
+      fs7__default.default.mkdirSync(path6__default.default.dirname(bridgeFilePath), { recursive: true });
+      fs7__default.default.writeFileSync(bridgeFilePath, bridgeContent, "utf8");
+      trace("local-server:style-export-bridge:written", `${dependencyName} ${exportKey} -> ${bridgeFilePath}`);
+    }
+  }
+}
+function normalizePreviewTargetDirectory(directoryPath) {
+  if (typeof directoryPath !== "string" || !directoryPath.trim()) {
+    return void 0;
+  }
+  return path6__default.default.resolve(directoryPath);
+}
+function normalizePreviewTargetDirectories(directoryPaths) {
+  if (!Array.isArray(directoryPaths)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      directoryPaths.map((directoryPath) => normalizePreviewTargetDirectory(directoryPath)).filter((directoryPath) => Boolean(directoryPath))
+    )
+  ).sort((left, right) => left.localeCompare(right));
+}
+function toLocalServerPreviewMode(target) {
+  return target.mode === "directory" ? "latest" : "all";
+}
+function buildPreviewTargetConfig(options = {}) {
+  const resolvedOutputDirectory = normalizePreviewTargetDirectory(options.outputDirectory);
+  const resolvedPreviousDirectory = normalizePreviewTargetDirectory(options.previousTarget?.directory);
+  const resolvedDirectories = normalizePreviewTargetDirectories(options.directories ?? options.previousTarget?.directories);
+  const targetDirectory = resolvedOutputDirectory || resolvedPreviousDirectory;
+  const targetMode = options.mode || toLocalServerPreviewMode(options.previousTarget || { mode: "all" });
+  if (targetMode === "all") {
+    return targetDirectory || resolvedDirectories.length > 0 ? {
+      ...targetDirectory ? { directory: targetDirectory } : {},
+      ...resolvedDirectories.length > 0 ? { directories: resolvedDirectories } : {},
+      mode: "all"
+    } : { mode: "all" };
+  }
+  if (!targetDirectory) {
+    return { mode: "all" };
+  }
+  return {
+    directory: targetDirectory,
+    mode: "directory"
+  };
+}
+function readPreviewTargetConfig(filePath) {
+  const parsed = readJsonFile(filePath);
+  const normalizedDirectory = normalizePreviewTargetDirectory(parsed?.directory);
+  const normalizedDirectories = normalizePreviewTargetDirectories(parsed?.directories);
+  if (parsed?.mode === "directory" && normalizedDirectory) {
+    return {
+      directory: normalizedDirectory,
+      mode: "directory"
+    };
+  }
+  if (parsed?.mode === "all") {
+    return normalizedDirectory ? {
+      directory: normalizedDirectory,
+      ...normalizedDirectories.length > 0 ? { directories: normalizedDirectories } : {},
+      mode: "all"
+    } : normalizedDirectories.length > 0 ? {
+      directories: normalizedDirectories,
+      mode: "all"
+    } : { mode: "all" };
+  }
+  return { mode: "all" };
+}
+function listGeneratedOutputDirectories(paths) {
+  const generatedRootPath = path6__default.default.join(paths.baseDir, "generated");
+  if (!fs7__default.default.existsSync(generatedRootPath) || !fs7__default.default.statSync(generatedRootPath).isDirectory()) {
+    return [];
+  }
+  return fs7__default.default.readdirSync(generatedRootPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path6__default.default.join(generatedRootPath, entry.name)).sort((left, right) => left.localeCompare(right));
+}
+function resolveValidGeneratedPreviewDirectories(paths) {
+  return listGeneratedOutputDirectories(paths).filter((directoryPath) => isGenHtmlPreviewDirectoryCandidate(directoryPath));
+}
+function selectPreviewTargetDirectory(preferredDirectory, validDirectories) {
+  if (preferredDirectory && validDirectories.includes(preferredDirectory)) {
+    return preferredDirectory;
+  }
+  return validDirectories.length > 0 ? validDirectories[validDirectories.length - 1] : void 0;
+}
+function setLocalServerPreviewTarget(paths, options = {}) {
+  const localServerPaths = getLocalServerPaths(paths);
+  const currentTarget = fs7__default.default.existsSync(localServerPaths.previewTargetPath) ? readPreviewTargetConfig(localServerPaths.previewTargetPath) : buildPreviewTargetConfig();
+  const resolvedMode = options.mode || toLocalServerPreviewMode(currentTarget);
+  const validDirectories = resolvedMode === "all" ? resolveValidGeneratedPreviewDirectories(paths) : [];
+  const resolvedOutputDirectory = normalizePreviewTargetDirectory(options.outputDirectory);
+  const effectiveDirectory = resolvedMode === "all" ? selectPreviewTargetDirectory(resolvedOutputDirectory || currentTarget.directory, validDirectories) : resolvedOutputDirectory || currentTarget.directory;
+  const nextTarget = buildPreviewTargetConfig({
+    directories: validDirectories,
+    mode: resolvedMode,
+    outputDirectory: effectiveDirectory,
+    previousTarget: currentTarget
+  });
+  writeJsonFile(localServerPaths.previewTargetPath, nextTarget);
+}
+function collectWorkspacePackageJsonPaths(rootDir) {
+  const workspaceRootDir = resolveWorkspaceRootDirectory(rootDir);
+  const packageJsonPaths = [path6__default.default.join(workspaceRootDir, "package.json")].filter((filePath) => fs7__default.default.existsSync(filePath));
+  for (const groupName of WORKSPACE_PACKAGE_GROUP_NAMES) {
+    const groupDirectoryPath = path6__default.default.join(workspaceRootDir, groupName);
+    if (!fs7__default.default.existsSync(groupDirectoryPath) || !fs7__default.default.statSync(groupDirectoryPath).isDirectory()) {
+      continue;
+    }
+    for (const entry of fs7__default.default.readdirSync(groupDirectoryPath, { withFileTypes: true })) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path6__default.default.join(groupDirectoryPath, entry.name, "package.json");
+      if (fs7__default.default.existsSync(packageJsonPath)) {
+        packageJsonPaths.push(packageJsonPath);
+      }
+    }
+  }
+  return packageJsonPaths.sort((left, right) => left.localeCompare(right));
+}
+function isWorkspaceRootDirectory(directoryPath) {
+  if (!directoryPath) {
+    return false;
+  }
+  if (WORKSPACE_ROOT_MARKER_FILE_NAMES.some((fileName) => fs7__default.default.existsSync(path6__default.default.join(directoryPath, fileName)))) {
+    return true;
+  }
+  const packageJsonPath = path6__default.default.join(directoryPath, "package.json");
+  const manifest = readJsonFile(packageJsonPath);
+  if (!isRecord(manifest)) {
+    return false;
+  }
+  return Boolean(manifest.workspaces);
+}
+function resolveWorkspaceRootDirectory(startDirectory) {
+  let currentDirectoryPath = path6__default.default.resolve(startDirectory);
+  while (true) {
+    if (isWorkspaceRootDirectory(currentDirectoryPath)) {
+      return currentDirectoryPath;
+    }
+    const parentDirectoryPath = path6__default.default.dirname(currentDirectoryPath);
+    if (parentDirectoryPath === currentDirectoryPath) {
+      return path6__default.default.resolve(startDirectory);
+    }
+    currentDirectoryPath = parentDirectoryPath;
+  }
+}
+function listAncestorDirectories(startDirectory) {
+  const directories = [];
+  let currentDirectoryPath = path6__default.default.resolve(startDirectory);
+  while (true) {
+    directories.push(currentDirectoryPath);
+    const parentDirectoryPath = path6__default.default.dirname(currentDirectoryPath);
+    if (parentDirectoryPath === currentDirectoryPath) {
+      break;
+    }
+    currentDirectoryPath = parentDirectoryPath;
+  }
+  return directories;
+}
+function resolveInstalledPackageVersion(dependencyName, startDirectories) {
+  const candidateDirectories = Array.from(
+    new Set(
+      startDirectories.flatMap((directoryPath) => {
+        if (!directoryPath) {
+          return [];
+        }
+        return listAncestorDirectories(directoryPath);
+      })
+    )
+  );
+  for (const directoryPath of candidateDirectories) {
+    const packageJsonPath = path6__default.default.join(directoryPath, "node_modules", ...dependencyName.split("/"), "package.json");
+    const manifest = readJsonFile(packageJsonPath);
+    const version = typeof manifest?.version === "string" ? manifest.version.trim() : "";
+    if (version) {
+      return version;
+    }
+  }
+  return "";
+}
+function resolvePreferredManifestDependencyEntry(manifest, dependencyName) {
+  if (!isRecord(manifest)) {
+    return void 0;
+  }
+  const dependencyFields = [
+    { fieldName: "dependencies", priority: 1 },
+    { fieldName: "devDependencies", priority: 2 },
+    { fieldName: "optionalDependencies", priority: 3 },
+    { fieldName: "peerDependencies", priority: 4 }
+  ];
+  for (const { fieldName, priority } of dependencyFields) {
+    const dependencies = normalizeDependencies(manifest[fieldName]);
+    const version = dependencies[dependencyName]?.trim();
+    if (!version || version.startsWith("workspace:") || version.startsWith("file:")) {
+      continue;
+    }
+    return {
+      priority,
+      version
+    };
+  }
+  return void 0;
+}
+function resolvePreferredWorkspaceDependencyVersions(rootDir, dependencyNames) {
+  const packageJsonPaths = collectWorkspacePackageJsonPaths(rootDir);
+  const resolvedEntries = /* @__PURE__ */ new Map();
+  for (const packageJsonPath of packageJsonPaths) {
+    const manifest = readJsonFile(packageJsonPath);
+    for (const dependencyName of dependencyNames) {
+      const candidate = resolvePreferredManifestDependencyEntry(manifest, dependencyName);
+      const current = resolvedEntries.get(dependencyName);
+      if (!candidate) {
+        continue;
+      }
+      if (!current || candidate.priority < current.priority) {
+        resolvedEntries.set(dependencyName, candidate);
+      }
+    }
+  }
+  return Object.fromEntries(
+    dependencyNames.map((dependencyName) => [dependencyName, resolvedEntries.get(dependencyName)?.version || ""]).filter(([, version]) => Boolean(version))
+  );
+}
+function resolveLocalServerRuntimeDependencies(paths, localServerDirectoryPath, trace) {
+  const dependencyNames = [...LOCAL_SERVER_RUNTIME_PACKAGE_NAMES];
+  const workspaceResolved = resolvePreferredWorkspaceDependencyVersions(paths.rootDir, dependencyNames);
+  const workspaceRootDir = resolveWorkspaceRootDirectory(paths.rootDir);
+  const resolvedDependencies = dependencyNames.reduce((accumulator, dependencyName) => {
+    const version = workspaceResolved[dependencyName] || resolveInstalledPackageVersion(dependencyName, [paths.rootDir, workspaceRootDir, localServerDirectoryPath]);
+    if (version) {
+      accumulator[dependencyName] = version;
+    }
+    return accumulator;
+  }, {});
+  if (Object.keys(resolvedDependencies).length > 0) {
+    trace(
+      "local-server:setup:runtime-dependencies",
+      Object.entries(resolvedDependencies).map(([dependencyName, version]) => `${dependencyName}@${version}`).join(", ")
+    );
+  }
+  return resolvedDependencies;
+}
+function installLocalServerDependencies(directoryPath, trace) {
+  trace("local-server:install:start", directoryPath);
+  const result = child_process.spawnSync("npm", ["install"], {
+    cwd: directoryPath,
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024 * 20,
+    stdio: "inherit"
+  });
+  if (result.error || result.status !== 0) {
+    trace("local-server:install:failed", getErrorSummary(result.error || result.stderr || result.status));
+    throw new Error("\uB85C\uCEEC \uD504\uB9AC\uBDF0 \uC11C\uBC84 \uC758\uC874\uC131 \uC124\uCE58\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+  }
+  trace("local-server:install:done", directoryPath);
+}
+function hasAllLocalServerDependencies(directoryPath) {
+  const packageJsonPath = path6__default.default.join(directoryPath, "package.json");
+  const packageJson = readJsonFile(packageJsonPath);
+  const dependencies = Object.keys(normalizeDependencies(packageJson?.dependencies));
+  if (dependencies.length === 0) {
+    return true;
+  }
+  return dependencies.every((dependencyName) => fs7__default.default.existsSync(path6__default.default.join(directoryPath, "node_modules", ...dependencyName.split("/"))));
+}
+function ensureLocalServerDependencies(paths, trace, forceInstall = false) {
+  const { directoryPath } = getLocalServerPaths(paths);
+  const nodeModulesPath = path6__default.default.join(directoryPath, "node_modules");
+  const hasNodeModules = fs7__default.default.existsSync(nodeModulesPath);
+  const hasRequiredDependencies = hasNodeModules ? hasAllLocalServerDependencies(directoryPath) : false;
+  const shouldInstall = forceInstall || !hasNodeModules || !hasRequiredDependencies;
+  if (hasNodeModules && !hasRequiredDependencies) {
+    trace("local-server:install:repair", directoryPath);
+  }
+  if (shouldInstall) {
+    installLocalServerDependencies(directoryPath, trace);
+  }
+  synchronizeLocalServerStyleExportBridges(paths, trace);
+}
+function toSortedDependencies(dependencies) {
+  return Object.fromEntries(Object.entries(dependencies).sort(([left], [right]) => left.localeCompare(right)));
+}
+function getStorybookMainConfigContent() {
+  return `import fs from 'node:fs';
+import path from 'node:path';
+import type { StorybookConfig } from '@storybook/react-vite';
+import type { Alias, Plugin } from 'vite';
+
+const localServerRoot = path.resolve(__dirname, '..');
+const localServerPackageJsonPath = path.resolve(localServerRoot, 'package.json');
+const previewTargetPath = path.resolve(__dirname, '../preview-target.json');
+const workspaceRoot = path.resolve(__dirname, '..', '..');
+const generatedFileEndpointPath = '/__ju_hong_e__/generated-file';
+const dependencyAliasExcludeNames = new Set(['react', 'react-dom', 'sass', 'storybook']);
+const dependencyAliasExcludePrefixes = ['@storybook/'];
+
+function toPosix(value: string) {
+  return value.split(path.sep).join('/');
+}
+
+function readLocalServerDependencies() {
+  try {
+    const raw = fs.readFileSync(localServerPackageJsonPath, 'utf8').trim();
+
+    if (!raw) {
+      return {};
+    }
+
+    const parsed = JSON.parse(raw) as { dependencies?: Record<string, string> };
+
+    return parsed.dependencies && typeof parsed.dependencies === 'object' ? parsed.dependencies : {};
+  } catch {
+    return {};
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function resolveExportTarget(value: unknown): string {
+  if (typeof value === 'string' && value.trim()) {
+    return value.trim();
+  }
+
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const resolvedTarget = resolveExportTarget(entry);
+
+      if (resolvedTarget) {
+        return resolvedTarget;
+      }
+    }
+
+    return '';
+  }
+
+  if (isRecord(value)) {
+    return resolveExportTarget(value.import) || resolveExportTarget(value.default) || resolveExportTarget(value.require);
+  }
+
+  return '';
+}
+
+	function escapeRegExp(value: string) {
+	  return value.replace(/[][\\\\^$.*+?(){}|]/g, '\\\\$&');
+	}
+
+function buildDependencyAliases() {
+  return Object.keys(readLocalServerDependencies()).reduce<Alias[]>((accumulator, dependencyName) => {
+    if (dependencyAliasExcludeNames.has(dependencyName) || dependencyAliasExcludePrefixes.some((prefix) => dependencyName.startsWith(prefix))) {
+      return accumulator;
+    }
+
+    const dependencyPath = path.resolve(localServerRoot, 'node_modules', ...dependencyName.split('/'));
+    const dependencyPackageJsonPath = path.resolve(dependencyPath, 'package.json');
+
+    if (fs.existsSync(dependencyPath)) {
+      try {
+        const dependencyPackageJson = JSON.parse(fs.readFileSync(dependencyPackageJsonPath, 'utf8')) as { exports?: Record<string, unknown> };
+        const dependencyExports = isRecord(dependencyPackageJson.exports) ? dependencyPackageJson.exports : {};
+        const rootExportTarget = resolveExportTarget(dependencyExports['.']);
+        const rootReplacement = rootExportTarget ? path.resolve(dependencyPath, rootExportTarget) : dependencyPath;
+        const dependencyNamePattern = escapeRegExp(dependencyName);
+
+        accumulator.push({
+          find: new RegExp(\`^\${dependencyNamePattern}$\`),
+          replacement: rootReplacement
+        });
+
+        for (const [exportKey, exportValue] of Object.entries(dependencyExports)) {
+          if (!exportKey.startsWith('./')) {
+            continue;
+          }
+
+          const exportTarget = resolveExportTarget(exportValue);
+
+          if (!exportTarget) {
+            continue;
+          }
+
+          accumulator.push({
+            find: new RegExp(\`^\${escapeRegExp(\`\${dependencyName}/\${exportKey.slice(2)}\`)}$\`),
+            replacement: path.resolve(dependencyPath, exportTarget)
+          });
+        }
+      } catch {
+        accumulator.push({
+          find: new RegExp(\`^\${escapeRegExp(dependencyName)}$\`),
+          replacement: dependencyPath
+        });
+      }
+
+      accumulator.push({
+        find: new RegExp(\`^\${escapeRegExp(dependencyName)}/(.+)$\`),
+        replacement: \`\${dependencyPath}/$1\`
+      });
+    }
+
+    return accumulator;
+  }, []);
+}
+
+function readPreviewTarget() {
+  try {
+    const raw = fs.readFileSync(previewTargetPath, 'utf8').trim();
+
+    if (!raw) {
+      return { mode: 'all' } as const;
+    }
+
+    const parsed = JSON.parse(raw) as { directory?: string; directories?: string[]; mode?: string };
+    const directory = typeof parsed.directory === 'string' && parsed.directory.trim() ? path.resolve(parsed.directory) : undefined;
+    const directories = Array.isArray(parsed.directories)
+      ? Array.from(
+          new Set(
+            parsed.directories
+              .filter((value): value is string => typeof value === 'string' && value.trim())
+              .map((value) => path.resolve(value))
+          )
+        ).sort((left, right) => left.localeCompare(right))
+      : undefined;
+
+    if (parsed.mode === 'directory' && directory) {
+      return {
+        directory,
+        mode: 'directory'
+      } as const;
+    }
+
+    if (parsed.mode === 'all') {
+      return {
+        ...(directory ? { directory } : {}),
+        ...(directories ? { directories } : {}),
+        mode: 'all'
+      } as const;
+    }
+  } catch {
+    return { mode: 'all' } as const;
+  }
+
+  return { mode: 'all' } as const;
+}
+
+function getAllowedGeneratedDirectories() {
+  const target = readPreviewTarget();
+
+  if (target.mode === 'all') {
+    if (Array.isArray(target.directories) && target.directories.length > 0) {
+      return target.directories;
+    }
+
+    return [path.resolve(localServerRoot, '..', 'generated')];
+  }
+
+  if (target.directory) {
+    return [target.directory];
+  }
+
+  return [path.resolve(localServerRoot, '..', 'generated')];
+}
+
+function isPathInsideDirectory(directoryPath: string, filePath: string) {
+  const relativePath = path.relative(directoryPath, filePath);
+
+  return relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+
+function resolveGeneratedFilePath(source: string) {
+  const normalizedSource = source.trim();
+
+  if (!normalizedSource) {
+    return '';
+  }
+
+  let candidate = normalizedSource;
+
+  try {
+    if (/^https?:\\/\\//i.test(candidate)) {
+      candidate = new URL(candidate).pathname;
+    }
+  } catch {
+    return '';
+  }
+
+  if (candidate.startsWith('/@fs/')) {
+    return path.resolve('/', candidate.slice('/@fs/'.length));
+  }
+
+  if (candidate.startsWith('/')) {
+    return path.resolve(candidate);
+  }
+
+  return path.resolve(workspaceRoot, candidate);
+}
+
+function createGeneratedFileProxyPlugin(): Plugin {
+  return {
+    configureServer(server) {
+      server.middlewares.use((request, response, next) => {
+        if (!request.url) {
+          next();
+
+          return;
+        }
+
+        const requestUrl = new URL(request.url, 'http://127.0.0.1');
+
+        if (requestUrl.pathname !== generatedFileEndpointPath) {
+          next();
+
+          return;
+        }
+
+        const filePath = resolveGeneratedFilePath(requestUrl.searchParams.get('source') || '');
+        const allowedDirectories = getAllowedGeneratedDirectories();
+        const isAllowedFile =
+          Boolean(filePath) &&
+          fs.existsSync(filePath) &&
+          fs.statSync(filePath).isFile() &&
+          allowedDirectories.some((directoryPath) => isPathInsideDirectory(directoryPath, filePath));
+
+        if (!isAllowedFile) {
+          response.statusCode = 404;
+          response.setHeader('Content-Type', 'text/plain; charset=utf-8');
+          response.end('\uC0DD\uC131\uB41C \uD30C\uC77C\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.');
+
+          return;
+        }
+
+        const shouldDownload = requestUrl.searchParams.get('download') === '1';
+        const content = fs.readFileSync(filePath, 'utf8');
+
+        response.statusCode = 200;
+        response.setHeader('Cache-Control', 'no-store');
+        response.setHeader('Content-Type', 'text/plain; charset=utf-8');
+        response.setHeader('X-Content-Type-Options', 'nosniff');
+        response.setHeader(
+          'Content-Disposition',
+          \`\${shouldDownload ? 'attachment' : 'inline'}; filename*=UTF-8''\${encodeURIComponent(path.basename(filePath))}\`
+        );
+        response.end(content);
+      });
+    },
+    name: 'ju-hong-e-generated-file-proxy'
+  };
+}
+
+function resolveStories() {
+  const target = readPreviewTarget();
+
+  if (target.mode === 'directory' && target.directory) {
+    const relativePattern = toPosix(path.relative(__dirname, target.directory));
+
+    return [\`\${relativePattern}/**/*.stories.@(js|jsx|ts|tsx)\`];
+  }
+
+  if (target.mode === 'all' && Array.isArray(target.directories)) {
+    return target.directories.map((directory) => \`\${toPosix(path.relative(__dirname, directory))}/**/*.stories.@(js|jsx|ts|tsx)\`);
+  }
+
+  return ['../../generated/**/*.stories.@(js|jsx|ts|tsx)'];
+}
+
+const dependencyAliases = buildDependencyAliases();
+
+const config: StorybookConfig = {
+  stories: resolveStories(),
+  addons: ['@storybook/addon-essentials'],
+  framework: {
+    name: '@storybook/react-vite',
+    options: {}
+  },
+  docs: {
+    autodocs: false
+  },
+  viteFinal: async (config) => {
+    const currentAllow = Array.isArray(config.server?.fs?.allow) ? config.server.fs.allow : [];
+    const currentPlugins = Array.isArray(config.plugins) ? config.plugins : config.plugins ? [config.plugins] : [];
+    const currentResolveAlias = config.resolve?.alias;
+    const currentResolveAliasArray = Array.isArray(currentResolveAlias)
+      ? currentResolveAlias
+      : Object.entries(currentResolveAlias || {}).map(([find, replacement]) => ({ find, replacement }));
+    const mergedAlias = [...dependencyAliases, ...currentResolveAliasArray];
+
+    config.server = {
+      ...(config.server || {}),
+      fs: {
+        ...(config.server?.fs || {}),
+        allow: Array.from(new Set([...currentAllow, workspaceRoot]))
+      }
+    };
+    config.resolve = {
+      ...(config.resolve || {}),
+      alias: mergedAlias
+    };
+    config.plugins = [...currentPlugins, createGeneratedFileProxyPlugin()];
+
+    return config;
+  }
+};
+
+export default config;
+`;
+}
+function getStorybookPreviewConfigContent() {
+  return `import type { Preview } from '@storybook/react';
+import 'sales-frontend-design-system/core-styles';
+
+const preview: Preview = {
+  parameters: {
+    layout: 'fullscreen',
+    controls: {
+      matchers: {
+        color: /(background|color)$/i,
+        date: /Date$/i
+      }
+    },
+    options: {
+      storySort: {
+        method: 'alphabetical'
+      }
+    }
+  }
+};
+
+export default preview;
+`;
+}
+function removeLegacyLocalServerFiles(localServerPaths, trace) {
+  for (const fileName of LOCAL_SERVER_LEGACY_FILE_NAMES) {
+    const targetPath = path6__default.default.join(localServerPaths.directoryPath, fileName);
+    if (!fs7__default.default.existsSync(targetPath)) {
+      continue;
+    }
+    fs7__default.default.unlinkSync(targetPath);
+    trace("local-server:cleanup:legacy-file", targetPath);
+  }
+}
+function ensureLocalServerSetup(paths, trace, outputDirectory, options = {}) {
+  const localServerPaths = getLocalServerPaths(paths);
+  const requiredWorkspaceDependencies = resolveRequiredLocalServerPublishedDependencies(paths, trace, options);
+  const runtimeDependencies = resolveLocalServerRuntimeDependencies(paths, localServerPaths.directoryPath, trace);
+  const generatedDependencies = {};
+  fs7__default.default.mkdirSync(localServerPaths.directoryPath, { recursive: true });
+  fs7__default.default.mkdirSync(localServerPaths.storybookConfigDirectoryPath, { recursive: true });
+  removeLegacyLocalServerFiles(localServerPaths, trace);
+  trace("local-server:setup:dir", localServerPaths.directoryPath);
+  let packageJson = mergeLocalServerPackageJson(void 0, generatedDependencies);
+  if (fs7__default.default.existsSync(localServerPaths.packageJsonPath)) {
+    try {
+      packageJson = mergeLocalServerPackageJson(readJsonFile(localServerPaths.packageJsonPath), generatedDependencies);
+    } catch (error) {
+      throw new Error(`\uB85C\uCEEC \uD504\uB9AC\uBDF0 \uC11C\uBC84 package.json\uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. ${getErrorSummary(error)}`);
+    }
+  }
+  packageJson = {
+    ...packageJson,
+    dependencies: {
+      ...normalizeDependencies(packageJson.dependencies),
+      ...requiredWorkspaceDependencies,
+      ...runtimeDependencies
+    }
+  };
+  const normalizedPackageJson = {
+    ...packageJson,
+    dependencies: toSortedDependencies(normalizeDependencies(packageJson.dependencies))
+  };
+  const nextPackageJsonContent = `${JSON.stringify(normalizedPackageJson, null, 2)}
+`;
+  const previousPackageJsonContent = fs7__default.default.existsSync(localServerPaths.packageJsonPath) ? fs7__default.default.readFileSync(localServerPaths.packageJsonPath, "utf8") : "";
+  const packageJsonChanged = previousPackageJsonContent !== nextPackageJsonContent;
+  if (packageJsonChanged) {
+    fs7__default.default.writeFileSync(localServerPaths.packageJsonPath, nextPackageJsonContent, "utf8");
+    trace("local-server:setup:package-json-updated", localServerPaths.packageJsonPath);
+  }
+  fs7__default.default.writeFileSync(localServerPaths.storybookMainConfigPath, getStorybookMainConfigContent(), "utf8");
+  fs7__default.default.writeFileSync(localServerPaths.storybookPreviewConfigPath, getStorybookPreviewConfigContent(), "utf8");
+  setLocalServerPreviewTarget(paths, { outputDirectory });
+  trace("local-server:setup:files", localServerPaths.storybookConfigDirectoryPath);
+  ensureLocalServerDependencies(paths, trace, packageJsonChanged);
+  return {
+    dependencies: toSortedDependencies(normalizeDependencies(normalizedPackageJson.dependencies)),
+    packageJsonPath: localServerPaths.packageJsonPath
+  };
+}
+
+// src/common/app/service-selection.ts
+async function chooseService(title) {
+  return selectSingleOption(
+    title,
+    AI_SERVICES.map((service) => ({
+      description: service === "codex" ? "OpenAI Codex CLI" : service === "gemini" ? "Google Gemini CLI" : "Anthropic Claude CLI",
+      label: service,
+      value: service
+    }))
+  );
+}
+async function resolveInitialService(paths, parsedArgs, trace) {
+  const savedService = readSavedService(paths);
+  if (parsedArgs.service) {
+    trace("service:from-args", parsedArgs.service);
+    saveService(paths, parsedArgs.service);
+    if (savedService !== parsedArgs.service) {
+      const summary = savedService ? `\uC11C\uBE44\uC2A4 \uBCC0\uACBD: ${savedService} -> ${parsedArgs.service}` : `\uCD08\uAE30 \uC11C\uBE44\uC2A4 \uC120\uD0DD: ${parsedArgs.service}`;
+      writeServiceChangeHistory(paths, savedService, parsedArgs.service, loadRecentHistoryContext(paths));
+      appendConversationHistory(paths, {
+        nextService: parsedArgs.service,
+        previousService: savedService,
+        scope: "service-change",
+        service: parsedArgs.service,
+        summary,
+        title: "\uC11C\uBE44\uC2A4 \uBCC0\uACBD"
+      });
+    }
+    return parsedArgs.service;
+  }
+  if (savedService) {
+    trace("service:from-file", savedService);
+    return savedService;
+  }
+  trace("service:interactive:start");
+  const selected = await chooseService("\uC0AC\uC6A9\uD560 AI \uC11C\uBE44\uC2A4\uB97C \uC120\uD0DD\uD558\uC138\uC694.");
+  trace("service:interactive:end", selected);
+  saveService(paths, selected);
+  writeServiceChangeHistory(paths, "", selected, loadRecentHistoryContext(paths));
+  appendConversationHistory(paths, {
+    nextService: selected,
+    previousService: "",
+    scope: "service-change",
+    service: selected,
+    summary: `\uCD08\uAE30 \uC11C\uBE44\uC2A4 \uC120\uD0DD: ${selected}`,
+    title: "\uC11C\uBE44\uC2A4 \uBCC0\uACBD"
+  });
+  return selected;
+}
+
+// src/common/app/run-cli-app.ts
+async function runCliApp(options) {
+  configureCliRuntime({
+    binaryName: options.binaryName,
+    profile: options.profile
+  });
+  try {
+    await runCliAppInternal(options);
+  } catch (error) {
+    if (isUserTerminatedError(error)) {
+      console.log("\uC0AC\uC6A9\uC790 \uC694\uCCAD\uC73C\uB85C \uC138\uC158\uC744 \uC885\uB8CC\uD569\uB2C8\uB2E4.");
+      return;
+    }
+    if (isUserCancelledError(error)) {
+      console.log("\uC0AC\uC6A9\uC790 \uCDE8\uC18C\uB85C \uC138\uC158\uC744 \uC885\uB8CC\uD569\uB2C8\uB2E4.");
+      return;
+    }
+    const paths = getStoragePaths(process.cwd());
+    ensureStorageDirectories(paths);
+    const errorReportPath = writeErrorReport(paths, error, {
+      args: process.argv.slice(2),
+      scope: `${options.traceScope}:main`,
+      traceMessages: getTraceMessages()
+    });
+    console.error("\uC8FC\uD64D\uC774 \uC2E4\uD589 \uC911 \uCE58\uBA85\uC801\uC778 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.");
+    console.error(formatActionError(error));
+    console.error(`\uC5D0\uB7EC \uB9AC\uD3EC\uD2B8: ${errorReportPath}`);
+    process.exitCode = 1;
+  } finally {
+    await shutdownPostHogClient();
+  }
+}
+async function runCliAppInternal(options) {
+  const parsedArgs = parseCliArgs();
+  await loadCommandModules();
+  const builtinCommands = getBuiltinCommands();
+  const builtinSlashCommands = getBuiltinSlashCommands();
+  const builtinCommandNames = getBuiltinCommandNames();
+  if (parsedArgs.help) {
+    console.log(createCliHelpText(builtinCommands, void 0, options.binaryName));
+    return;
+  }
+  clearTraceMessages();
+  const trace = createTraceLogger(options.traceScope, parsedArgs);
+  const paths = getStoragePaths(process.cwd());
+  ensureStorageDirectories(paths);
+  trace("main:start", JSON.stringify({ ...parsedArgs, profile: options.profile }));
+  hydrateStreamOutputState(paths);
+  if (shouldEnableLocalServer(options.profile)) {
+    try {
+      ensureLocalServerSetup(paths, trace, void 0, {
+        refreshPublishedDependencies: true
+      });
+    } catch (error) {
+      trace("local-server:setup:skip", formatActionError(error));
+    }
+  }
+  const sessionRecords = [];
+  let currentService = await resolveInitialService(paths, parsedArgs, trace);
+  let promptHistory = loadPromptHistory(paths);
+  printSessionBanner({
+    commands: builtinSlashCommands,
+    service: currentService,
+    streamOutputEnabled: isStreamOutputEnabled(),
+    testMode: parsedArgs.testMode,
+    traceMode: parsedArgs.traceMode
+  });
+  let isRunning = true;
+  while (isRunning) {
+    const sessionCatalog = getSessionCommandCatalog(currentService);
+    let input = "";
+    try {
+      input = await promptSessionInput({
+        commands: sessionCatalog.slashCommands,
+        history: promptHistory,
+        service: currentService,
+        testMode: parsedArgs.testMode,
+        traceMode: parsedArgs.traceMode
+      });
+    } catch (error) {
+      if (isUserTerminatedError(error)) {
+        trace("session:input:terminated");
+        console.log("\uC138\uC158\uC744 \uC885\uB8CC\uD569\uB2C8\uB2E4.");
+        break;
+      }
+      throw error;
+    }
+    if (!input) {
+      continue;
+    }
+    promptHistory = appendPromptHistory(paths, input);
+    const resolvedSlashInput = resolveSlashCommandInput(input, builtinCommandNames);
+    const traceStartIndex = getTraceMessages().length;
+    try {
+      let record;
+      let shouldPrintBanner = false;
+      let shouldExit = false;
+      if (resolvedSlashInput?.kind === "builtin") {
+        const definition = findJuHongECommand(resolvedSlashInput.command);
+        if (!definition) {
+          throw new Error(`\uB4F1\uB85D\uB41C \uC8FC\uD64D\uC774 \uBA85\uB839\uC5B4\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. command=${resolvedSlashInput.command}`);
+        }
+        const result = await executeJuHongECommand(definition, {
+          args: resolvedSlashInput.args,
+          catalog: sessionCatalog,
+          command: resolvedSlashInput.command,
+          input,
+          parsedArgs,
+          paths,
+          rawArgs: resolvedSlashInput.rawArgs,
+          rawCommand: resolvedSlashInput.rawCommand,
+          service: currentService,
+          trace
+        });
+        if (result.nextService) {
+          currentService = result.nextService;
+        }
+        record = result.record;
+        shouldExit = Boolean(result.shouldExit);
+        shouldPrintBanner = Boolean(result.shouldPrintBanner);
+      } else if (resolvedSlashInput?.kind === "native") {
+        if (resolvedSlashInput.requestedService && resolvedSlashInput.requestedService !== currentService) {
+          console.log(`\uD604\uC7AC \uC120\uD0DD\uB41C \uC11C\uBE44\uC2A4\uB294 ${currentService} \uC785\uB2C8\uB2E4. [${currentService}] prefix\uB85C \uB2E4\uC2DC \uC2E4\uD589\uD558\uC138\uC694.`);
+        } else {
+          const result = await executeNativeCommand(findNativeCommand(currentService, resolvedSlashInput.command), {
+            args: resolvedSlashInput.args,
+            catalog: sessionCatalog,
+            command: resolvedSlashInput.command,
+            input,
+            parsedArgs,
+            paths,
+            rawArgs: resolvedSlashInput.rawArgs,
+            rawCommand: resolvedSlashInput.rawCommand,
+            requestedService: resolvedSlashInput.requestedService,
+            service: currentService,
+            trace
+          });
+          record = result.record;
+          shouldExit = Boolean(result.shouldExit);
+          shouldPrintBanner = Boolean(result.shouldPrintBanner);
+        }
+      } else {
+        record = await runChatAction({
+          input,
+          parsedArgs,
+          paths,
+          service: currentService,
+          trace
+        });
+      }
+      if (shouldPrintBanner) {
+        printSessionBanner({
+          commands: builtinSlashCommands,
+          service: currentService,
+          streamOutputEnabled: isStreamOutputEnabled(),
+          testMode: parsedArgs.testMode,
+          traceMode: parsedArgs.traceMode
+        });
+      }
+      if (shouldExit) {
+        trace("session:exit");
+        isRunning = false;
+      }
+      if (record) {
+        record.traceMessages = getTraceMessages().slice(traceStartIndex);
+        sessionRecords.push(record);
+      }
+    } catch (error) {
+      if (isUserTerminatedError(error)) {
+        trace("session:terminated", input);
+        console.log("\uC138\uC158\uC744 \uC885\uB8CC\uD569\uB2C8\uB2E4.");
+        break;
+      }
+      if (isUserCancelledError(error)) {
+        trace("action:cancelled", input);
+        console.log("\uD604\uC7AC \uC791\uC5C5\uC744 \uCDE8\uC18C\uD558\uACE0 \uB300\uD654 \uC785\uB825 \uC0C1\uD0DC\uB85C \uB3CC\uC544\uAC11\uB2C8\uB2E4.");
+        continue;
+      }
+      const errorTrace = getTraceMessages().slice(traceStartIndex);
+      const errorReportPath = writeErrorReport(paths, error, {
+        args: process.argv.slice(2),
+        extraSections: [
+          {
+            heading: "Current Service",
+            markdown: `\`${currentService}\``
+          }
+        ],
+        scope: `${options.traceScope}:action`,
+        traceMessages: errorTrace
+      });
+      console.error("\uC791\uC5C5 \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4.");
+      console.error(formatActionError(error));
+      console.error(`\uC5D0\uB7EC \uB9AC\uD3EC\uD2B8: ${errorReportPath}`);
+    }
+  }
+  if (parsedArgs.testMode) {
+    const reportPath = writeTestReport(
+      paths,
+      options.testReportTitle,
+      [
+        `- \uC2DC\uC791 \uC11C\uBE44\uC2A4: \`${readSavedService(paths) || currentService}\``,
+        `- \uCD1D \uC561\uC158 \uC218: \`${sessionRecords.length}\``,
+        "",
+        ...sessionRecords.map(
+          (record, index) => [
+            `## ${index + 1}. ${record.title}`,
+            "",
+            `- scope: \`${record.scope}\``,
+            `- service: \`${record.service}\``,
+            `- skipped: \`${record.skipped}\``,
+            `- summary: ${record.summary}`,
+            record.historyPath ? `- history: \`${record.historyPath}\`` : "",
+            record.previewCommand ? `- preview:
+\`\`\`sh
+${record.previewCommand}
+\`\`\`` : "",
+            `- trace:
+\`\`\`json
+${JSON.stringify(record.traceMessages, null, 2)}
+\`\`\``
+          ].filter(Boolean).join("\n")
+        )
+      ].join("\n")
+    );
+    console.log(`\uD14C\uC2A4\uD2B8 \uB9AC\uD3EC\uD2B8: ${reportPath}`);
+  }
+  trace("main:end", `service=${currentService}`);
+}
+
+// src/be.ts
+void runCliApp({
+  binaryName: "ju-hong-be",
+  profile: "be",
+  testReportTitle: "Ju-hong-be Test Session",
+  traceScope: "be"
+});
+//# sourceMappingURL=be.cjs.map
+//# sourceMappingURL=be.cjs.map