jutell 0.3.0

package/assets/local-admin-server.js

@@ -0,0 +1,1391 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../apps/local-admin/server/config/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  FEATURE_IDS: () => FEATURE_IDS,
+  LIMIT_RANGES: () => LIMIT_RANGES,
+  PROFILES: () => PROFILES,
+  SUPPORTED_VERSION: () => SUPPORTED_VERSION,
+  changedFields: () => changedFields,
+  validateConfig: () => validateConfig
+});
+function validateConfig(input) {
+  if (!isRecord(input)) return { ok: false, error: "\uC124\uC815\uC740 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+  if (!hasOnlyKeys(input, ["version", "profile", "features", "limits", "mcp", "usageMeasurement", "voice"])) {
+    return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC124\uC815 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4." };
+  }
+  if (input.version !== SUPPORTED_VERSION) return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC124\uC815 \uBC84\uC804\uC785\uB2C8\uB2E4." };
+  if (!["minimal", "balanced", "learning", "detailed"].includes(String(input.profile))) {
+    return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 Profile\uC785\uB2C8\uB2E4." };
+  }
+  if (!isRecord(input.features) || !hasOnlyKeys(input.features, FEATURE_IDS)) {
+    return { ok: false, error: "\uACF5\uC2DD Feature\uB9CC \uC124\uC815\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." };
+  }
+  for (const featureId of FEATURE_IDS) {
+    if (input.features[featureId] !== void 0 && typeof input.features[featureId] !== "boolean") {
+      return { ok: false, error: "Feature \uAC12\uC740 ON \uB610\uB294 OFF\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    }
+  }
+  if (!isRecord(input.limits) || !hasOnlyKeys(input.limits, Object.keys(LIMIT_RANGES))) {
+    return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 limits \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4." };
+  }
+  for (const [key, range] of Object.entries(LIMIT_RANGES)) {
+    const value = input.limits[key];
+    if (typeof value !== "number" || !Number.isInteger(value) || value < range.min || value > range.max) {
+      return { ok: false, error: `${key}\uB294 ${range.min}~${range.max} \uC0AC\uC774\uC758 \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4.` };
+    }
+  }
+  if ("mcp" in input && (!isRecord(input.mcp) || !hasOnlyKeys(input.mcp, ["enabled", "autoStart"]) || typeof input.mcp.enabled !== "boolean" || input.mcp.autoStart !== void 0 && typeof input.mcp.autoStart !== "boolean")) {
+    return { ok: false, error: "MCP \uC124\uC815\uC740 enabled(ON/OFF)\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." };
+  }
+  if ("usageMeasurement" in input && (!isRecord(input.usageMeasurement) || !hasOnlyKeys(input.usageMeasurement, ["localCountersEnabled"]) || typeof input.usageMeasurement.localCountersEnabled !== "boolean")) {
+    return { ok: false, error: "usageMeasurement \uC124\uC815\uC740 localCountersEnabled(ON/OFF)\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." };
+  }
+  if ("voice" in input && (!isRecord(input.voice) || !hasOnlyKeys(input.voice, ["preset"]) || input.voice.preset !== void 0 && !["default", "plain", "learning", "jutell"].includes(String(input.voice.preset)))) {
+    return { ok: false, error: "voice \uC124\uC815\uC758 preset\uC744 \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." };
+  }
+  const profile = input.profile;
+  const rawFeatures = input.features;
+  const features = Object.fromEntries(
+    FEATURE_IDS.map((id) => [id, typeof rawFeatures[id] === "boolean" ? rawFeatures[id] : PROFILES[profile].features[id]])
+  );
+  return {
+    ok: true,
+    value: {
+      version: SUPPORTED_VERSION,
+      profile,
+      features,
+      limits: { ...input.limits },
+      mcp: "mcp" in input ? { enabled: isRecord(input.mcp) ? input.mcp.enabled : false } : { ...DEFAULT_CONFIG.mcp },
+      usageMeasurement: "usageMeasurement" in input ? { ...input.usageMeasurement } : { ...DEFAULT_CONFIG.usageMeasurement },
+      ..."voice" in input ? { voice: { preset: input.voice && isRecord(input.voice) && typeof input.voice.preset === "string" ? input.voice.preset : "default" } } : {}
+    }
+  };
+}
+function changedFields(before, after) {
+  const changes = [];
+  if (before.profile !== after.profile) changes.push({ field: "profile", before: before.profile, after: after.profile });
+  for (const id of FEATURE_IDS) {
+    if (before.features[id] !== after.features[id]) {
+      changes.push({ field: `features.${id}`, before: before.features[id], after: after.features[id] });
+    }
+  }
+  for (const key of Object.keys(LIMIT_RANGES)) {
+    if (before.limits[key] !== after.limits[key]) {
+      changes.push({ field: `limits.${key}`, before: before.limits[key], after: after.limits[key] });
+    }
+  }
+  for (const key of ["enabled"]) {
+    if (before.mcp[key] !== after.mcp[key]) changes.push({ field: `mcp.${key}`, before: before.mcp[key], after: after.mcp[key] });
+  }
+  if (before.usageMeasurement.localCountersEnabled !== after.usageMeasurement.localCountersEnabled) {
+    changes.push({ field: "usageMeasurement.localCountersEnabled", before: before.usageMeasurement.localCountersEnabled, after: after.usageMeasurement.localCountersEnabled });
+  }
+  return changes;
+}
+var SUPPORTED_VERSION, FEATURE_IDS, PROFILES, DEFAULT_CONFIG, LIMIT_RANGES, isRecord, hasOnlyKeys;
+var init_schema = __esm({
+  "../../apps/local-admin/server/config/schema.ts"() {
+    SUPPORTED_VERSION = 1;
+    FEATURE_IDS = [
+      "changeSummary",
+      "userVisibleChanges",
+      "internalChanges",
+      "mainFiles",
+      "explainedDiff",
+      "glossary",
+      "validationResults",
+      "riskAssessment",
+      "userActions",
+      "nextActionSuggestions",
+      "requestClarificationGuide",
+      "manualEditGuidance",
+      "requestBuilder"
+    ];
+    PROFILES = {
+      minimal: {
+        features: {
+          changeSummary: true,
+          userVisibleChanges: true,
+          internalChanges: false,
+          mainFiles: false,
+          explainedDiff: false,
+          glossary: false,
+          validationResults: true,
+          riskAssessment: false,
+          userActions: true,
+          nextActionSuggestions: false,
+          requestClarificationGuide: false,
+          manualEditGuidance: false,
+          requestBuilder: true
+        },
+        limits: { maxMainFiles: 3, maxGlossaryTerms: 1, compactReportMaxSentences: 8 }
+      },
+      balanced: {
+        features: {
+          changeSummary: true,
+          userVisibleChanges: true,
+          internalChanges: true,
+          mainFiles: true,
+          explainedDiff: true,
+          glossary: true,
+          validationResults: true,
+          riskAssessment: true,
+          userActions: true,
+          nextActionSuggestions: true,
+          requestClarificationGuide: true,
+          manualEditGuidance: true,
+          requestBuilder: true
+        },
+        limits: { maxMainFiles: 5, maxGlossaryTerms: 3, compactReportMaxSentences: 12 }
+      },
+      learning: {
+        features: {
+          changeSummary: true,
+          userVisibleChanges: true,
+          internalChanges: true,
+          mainFiles: true,
+          explainedDiff: true,
+          glossary: true,
+          validationResults: true,
+          riskAssessment: true,
+          userActions: true,
+          nextActionSuggestions: true,
+          requestClarificationGuide: true,
+          manualEditGuidance: true,
+          requestBuilder: true
+        },
+        limits: { maxMainFiles: 5, maxGlossaryTerms: 6, compactReportMaxSentences: 12 }
+      },
+      detailed: {
+        features: {
+          changeSummary: true,
+          userVisibleChanges: true,
+          internalChanges: true,
+          mainFiles: true,
+          explainedDiff: true,
+          glossary: true,
+          validationResults: true,
+          riskAssessment: true,
+          userActions: true,
+          nextActionSuggestions: true,
+          requestClarificationGuide: true,
+          manualEditGuidance: true,
+          requestBuilder: true
+        },
+        limits: { maxMainFiles: 5, maxGlossaryTerms: 6, compactReportMaxSentences: 18 }
+      }
+    };
+    DEFAULT_CONFIG = {
+      version: SUPPORTED_VERSION,
+      profile: "balanced",
+      features: { ...PROFILES.balanced.features },
+      limits: { ...PROFILES.balanced.limits },
+      mcp: { enabled: false },
+      usageMeasurement: { localCountersEnabled: false }
+    };
+    LIMIT_RANGES = {
+      maxMainFiles: { min: 1, max: 10 },
+      maxGlossaryTerms: { min: 0, max: 10 },
+      compactReportMaxSentences: { min: 4, max: 30 }
+    };
+    isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+    hasOnlyKeys = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
+  }
+});
+
+// ../../apps/local-admin/server/app.ts
+init_schema();
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { createServer } from "node:http";
+import { promises as fs7 } from "node:fs";
+import path5 from "node:path";
+
+// ../../apps/local-admin/server/storage/files.ts
+init_schema();
+import { promises as fs, existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+function getStoragePaths(projectRoot) {
+  const preferredLocalDir = path.join(projectRoot, ".jutell-local");
+  const legacyLocalDir = path.join(projectRoot, ".beginner-bridge-local");
+  const localDir = existsSync(preferredLocalDir) || !existsSync(legacyLocalDir) ? preferredLocalDir : legacyLocalDir;
+  return {
+    projectRoot,
+    configFile: path.join(projectRoot, ".jutell.json"),
+    legacyConfigFile: path.join(projectRoot, ".beginner-bridge.json"),
+    localDir,
+    legacyLocalDir,
+    feedbackFile: path.join(localDir, "beta-feedback.json"),
+    historyFile: path.join(localDir, "settings-history.json"),
+    metadataFile: path.join(localDir, "metadata.json"),
+    usageCountersFile: path.join(localDir, "usage-counters.json"),
+    usageExperimentsFile: path.join(localDir, "usage-experiments.json")
+  };
+}
+var storageInitialization = /* @__PURE__ */ new Map();
+var fileWrites = /* @__PURE__ */ new Map();
+async function initializeStorage(paths) {
+  await fs.mkdir(paths.localDir, { recursive: true });
+  for (const [file, fallback] of [
+    [paths.feedbackFile, []],
+    [paths.historyFile, []],
+    [paths.metadataFile, { configVersion: 1, skillVersion: "not-recorded" }]
+  ]) {
+    try {
+      await fs.access(file);
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+      await writeJsonAtomically(file, fallback);
+    }
+  }
+}
+function ensureStorage(paths) {
+  const existing = storageInitialization.get(paths.localDir);
+  if (existing) return existing;
+  const initialization = initializeStorage(paths).catch((error2) => {
+    storageInitialization.delete(paths.localDir);
+    throw error2;
+  });
+  storageInitialization.set(paths.localDir, initialization);
+  return initialization;
+}
+async function readJson(file) {
+  const text = await fs.readFile(file, "utf8");
+  return JSON.parse(text);
+}
+async function readConfig(paths) {
+  try {
+    const configFile = await fs.access(paths.configFile).then(() => paths.configFile).catch(() => paths.legacyConfigFile);
+    const result = validateConfig(await readJson(configFile));
+    if (result.ok) return { config: result.value, fallback: false };
+    return { config: await readDefaultConfig(), fallback: true, warning: result.error };
+  } catch {
+    return { config: await readDefaultConfig(), fallback: true, warning: "\uC124\uC815 \uD30C\uC77C\uC744 \uC77D\uC744 \uC218 \uC5C6\uC5B4 \uAE30\uBCF8 \uC124\uC815\uC744 \uC0AC\uC6A9\uD569\uB2C8\uB2E4." };
+  }
+}
+async function readDefaultConfig() {
+  const { DEFAULT_CONFIG: DEFAULT_CONFIG2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+  return structuredClone(DEFAULT_CONFIG2);
+}
+async function writeJsonAtomicallyUnlocked(file, value) {
+  const directory = path.dirname(file);
+  await fs.mkdir(directory, { recursive: true });
+  const tempFile = path.join(directory, `.${path.basename(file)}.${process.pid}.${randomUUID()}.tmp`);
+  await fs.writeFile(tempFile, JSON.stringify(value, null, 2) + "\n", "utf8");
+  try {
+    JSON.parse(await fs.readFile(tempFile, "utf8"));
+    const backupFile = `${file}.previous`;
+    try {
+      await fs.rm(backupFile, { force: true });
+    } catch {
+    }
+    try {
+      await fs.rename(file, backupFile);
+    } catch {
+    }
+    try {
+      await fs.rename(tempFile, file);
+      await fs.rm(backupFile, { force: true });
+    } catch (error2) {
+      try {
+        await fs.rm(file, { force: true });
+      } catch {
+      }
+      try {
+        await fs.rename(backupFile, file);
+      } catch {
+      }
+      throw error2;
+    }
+  } finally {
+    await fs.rm(tempFile, { force: true });
+  }
+}
+function writeJsonAtomically(file, value) {
+  const previous = fileWrites.get(file) ?? Promise.resolve();
+  const write = previous.then(() => writeJsonAtomicallyUnlocked(file, value), () => writeJsonAtomicallyUnlocked(file, value));
+  const tracked = write.finally(() => {
+    if (fileWrites.get(file) === tracked) fileWrites.delete(file);
+  });
+  fileWrites.set(file, tracked);
+  return tracked;
+}
+async function readArray(file) {
+  const value = await readJson(file);
+  if (!Array.isArray(value)) throw new Error("\uC800\uC7A5\uB41C \uBAA9\uB85D \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  return value;
+}
+async function saveFeedback(paths, items) {
+  await writeJsonAtomically(paths.feedbackFile, items);
+}
+
+// ../../apps/local-admin/server/validation/feedback.ts
+init_schema();
+var TASK_TYPES = ["screen", "feature", "docs", "settings", "ui-ux-beta", "other"];
+var LENGTHES = ["short", "appropriate", "long"];
+var UNDERSTANDABLE = ["yes", "partial", "no"];
+var REUSE = ["yes", "no", "unknown"];
+var SEVERITIES = ["low", "medium", "high"];
+var STATUSES = ["noted", "needs_reproduction", "planned", "improving", "confirmed"];
+var requiredKeys = [
+  "date",
+  "projectAlias",
+  "taskType",
+  "profile",
+  "activeFeatures",
+  "perceivedLength",
+  "understandable",
+  "mostUsefulFeature",
+  "unnecessaryFeature",
+  "missingInfo",
+  "inaccurateContent",
+  "reuseConfig",
+  "improvementIdea",
+  "severity",
+  "status"
+];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function validateFeedback(input) {
+  if (!isRecord2(input)) return { ok: false, error: "\uD53C\uB4DC\uBC31\uC740 JSON \uAC1D\uCCB4\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+  if (Object.keys(input).some((key) => !requiredKeys.includes(key))) return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD53C\uB4DC\uBC31 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4." };
+  if (requiredKeys.some((key) => !(key in input))) return { ok: false, error: "\uD544\uC218 \uD53C\uB4DC\uBC31 \uD56D\uBAA9\uC774 \uBE60\uC84C\uC2B5\uB2C8\uB2E4." };
+  const strings = ["projectAlias", "mostUsefulFeature", "unnecessaryFeature", "missingInfo", "inaccurateContent", "improvementIdea"];
+  if (typeof input.date !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(input.date)) return { ok: false, error: "\uB0A0\uC9DC \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (strings.some((key) => typeof input[key] !== "string" || String(input[key]).length > 2e3)) return { ok: false, error: "\uD53C\uB4DC\uBC31 \uAE00\uC790 \uC218\uB098 \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!String(input.projectAlias).trim()) return { ok: false, error: "\uC775\uBA85 \uD504\uB85C\uC81D\uD2B8 \uBCC4\uCE6D\uC744 \uC785\uB825\uD558\uC138\uC694." };
+  if (!TASK_TYPES.includes(String(input.taskType))) return { ok: false, error: "\uC791\uC5C5 \uC885\uB958\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!Object.keys(PROFILES).includes(String(input.profile))) return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 Profile\uC785\uB2C8\uB2E4." };
+  if (!Array.isArray(input.activeFeatures) || input.activeFeatures.some((id) => typeof id !== "string" || !FEATURE_IDS.includes(id))) {
+    return { ok: false, error: "\uD65C\uC131 Feature \uBAA9\uB85D\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  }
+  if (!LENGTHES.includes(String(input.perceivedLength))) return { ok: false, error: "\uBCF4\uACE0\uC11C \uAE38\uC774 \uC120\uD0DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!UNDERSTANDABLE.includes(String(input.understandable))) return { ok: false, error: "\uC774\uD574\uD558\uAE30 \uC26C\uC6E0\uB294\uC9C0 \uC120\uD0DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!REUSE.includes(String(input.reuseConfig))) return { ok: false, error: "\uC7AC\uC0AC\uC6A9 \uC758\uD5A5 \uC120\uD0DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!SEVERITIES.includes(String(input.severity))) return { ok: false, error: "\uC2EC\uAC01\uB3C4 \uC120\uD0DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  if (!STATUSES.includes(String(input.status))) return { ok: false, error: "\uC870\uCE58 \uC0C1\uD0DC \uC120\uD0DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+  return { ok: true, value: input };
+}
+
+// ../../apps/local-admin/server/mcp/config.ts
+import { promises as fs2 } from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+import { spawnSync } from "node:child_process";
+var BEGIN_MARKER = "# JUTELL_MCP_BEGIN";
+var END_MARKER = "# JUTELL_MCP_END";
+var LEGACY_BEGIN_MARKER = "# BEGINNER_BRIDGE_MCP_BEGIN";
+var LEGACY_END_MARKER = "# BEGINNER_BRIDGE_MCP_END";
+function codexHome() {
+  const override = process.env.CODEX_HOME;
+  return path2.resolve(override && override.trim() ? override : path2.join(os.homedir(), ".codex"));
+}
+var OPENCODE_BEGIN_MARKER = "BEGIN JUTELL MANAGED BLOCK";
+var OPENCODE_END_MARKER = "END JUTELL MANAGED BLOCK";
+var OPENCODE_MCP_KEY = "jutell";
+var LEGACY_OPENCODE_MCP_KEY = "beginner_bridge";
+function providerDetected(id) {
+  if (id !== "codex" && id !== "opencode" && id !== "claude-code" && id !== "claude") return false;
+  const map = { codex: "codex.cmd", opencode: "opencode.cmd", "claude-code": "claude.cmd", claude: "claude.cmd" };
+  const executable = map[id] ?? `${id}.cmd`;
+  const result = spawnSync(process.platform === "win32" ? executable : executable.replace(".cmd", ""), ["--version"], { stdio: "ignore", windowsHide: true });
+  return result.status === 0;
+}
+function claudeHome() {
+  const override = process.env.CLAUDE_CONFIG_DIR;
+  return path2.resolve(override && override.trim() ? override : path2.join(os.homedir()));
+}
+function hasJuTellMcpEvidence(content, key) {
+  const keyPattern = new RegExp(`^\\s*\\[mcp_servers\\.${key}\\]\\s*$`, "m");
+  const m = content.match(keyPattern);
+  if (!m || m.index === void 0) return false;
+  return /(?:assets|apps)[\\/]mcp-server/i.test(content.slice(m.index, m.index + 1200));
+}
+function filePath(_projectRoot) {
+  return path2.join(codexHome(), "config.toml");
+}
+function configuredServerEntry() {
+  const configured = process.env.BEGINNER_BRIDGE_MCP_SERVER;
+  return configured && path2.isAbsolute(configured) ? configured : void 0;
+}
+function buildMcpConfigBlock(enabled) {
+  const serverEntry2 = configuredServerEntry();
+  return [
+    BEGIN_MARKER,
+    "[mcp_servers.jutell]",
+    'command = "node"',
+    `args = [${JSON.stringify(serverEntry2 ?? "apps/mcp-server/dist/index.js")}]`,
+    // No `cwd` here: this block is written to Codex's global config, shared
+    // across every project, so it must not be pinned to one project's dir.
+    `enabled = ${enabled ? "true" : "false"}`,
+    "required = false",
+    'default_tools_approval_mode = "prompt"',
+    END_MARKER
+  ].join("\n");
+}
+async function readConfigFile(projectRoot) {
+  try {
+    return await fs2.readFile(filePath(projectRoot), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function readCodexMcpRegistration(projectRoot, enabled = false) {
+  const text = await readConfigFile(projectRoot);
+  const canonicalBlock = text.match(new RegExp(`${BEGIN_MARKER}[\\s\\S]*?${END_MARKER}`, "m"))?.[0] ?? "";
+  const legacyBlock = text.match(new RegExp(`${LEGACY_BEGIN_MARKER}[\\s\\S]*?${LEGACY_END_MARKER}`, "m"))?.[0] ?? "";
+  const canonicalRegistered = /^\s*\[mcp_servers\.jutell\]\s*$/m.test(text);
+  const legacyRegistered = /^\s*\[mcp_servers\.beginner_bridge\]\s*$/m.test(text);
+  const canonicalHeuristic = !canonicalBlock && canonicalRegistered && hasJuTellMcpEvidence(text, "jutell");
+  const legacyHeuristic = !legacyBlock && legacyRegistered && hasJuTellMcpEvidence(text, "beginner_bridge");
+  const registered = Boolean(canonicalBlock || legacyBlock || canonicalHeuristic || legacyHeuristic);
+  const conflict = !registered && (canonicalRegistered || legacyRegistered);
+  const enabledFlag = (() => {
+    if (canonicalBlock) return /^\s*enabled\s*=\s*true\s*$/m.test(canonicalBlock);
+    if (canonicalHeuristic) {
+      const m = text.match(/^\s*\[mcp_servers\.jutell\]\s*$/m);
+      if (m && m.index !== void 0) return /^\s*enabled\s*=\s*true\s*$/m.test(text.slice(m.index, m.index + 1200));
+    }
+    if (legacyBlock) return /^\s*enabled\s*=\s*true\s*$/m.test(legacyBlock);
+    if (legacyHeuristic) {
+      const m = text.match(/^\s*\[mcp_servers\.beginner_bridge\]\s*$/m);
+      if (m && m.index !== void 0) return /^\s*enabled\s*=\s*true\s*$/m.test(text.slice(m.index, m.index + 1200));
+    }
+    return false;
+  })();
+  return { path: filePath(projectRoot), exists: Boolean(text), registered, conflict, enabled: enabledFlag, canonicalRegistered, legacyRegistered, bothRegistered: canonicalRegistered && legacyRegistered, preview: buildMcpConfigBlock(enabled) };
+}
+async function backup(file) {
+  try {
+    await fs2.copyFile(file, `${file}.previous`);
+  } catch {
+  }
+}
+function replaceManagedBlock(text, block) {
+  const pattern = new RegExp(`${BEGIN_MARKER}[\\s\\S]*?${END_MARKER}`, "m");
+  return text.replace(pattern, block).replace(/[ \t]*\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+async function registerCodexMcp(projectRoot, enabled) {
+  const file = filePath(projectRoot);
+  const current = await readConfigFile(projectRoot);
+  const existing = await readCodexMcpRegistration(projectRoot, enabled);
+  if (existing.conflict) throw new Error("Codex \uC124\uC815\uC5D0 \uAC19\uC740 \uC774\uB984\uC758 \uAD00\uB9AC\uB418\uC9C0 \uC54A\uB294 MCP \uD56D\uBAA9\uC774 \uC788\uC5B4 \uC790\uB3D9 \uBCC0\uACBD\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  if (existing.legacyRegistered && !existing.canonicalRegistered) return existing;
+  if (existing.bothRegistered) return existing;
+  await fs2.mkdir(path2.dirname(file), { recursive: true });
+  if (current) await backup(file);
+  const next = existing.registered ? replaceManagedBlock(current, buildMcpConfigBlock(enabled)) : `${current.trimEnd()}${current.trimEnd() ? "\n\n" : ""}${buildMcpConfigBlock(enabled)}
+`;
+  await fs2.writeFile(file, next, "utf8");
+  return readCodexMcpRegistration(projectRoot, enabled);
+}
+async function removeCodexMcp(projectRoot) {
+  const file = filePath(projectRoot);
+  const current = await readConfigFile(projectRoot);
+  const existing = await readCodexMcpRegistration(projectRoot);
+  if (existing.conflict) throw new Error("\uAD00\uB9AC\uB418\uC9C0 \uC54A\uB294 \uAC19\uC740 \uC774\uB984\uC758 MCP \uD56D\uBAA9\uC740 \uC790\uB3D9\uC73C\uB85C \uC81C\uAC70\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  if (!existing.registered) return existing;
+  await backup(file);
+  const patterns = [
+    new RegExp(`\\n?${BEGIN_MARKER}[\\s\\S]*?${END_MARKER}\\n?`, "m"),
+    new RegExp(`\\n?${LEGACY_BEGIN_MARKER}[\\s\\S]*?${LEGACY_END_MARKER}\\n?`, "m")
+  ];
+  const next = patterns.reduce((value, pattern) => value.replace(pattern, ""), current).replace(/\n{3,}/g, "\n\n").trim();
+  await fs2.writeFile(file, next ? `${next}
+` : "", "utf8");
+  return readCodexMcpRegistration(projectRoot);
+}
+function openCodeFilePath(projectRoot) {
+  const jsonc = path2.join(projectRoot, "opencode.jsonc");
+  const json2 = path2.join(projectRoot, "opencode.json");
+  return jsonc;
+}
+async function readOpenCodeFile(projectRoot) {
+  for (const name of ["opencode.jsonc", "opencode.json"]) {
+    const file = path2.join(projectRoot, name);
+    try {
+      return { file, text: await fs2.readFile(file, "utf8") };
+    } catch {
+    }
+  }
+  return { file: openCodeFilePath(projectRoot), text: "" };
+}
+function stripJsoncComments(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (inBlock) {
+      if (c === "*" && next === "/") {
+        inBlock = false;
+        out += "  ";
+        i += 1;
+      } else out += c === "\n" ? "\n" : " ";
+      continue;
+    }
+    if (inLine) {
+      if (c === "\n") {
+        inLine = false;
+        out += "\n";
+      } else out += " ";
+      continue;
+    }
+    if (inString) {
+      out += c;
+      if (escaped) escaped = false;
+      else if (c === "\\") escaped = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inLine = true;
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlock = true;
+      out += "  ";
+      i += 1;
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function tryParseJson(text) {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return {};
+  try {
+    const cleaned = stripJsoncComments(trimmed).replace(/,\s*([}\]])/g, "$1");
+    const value = JSON.parse(cleaned);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildOpenCodeBlock(enabled) {
+  const serverEntry2 = configuredServerEntry() ?? "apps/mcp-server/dist/index.js";
+  return JSON.stringify({ type: "local", command: [process.execPath, serverEntry2], enabled, cwd: "." }, null, 2);
+}
+function indentLines(value, prefix) {
+  return value.replace(/\n/g, `
+${prefix}`);
+}
+function serializeWithManaged(config, enabled) {
+  const copy = { ...config };
+  const rawMcp = copy.mcp && typeof copy.mcp === "object" && !Array.isArray(copy.mcp) ? copy.mcp : {};
+  const others = Object.entries(rawMcp).filter(([key]) => key !== OPENCODE_MCP_KEY);
+  const lines = ["{"];
+  for (const [key, value] of Object.entries(copy)) {
+    if (key === "mcp") continue;
+    lines.push(`  ${JSON.stringify(key)}: ${indentLines(JSON.stringify(value, null, 2), "  ")},`);
+  }
+  lines.push('  "mcp": {');
+  for (const [key, value] of others) {
+    lines.push(`    ${JSON.stringify(key)}: ${indentLines(JSON.stringify(value, null, 2), "    ")},`);
+  }
+  lines.push(`    // ${OPENCODE_BEGIN_MARKER}`);
+  lines.push(`    ${JSON.stringify(OPENCODE_MCP_KEY)}: ${indentLines(buildOpenCodeBlock(enabled), "    ")},`);
+  lines.push(`    // ${OPENCODE_END_MARKER}`);
+  lines.push("  }");
+  lines.push("}");
+  return lines.join("\n");
+}
+async function readOpenCodeRegistration(projectRoot, enabled = false) {
+  const { file, text } = await readOpenCodeFile(projectRoot);
+  const parsed = tryParseJson(text);
+  const rawMcp = parsed?.mcp && typeof parsed.mcp === "object" && !Array.isArray(parsed.mcp) ? parsed.mcp : {};
+  const canonicalEntry = rawMcp[OPENCODE_MCP_KEY];
+  const legacyEntry = rawMcp[LEGACY_OPENCODE_MCP_KEY];
+  const begin = text.indexOf(`// ${OPENCODE_BEGIN_MARKER}`);
+  const end = text.indexOf(`// ${OPENCODE_END_MARKER}`);
+  const managedText = begin >= 0 && end > begin ? text.slice(begin, end) : "";
+  const canonicalManaged = managedText.includes(JSON.stringify(OPENCODE_MCP_KEY));
+  const legacyManaged = managedText.includes(JSON.stringify(LEGACY_OPENCODE_MCP_KEY));
+  const canonicalRegistered = canonicalEntry !== void 0;
+  const legacyRegistered = legacyEntry !== void 0;
+  function isJuTellEntry(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+    const cmd = entry.command;
+    if (!Array.isArray(cmd)) return false;
+    return cmd.some((c) => typeof c === "string" && /(?:assets|apps)[\\/]mcp-server/i.test(c));
+  }
+  const canonicalHeuristic = !canonicalManaged && canonicalRegistered && isJuTellEntry(canonicalEntry);
+  const legacyHeuristic = !legacyManaged && legacyRegistered && isJuTellEntry(legacyEntry);
+  const registered = canonicalManaged || legacyManaged || canonicalHeuristic || legacyHeuristic;
+  const conflict = !registered && (canonicalRegistered || legacyRegistered);
+  const enabledFlag = (() => {
+    if (canonicalManaged && canonicalEntry && typeof canonicalEntry === "object") return canonicalEntry.enabled === true;
+    if (canonicalHeuristic && canonicalEntry && typeof canonicalEntry === "object") return canonicalEntry.enabled === true;
+    if (legacyManaged && legacyEntry && typeof legacyEntry === "object") return legacyEntry.enabled === true;
+    if (legacyHeuristic && legacyEntry && typeof legacyEntry === "object") return legacyEntry.enabled === true;
+    return false;
+  })();
+  return { file, exists: text.trim().length > 0, registered, conflict, enabled: enabledFlag, canonicalRegistered, legacyRegistered, bothRegistered: canonicalRegistered && legacyRegistered, preview: serializeWithManaged(parsed ?? {}, enabled) };
+}
+async function writeOpenCodeFile(file, text) {
+  await fs2.mkdir(path2.dirname(file), { recursive: true });
+  await fs2.writeFile(file, text, "utf8");
+}
+async function registerOpenCodeMcp(projectRoot, enabled) {
+  const current = await readOpenCodeRegistration(projectRoot, enabled);
+  if (current.conflict) throw new Error("OpenCode \uC124\uC815\uC5D0 \uAC19\uC740 \uC774\uB984\uC758 \uAD00\uB9AC\uB418\uC9C0 \uC54A\uB294 MCP \uD56D\uBAA9\uC774 \uC788\uC5B4 \uC790\uB3D9 \uBCC0\uACBD\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  if (current.legacyRegistered && !current.canonicalRegistered) return current;
+  if (current.bothRegistered) return current;
+  const { file, text } = await readOpenCodeFile(projectRoot);
+  const parsed = tryParseJson(text);
+  if (text.trim() && !parsed) throw new Error("OpenCode \uC124\uC815 \uD30C\uC77C\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC790\uB3D9 \uBCC0\uACBD\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  await backup(file);
+  await writeOpenCodeFile(file, `${serializeWithManaged(parsed ?? { $schema: "https://opencode.ai/config.json" }, enabled)}
+`);
+  return readOpenCodeRegistration(projectRoot, enabled);
+}
+async function setOpenCodeMcpEnabled(projectRoot, enabled) {
+  const current = await readOpenCodeRegistration(projectRoot, enabled);
+  if (current.conflict || !current.registered) return current;
+  if (current.legacyRegistered && !current.canonicalRegistered) return current;
+  if (current.bothRegistered) return current;
+  const { text } = await readOpenCodeFile(projectRoot);
+  const parsed = tryParseJson(text);
+  if (!parsed) throw new Error("OpenCode \uC124\uC815 \uD30C\uC77C\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC790\uB3D9 \uBCC0\uACBD\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  await backup(current.file);
+  await writeOpenCodeFile(current.file, `${serializeWithManaged(parsed, enabled)}
+`);
+  return readOpenCodeRegistration(projectRoot, enabled);
+}
+function claudeConfigFile() {
+  return path2.join(claudeHome(), ".claude.json");
+}
+async function readClaudeMcpRegistration(projectRoot, _enabled = false) {
+  const file = claudeConfigFile();
+  let text = "";
+  try {
+    text = await fs2.readFile(file, "utf8");
+  } catch {
+    text = "";
+  }
+  let parsed;
+  try {
+    parsed = text.trim() ? JSON.parse(text) : {};
+  } catch {
+    parsed = void 0;
+  }
+  if (!parsed) return { file, claudeScope: "local", exists: Boolean(text), registered: false, conflict: false, enabled: false, canonicalRegistered: false, legacyRegistered: false, bothRegistered: false, preview: JSON.stringify({ scope: "local", type: "stdio", command: "node", args: ["assets/mcp-server/index.js"] }, null, 2) };
+  const projects = parsed.projects;
+  const normalizedRoot = projectRoot.replace(/\\/g, "/");
+  let mcp;
+  for (const [k, v] of Object.entries(projects ?? {})) {
+    if (k.replace(/\\/g, "/").toLowerCase() === normalizedRoot.toLowerCase()) {
+      const entry2 = v;
+      const servers = entry2.mcpServers;
+      mcp = servers;
+      break;
+    }
+  }
+  const topMcp = parsed.mcpServers;
+  const entry = mcp?.jutell ?? topMcp?.jutell;
+  const registered = entry !== void 0;
+  return { file, claudeScope: "local", exists: Boolean(text), registered, conflict: false, enabled: registered, canonicalRegistered: registered, legacyRegistered: false, bothRegistered: false, preview: JSON.stringify({ scope: "local", type: "stdio", command: "node", args: ["assets/mcp-server/index.js"] }, null, 2) };
+}
+
+// ../../apps/local-admin/server/mcp/runtime.ts
+import { spawn } from "node:child_process";
+import { promises as fs3 } from "node:fs";
+import path3 from "node:path";
+var child;
+var state = { state: "stopped" };
+function serverEntry(projectRoot) {
+  const configured = process.env.BEGINNER_BRIDGE_MCP_SERVER;
+  return configured && path3.isAbsolute(configured) ? configured : path3.join(projectRoot, "apps", "mcp-server", "dist", "index.js");
+}
+function getMcpRuntimeState() {
+  return { ...state };
+}
+async function startMcpRuntime(projectRoot) {
+  if (child && state.state === "running") return getMcpRuntimeState();
+  try {
+    await fs3.access(serverEntry(projectRoot));
+  } catch {
+    throw new Error("MCP \uC11C\uBC84 \uBE4C\uB4DC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 apps/mcp-server\uC5D0\uC11C npm run build\uB97C \uC2E4\uD589\uD558\uC138\uC694.");
+  }
+  state = { state: "starting" };
+  const processHandle = spawn(process.execPath, [serverEntry(projectRoot)], {
+    cwd: projectRoot,
+    stdio: ["pipe", "ignore", "ignore"],
+    windowsHide: true
+  });
+  child = processHandle;
+  processHandle.once("spawn", () => {
+    state = { state: "running" };
+  });
+  processHandle.once("error", () => {
+    child = void 0;
+    state = { state: "error", error: "MCP \uC11C\uBC84\uB97C \uC2DC\uC791\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4." };
+  });
+  processHandle.once("exit", (code) => {
+    child = void 0;
+    if (state.state !== "error") state = code === 0 ? { state: "stopped" } : { state: "error", error: "MCP \uC11C\uBC84\uAC00 \uC608\uAE30\uCE58 \uC54A\uAC8C \uC885\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4." };
+  });
+  await new Promise((resolve) => setTimeout(resolve, 25));
+  return getMcpRuntimeState();
+}
+async function stopMcpRuntime() {
+  if (!child) {
+    state = { state: "stopped" };
+    return getMcpRuntimeState();
+  }
+  child.stdin?.end();
+  child.kill();
+  child = void 0;
+  state = { state: "stopped" };
+  return getMcpRuntimeState();
+}
+
+// ../../apps/local-admin/server/templates/request-templates.ts
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
+var REQUEST_TEMPLATE_DIR = "templates/request-builder";
+var REQUEST_TEMPLATE_LIST = [
+  { name: "README.md", description: "\uC0AC\uC6A9\uBC95\uACFC \uACF5\uD1B5 \uC120\uD0DD\uC9C0 \uC124\uBA85" },
+  { name: "DESIGN_REQUEST.md", description: "\uD654\uBA74 \uBAA8\uC591\uC774\uB098 \uBD84\uC704\uAE30 \uBCC0\uACBD" },
+  { name: "FEATURE_REQUEST.md", description: "\uC0C8 \uAE30\uB2A5\xB7\uD654\uBA74 \uCD94\uAC00" },
+  { name: "BUG_REPORT_REQUEST.md", description: "\uBB38\uC81C(\uBC84\uADF8) \uC2E0\uACE0" },
+  { name: "PROJECT_PLANNING_REQUEST.md", description: "\uD504\uB85C\uC81D\uD2B8 \uACC4\uD68D" },
+  { name: "CODE_REVIEW_REQUEST.md", description: "\uC791\uC5C5 \uAC80\uD1A0" },
+  { name: "NEXT_AGENT_HANDOFF.md", description: "\uB2E4\uC74C Agent\uC5D0\uAC8C \uC791\uC5C5 \uC804\uB2EC" },
+  { name: "MANUAL_EDIT_GUIDE.md", description: "\uC0AC\uC6A9\uC790 \uC9C1\uC811 \uC218\uC815 \uC548\uB0B4" }
+];
+async function exists(file) {
+  try {
+    await fs4.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findRequestTemplatesRoot(projectRoot) {
+  const candidates = [
+    { root: path4.join(projectRoot, REQUEST_TEMPLATE_DIR), source: "project" },
+    ...process.env.JUTELL_TEMPLATES_ROOT ? [{ root: process.env.JUTELL_TEMPLATES_ROOT, source: "assets" }] : []
+  ];
+  for (const candidate of candidates) {
+    if (await exists(path4.join(candidate.root, "README.md"))) return candidate;
+  }
+  return null;
+}
+async function readRequestTemplates(projectRoot) {
+  const found = await findRequestTemplatesRoot(projectRoot);
+  if (!found) return { templates: [], source: "unavailable" };
+  const templates = [];
+  for (const item of REQUEST_TEMPLATE_LIST) {
+    try {
+      templates.push({ ...item, content: await fs4.readFile(path4.join(found.root, item.name), "utf8") });
+    } catch {
+    }
+  }
+  return { templates, source: found.source };
+}
+
+// ../../apps/local-admin/server/usage/counters.ts
+import { promises as fs5 } from "node:fs";
+async function readUsageCounters(paths) {
+  try {
+    const value = await readJson(paths.usageCountersFile);
+    if (!value || typeof value !== "object" || Array.isArray(value)) return { exists: true, corrupt: true, counters: null };
+    const record = value;
+    if (record.schemaVersion !== 1 || typeof record.enabled !== "boolean" || typeof record.totalToolCalls !== "number" || typeof record.tools !== "object" || record.tools === null || Array.isArray(record.tools)) {
+      return { exists: true, corrupt: true, counters: null };
+    }
+    return { exists: true, corrupt: false, counters: value };
+  } catch {
+    return { exists: false, corrupt: false, counters: null };
+  }
+}
+async function deleteUsageCounters(paths) {
+  await fs5.rm(paths.usageCountersFile, { force: true });
+}
+async function writeCounters(paths, value) {
+  await writeJsonAtomically(paths.usageCountersFile, value);
+}
+async function recordTemplateCopy(paths, template, taskType, profile) {
+  const current = await readUsageCounters(paths);
+  if (current.corrupt) return { ok: false, reason: "\uCE74\uC6B4\uD130 \uD30C\uC77C \uD615\uC2DD\uC744 \uD655\uC778\uD560 \uC218 \uC5C6\uC5B4 \uBCF4\uC874\uD558\uACE0 \uAE30\uB85D\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4." };
+  const base = current.counters ?? { schemaVersion: 1, enabled: true, updatedAt: null, totalToolCalls: 0, tools: {}, templateCopies: {} };
+  const copies = base.templateCopies ?? (base.templateCopies = {});
+  const item = copies[template] ?? { count: 0, byTaskType: {}, byProfile: {}, lastCopiedAt: null };
+  item.count += 1;
+  item.byTaskType[taskType] = (item.byTaskType[taskType] ?? 0) + 1;
+  item.byProfile[profile] = (item.byProfile[profile] ?? 0) + 1;
+  item.lastCopiedAt = (/* @__PURE__ */ new Date()).toISOString();
+  copies[template] = item;
+  base.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeCounters(paths, base);
+  return { ok: true };
+}
+
+// ../../apps/local-admin/server/usage/experiments.ts
+init_schema();
+import { promises as fs6 } from "node:fs";
+function emptyFile() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { schemaVersion: 1, createdAt: now, updatedAt: now, experiments: [] };
+}
+async function readFile(paths) {
+  try {
+    const value = await readJson(paths.usageExperimentsFile);
+    if (!value || typeof value !== "object" || Array.isArray(value)) return emptyFile();
+    const record = value;
+    if (record.schemaVersion !== 1 || !Array.isArray(record.experiments)) return emptyFile();
+    return value;
+  } catch {
+    return emptyFile();
+  }
+}
+async function writeFile(paths, file) {
+  await writeJsonAtomically(paths.usageExperimentsFile, file);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateField(key, value) {
+  if (key === "title") {
+    if (typeof value !== "string" || value.trim().length === 0 || value.length > 100) return { ok: false, error: "\uC2E4\uD5D8 \uC774\uB984\uC740 1~100\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "status") {
+    if (value !== "in_progress" && value !== "completed") return { ok: false, error: "status\uB294 in_progress \uB610\uB294 completed\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "profile") {
+    if (value !== "minimal" && value !== "balanced" && value !== "learning" && value !== "detailed") return { ok: false, error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 Profile\uC785\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "features") {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !FEATURE_IDS.includes(item))) return { ok: false, error: "\uD65C\uC131 Feature \uBAA9\uB85D\uC5D0 \uACF5\uC2DD Feature ID\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." };
+    if (new Set(value).size !== value.length) return { ok: false, error: "\uD65C\uC131 Feature \uBAA9\uB85D\uC5D0 \uC911\uBCF5\uC774 \uC788\uC2B5\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "environment") {
+    if (!isRecord3(value) || value.provider !== "codex" && value.provider !== "opencode" && value.provider !== "other" || typeof value.mcpEnabled !== "boolean" || typeof value.skillEnabled !== "boolean") {
+      return { ok: false, error: "\uD658\uACBD \uC815\uBCF4\uB294 provider(\uCF54\uB4DC\uB2C9\uC2A4/OpenCode/\uAE30\uD0C0)\uC640 MCP\xB7Skill \uC0AC\uC6A9 \uC5EC\uBD80\uB9CC \uC800\uC7A5\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." };
+    }
+    return { ok: true };
+  }
+  if (key === "measurement") {
+    if (!isRecord3(value)) return { ok: false, error: "\uCE21\uC815 \uC815\uBCF4 \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+    for (const field of ["toolCalls", "responseCharacters", "estimatedTokens", "durationMs"]) {
+      const number = value[field];
+      if (typeof number !== "number" || !Number.isInteger(number) || number < 0) return { ok: false, error: `${field}\uB294 0 \uC774\uC0C1\uC758 \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4.` };
+    }
+    return { ok: true };
+  }
+  if (key === "evaluation") {
+    if (!isRecord3(value)) return { ok: false, error: "\uD3C9\uAC00 \uC815\uBCF4 \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." };
+    for (const field of ["understanding", "readability", "accuracy", "overall"]) {
+      const number = value[field];
+      if (typeof number !== "number" || !Number.isInteger(number) || number < 1 || number > 5) return { ok: false, error: `${field}\uB294 1~5 \uC0AC\uC774\uC758 \uC815\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4.` };
+    }
+    return { ok: true };
+  }
+  if (key === "issues") {
+    if (!Array.isArray(value) || value.length > 20 || value.some((item) => typeof item !== "string" || item.length === 0 || item.length > 200)) return { ok: false, error: "\uBB38\uC81C \uBAA9\uB85D\uC740 20\uAC1C \uC774\uD558, \uAC01 1~200\uC790\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "decision") {
+    if (typeof value !== "string" || value.length > 500) return { ok: false, error: "\uCD5C\uC885 \uACB0\uC815\uC740 500\uC790 \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  if (key === "notes") {
+    if (typeof value !== "string" || value.length > 500) return { ok: false, error: "\uC6B4\uC601\uC790 \uBA54\uBAA8\uB294 500\uC790 \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4." };
+    return { ok: true };
+  }
+  return { ok: false, error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC2E4\uD5D8 \uD56D\uBAA9\uC785\uB2C8\uB2E4: ${key}` };
+}
+function validatePartial(input) {
+  for (const [key, value] of Object.entries(input)) {
+    const result = validateField(key, value);
+    if (!result.ok) return result;
+  }
+  return { ok: true, value: input };
+}
+async function readUsageExperiments(paths) {
+  const file = await readFile(paths);
+  return { summary: summarize(file), experiments: file.experiments };
+}
+async function createUsageExperiment(paths, input) {
+  const validated = validatePartial(input);
+  if (!validated.ok) return validated;
+  const file = await readFile(paths);
+  const maxId = file.experiments.reduce((max, item) => {
+    const number = Number(item.id.replace(/^EXP-/, ""));
+    return Number.isInteger(number) && number > max ? number : max;
+  }, 0);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const experiment = {
+    id: `EXP-${String(maxId + 1).padStart(3, "0")}`,
+    title: typeof validated.value.title === "string" ? validated.value.title : "\uC81C\uBAA9 \uC5C6\uB294 \uC2E4\uD5D8",
+    status: validated.value.status ?? "in_progress",
+    profile: validated.value.profile ?? "balanced",
+    features: validated.value.features ?? [],
+    environment: validated.value.environment ?? { provider: "codex", mcpEnabled: false, skillEnabled: true },
+    issues: validated.value.issues ?? [],
+    decision: validated.value.decision ?? "",
+    notes: validated.value.notes ?? "",
+    createdAt: now,
+    updatedAt: now,
+    ...validated.value.measurement ? { measurement: validated.value.measurement } : {},
+    ...validated.value.evaluation ? { evaluation: validated.value.evaluation } : {}
+  };
+  file.experiments.push(experiment);
+  file.updatedAt = now;
+  await writeFile(paths, file);
+  return { ok: true, experiment };
+}
+async function updateUsageExperiment(paths, id, input) {
+  const validated = validatePartial(input);
+  if (!validated.ok) return validated;
+  const file = await readFile(paths);
+  const index = file.experiments.findIndex((item) => item.id === id);
+  if (index < 0) return { ok: false, error: "\uC2E4\uD5D8 \uAE30\uB85D\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." };
+  const current = file.experiments[index];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const next = {
+    ...current,
+    title: validated.value.title !== void 0 ? validated.value.title : current.title,
+    status: validated.value.status !== void 0 ? validated.value.status : current.status,
+    profile: validated.value.profile !== void 0 ? validated.value.profile : current.profile,
+    features: validated.value.features !== void 0 ? validated.value.features : current.features,
+    environment: validated.value.environment !== void 0 ? validated.value.environment : current.environment,
+    issues: validated.value.issues !== void 0 ? validated.value.issues : current.issues,
+    decision: validated.value.decision !== void 0 ? validated.value.decision : current.decision,
+    notes: validated.value.notes !== void 0 ? validated.value.notes : current.notes,
+    ...validated.value.measurement !== void 0 ? { measurement: validated.value.measurement } : current.measurement ? { measurement: current.measurement } : {},
+    ...validated.value.evaluation !== void 0 ? { evaluation: validated.value.evaluation } : current.evaluation ? { evaluation: current.evaluation } : {},
+    updatedAt: now
+  };
+  file.experiments[index] = next;
+  file.updatedAt = now;
+  await writeFile(paths, file);
+  return { ok: true, experiment: next };
+}
+async function deleteAllUsageExperiments(paths) {
+  await fs6.rm(paths.usageExperimentsFile, { force: true });
+}
+function average(values) {
+  if (values.length === 0) return null;
+  return Math.round(values.reduce((sum, value) => sum + value, 0) / values.length * 10) / 10;
+}
+function summarize(file) {
+  const experiments = file.experiments;
+  const evaluated = experiments.filter((item) => item.evaluation);
+  const measured = experiments.filter((item) => item.measurement);
+  const profileCounts = /* @__PURE__ */ new Map();
+  const disabledCounts = /* @__PURE__ */ new Map();
+  const issueCounts = /* @__PURE__ */ new Map();
+  for (const item of experiments) {
+    profileCounts.set(item.profile, (profileCounts.get(item.profile) ?? 0) + 1);
+    for (const id of FEATURE_IDS) {
+      if (!item.features.includes(id)) disabledCounts.set(id, (disabledCounts.get(id) ?? 0) + 1);
+    }
+    for (const issue of item.issues) issueCounts.set(issue, (issueCounts.get(issue) ?? 0) + 1);
+  }
+  const mostUsedProfile = profileCounts.size === 0 ? null : [...profileCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+  const mostDisabledFeatures = [...disabledCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([id]) => id);
+  const topIssues = [...issueCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([text, count]) => ({ text, count }));
+  return {
+    total: experiments.length,
+    completed: experiments.filter((item) => item.status === "completed").length,
+    inProgress: experiments.filter((item) => item.status === "in_progress").length,
+    averageUnderstanding: average(evaluated.map((item) => item.evaluation.understanding)),
+    averageReadability: average(evaluated.map((item) => item.evaluation.readability)),
+    averageAccuracy: average(evaluated.map((item) => item.evaluation.accuracy)),
+    averageResponseCharacters: average(measured.map((item) => item.measurement.responseCharacters)),
+    averageToolCalls: average(measured.map((item) => item.measurement.toolCalls)),
+    mostUsedProfile,
+    mostDisabledFeatures,
+    topIssues
+  };
+}
+
+// ../../apps/local-admin/server/app.ts
+var MAX_BODY_BYTES = 512 * 1024;
+var writeQueue = Promise.resolve();
+var lastMcpCheckAt = null;
+function withWriteLock(task) {
+  const run = writeQueue.then(task, task);
+  writeQueue = run.then(() => void 0, () => void 0);
+  return run;
+}
+function json(res, status, body2) {
+  const payload = JSON.stringify(body2);
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.setHeader("Cache-Control", "no-store");
+  res.end(payload);
+}
+function error(res, status, message) {
+  json(res, status, { error: message });
+}
+async function body(req) {
+  let size = 0;
+  const chunks = [];
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > MAX_BODY_BYTES) throw new Error("\uC694\uCCAD\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4.");
+    chunks.push(buffer);
+  }
+  if (size === 0) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new Error("JSON \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  }
+}
+async function getHistory(paths) {
+  return readArray(paths.historyFile);
+}
+async function getFeedback(paths) {
+  return readArray(paths.feedbackFile);
+}
+function safeId(value) {
+  return Boolean(value && /^[0-9a-f-]{36}$/i.test(value));
+}
+async function updateHistory(paths, entry) {
+  const history = await getHistory(paths);
+  const next = history.map((item) => item.id === entry.id ? entry : item);
+  await writeJsonAtomically(paths.historyFile, next.slice(-100));
+}
+async function saveConfig(paths, next) {
+  return withWriteLock(async () => {
+    const current = (await readConfig(paths)).config;
+    const changes = changedFields(current, next);
+    if (changes.length === 0) return { config: next, changed: false, historyRecorded: true };
+    const entry = { id: randomUUID2(), changedAt: (/* @__PURE__ */ new Date()).toISOString(), changedFields: changes, status: "pending" };
+    const history = await getHistory(paths);
+    await writeJsonAtomically(paths.historyFile, [...history, entry].slice(-100));
+    try {
+      await writeJsonAtomically(paths.configFile, next);
+    } catch {
+      await updateHistory(paths, { ...entry, status: "failed" });
+      throw new Error("\uC124\uC815\uC744 \uC800\uC7A5\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uAE30\uC874 \uC124\uC815\uC744 \uC720\uC9C0\uD588\uC2B5\uB2C8\uB2E4.");
+    }
+    await updateHistory(paths, { ...entry, status: "applied" });
+    return { config: next, changed: true, historyRecorded: true };
+  });
+}
+async function readOverview(paths) {
+  const result = await readConfig(paths);
+  const history = await getHistory(paths);
+  let metadata = {};
+  try {
+    metadata = await readJson(paths.metadataFile);
+  } catch {
+  }
+  return {
+    ...result,
+    metadata,
+    lastChangedAt: history.at(-1)?.changedAt ?? null
+  };
+}
+async function exists2(file) {
+  try {
+    await fs7.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readReadiness(projectRoot, paths) {
+  const configExists = await exists2(paths.configFile) || await exists2(paths.legacyConfigFile);
+  const agentsPath = path5.join(projectRoot, "AGENTS.md");
+  const skillPath = path5.join(projectRoot, ".agents", "skills", "beginner-bridge", "SKILL.md");
+  const [agentsExists, skillExists] = await Promise.all([exists2(agentsPath), exists2(skillPath)]);
+  const agentsText = agentsExists ? await fs7.readFile(agentsPath, "utf8") : "";
+  let safetyExists = false;
+  if (skillExists) {
+    try {
+      const skill = await fs7.readFile(skillPath, "utf8");
+      safetyExists = skill.includes("\uBE44\uBC00\uC815\uBCF4") && skill.includes("\uC911\uC694\uD55C \uBBF8\uD655\uC778 \uC0AC\uD56D");
+    } catch {
+      safetyExists = false;
+    }
+  }
+  const config = await readConfig(paths);
+  return {
+    config: { exists: configExists, valid: configExists && !config.fallback, profile: config.config.profile, activeFeatures: Object.values(config.config.features).filter(Boolean).length },
+    skill: { exists: skillExists },
+    agents: { exists: agentsExists, jutellBlock: agentsText.includes("<!-- BEGIN JUTELL MANAGED BLOCK -->") && agentsText.includes("<!-- END JUTELL MANAGED BLOCK -->") },
+    safetyRules: { exists: safetyExists },
+    sessionApplied: "manual_check_required"
+  };
+}
+async function readProviderStatuses(projectRoot, config) {
+  const [codex, opencode, claude] = await Promise.all([
+    readCodexMcpRegistration(projectRoot, config.mcp.enabled),
+    readOpenCodeRegistration(projectRoot, config.mcp.enabled),
+    readClaudeMcpRegistration(projectRoot, config.mcp.enabled)
+  ]);
+  const base = { lastCheckedAt: lastMcpCheckAt };
+  return [
+    { id: "codex", label: "Codex", status: "supported", detected: providerDetected("codex"), registered: codex.registered, conflict: codex.conflict, enabled: codex.enabled, ...base },
+    { id: "opencode", label: "OpenCode", status: "beta", detected: providerDetected("opencode"), registered: opencode.registered, conflict: opencode.conflict, enabled: opencode.enabled, ...base },
+    { id: "claude-code", label: "Claude Code", status: "beta", detected: providerDetected("claude-code"), registered: claude.registered, conflict: claude.conflict, enabled: claude.enabled, ...base },
+    { id: "cline", label: "Cline", status: "planned", detected: false, registered: false, conflict: false, enabled: false, ...base }
+  ];
+}
+async function readMcpStatus(projectRoot, paths) {
+  const config = (await readConfig(paths)).config;
+  const codex = await readCodexMcpRegistration(projectRoot, config.mcp.enabled);
+  const preparation = codex.conflict ? "error" : !codex.registered ? "not_registered" : config.mcp.enabled ? "enabled" : "registered";
+  return {
+    settings: config.mcp,
+    server: getMcpRuntimeState(),
+    codex: { registered: codex.registered, path: codex.path, conflict: codex.conflict, enabled: codex.enabled },
+    providers: await readProviderStatuses(projectRoot, config),
+    preparation,
+    connection: { state: "not_checked", lastCheckedAt: lastMcpCheckAt },
+    skillFallback: { available: true, message: "MCP\uB97C \uB044\uAC70\uB098 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC5B4\uB3C4 AGENTS.md, Skill, \uC124\uC815 \uD30C\uC77C \uBC29\uC2DD\uC740 \uACC4\uC18D \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." }
+  };
+}
+async function providerRequest(input) {
+  const value = input && typeof input === "object" ? input : {};
+  const provider = value.provider;
+  if (provider !== "codex" && provider !== "opencode" && provider !== "claude-code" && provider !== "claude") return { error: "\uC5F0\uACB0\uD560 Agent\uB97C codex, opencode \uB610\uB294 claude \uC911\uC5D0\uC11C \uC120\uD0DD\uD558\uC138\uC694." };
+  if (value.confirm !== true) return { error: "Provider \uC5F0\uACB0 \uBCC0\uACBD \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4." };
+  const normalized = provider === "claude" ? "claude-code" : provider;
+  return { provider: normalized };
+}
+async function applyProviderAction(projectRoot, provider, action, config) {
+  const opencode = await readOpenCodeRegistration(projectRoot, config.mcp.enabled);
+  const codex = await readCodexMcpRegistration(projectRoot, config.mcp.enabled);
+  if (action === "disconnect") {
+    if (provider === "codex") await registerCodexMcp(projectRoot, false);
+    else if (provider === "opencode") await setOpenCodeMcpEnabled(projectRoot, false);
+    else return config;
+    return config;
+  }
+  if (action === "default" && provider !== "codex" && codex.registered && codex.enabled) await registerCodexMcp(projectRoot, false);
+  if (action === "default" && provider !== "opencode" && opencode.registered && opencode.enabled) await setOpenCodeMcpEnabled(projectRoot, false);
+  if (provider === "codex") await registerCodexMcp(projectRoot, true);
+  else if (provider === "opencode") await registerOpenCodeMcp(projectRoot, true);
+  else return config;
+  if (action === "connect" || action === "default") return { ...config, mcp: { ...config.mcp, enabled: true } };
+  return config;
+}
+function confirmBody(input, message) {
+  return Boolean(input && typeof input === "object" && input.confirm === true) ? null : message;
+}
+async function handleApiRequest(req, res, projectRoot) {
+  const paths = getStoragePaths(projectRoot);
+  try {
+    await ensureStorage(paths);
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const method = req.method ?? "GET";
+    if (!url.pathname.startsWith("/api/")) return error(res, 404, "\uC694\uCCAD\uD55C \uC8FC\uC18C\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    if (method === "GET" && url.pathname === "/api/config") return json(res, 200, await readOverview(paths));
+    if (method === "GET" && url.pathname === "/api/request-templates") return json(res, 200, await readRequestTemplates(projectRoot));
+    if (method === "GET" && url.pathname === "/api/usage-counters") return json(res, 200, await readUsageCounters(paths));
+    if (method === "DELETE" && url.pathname === "/api/usage-counters") {
+      const errorMessage = confirmBody(await body(req), "\uB85C\uCEEC \uC0AC\uC6A9\uB7C9 \uCE74\uC6B4\uD130 \uC0AD\uC81C \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      if (errorMessage) return error(res, 400, errorMessage);
+      await deleteUsageCounters(paths);
+      return json(res, 200, { counters: null });
+    }
+    if (method === "PATCH" && url.pathname === "/api/usage-settings") {
+      const input = await body(req);
+      if (!input || typeof input !== "object" || typeof input.localCountersEnabled !== "boolean") {
+        return error(res, 400, "localCountersEnabled\uB294 ON \uB610\uB294 OFF\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+      }
+      const config = (await readConfig(paths)).config;
+      const saved = await saveConfig(paths, { ...config, usageMeasurement: { localCountersEnabled: input.localCountersEnabled } });
+      return json(res, 200, { ...saved, ...await readOverview(paths) });
+    }
+    if (method === "GET" && url.pathname === "/api/usage-experiments") return json(res, 200, await readUsageExperiments(paths));
+    if (method === "POST" && url.pathname === "/api/usage-experiments") {
+      const result = await createUsageExperiment(paths, await body(req));
+      if (!result.ok) return error(res, 400, result.error);
+      return json(res, 201, { experiment: result.experiment, ...await readUsageExperiments(paths) });
+    }
+    if (method === "POST" && url.pathname === "/api/usage-experiments/template-copy") {
+      const config = (await readConfig(paths)).config;
+      if (!config.usageMeasurement.localCountersEnabled) return error(res, 409, "\uB85C\uCEEC \uC0AC\uC6A9\uB7C9 \uCE21\uC815\uC774 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 \uCF1C\uC57C \uD15C\uD50C\uB9BF \uBCF5\uC0AC \uD69F\uC218\uB97C \uAE30\uB85D\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+      const input = await body(req);
+      const record = input && typeof input === "object" ? input : {};
+      const template = typeof record.template === "string" ? record.template : "";
+      const taskType = typeof record.taskType === "string" && record.taskType.length > 0 && record.taskType.length <= 40 ? record.taskType : "\uAE30\uD0C0";
+      if (!REQUEST_TEMPLATE_LIST.some((item) => item.name === template)) return error(res, 400, "\uACF5\uC2DD \uD15C\uD50C\uB9BF \uC774\uB984\uB9CC \uAE30\uB85D\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+      const result = await recordTemplateCopy(paths, template, taskType, config.profile);
+      if (!result.ok) return error(res, 409, result.reason);
+      return json(res, 200, { recorded: true, counters: (await readUsageCounters(paths)).counters });
+    }
+    const experimentMatch = url.pathname.match(/^\/api\/usage-experiments\/(EXP-\d{3})$/);
+    if (experimentMatch && method === "PATCH") {
+      const result = await updateUsageExperiment(paths, experimentMatch[1], await body(req));
+      if (!result.ok) return error(res, result.error === "\uC2E4\uD5D8 \uAE30\uB85D\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." ? 404 : 400, result.error);
+      return json(res, 200, { experiment: result.experiment, ...await readUsageExperiments(paths) });
+    }
+    if (method === "DELETE" && url.pathname === "/api/usage-experiments") {
+      const errorMessage = confirmBody(await body(req), "\uC2E4\uD5D8 \uAE30\uB85D \uC804\uCCB4 \uC0AD\uC81C \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      if (errorMessage) return error(res, 400, errorMessage);
+      await deleteAllUsageExperiments(paths);
+      return json(res, 200, { experiments: [], summary: null });
+    }
+    if (method === "GET" && url.pathname === "/api/readiness") return json(res, 200, await readReadiness(projectRoot, paths));
+    if (method === "GET" && url.pathname === "/api/mcp/status") return json(res, 200, await readMcpStatus(projectRoot, paths));
+    if (method === "POST" && url.pathname === "/api/mcp/preview") {
+      const config = (await readConfig(paths)).config;
+      const codex = await readCodexMcpRegistration(projectRoot, config.mcp.enabled);
+      return json(res, 200, { path: codex.path, preview: codex.preview, registered: codex.registered, conflict: codex.conflict, note: "Codex\uB294 MCP \uC11C\uBC84 \uBAA9\uB85D\uC744 \uC0AC\uC6A9\uC790 \uC804\uC5ED \uC124\uC815\uC5D0\uC11C\uB9CC \uC77D\uC2B5\uB2C8\uB2E4. \uC774 \uD504\uB85C\uC81D\uD2B8\uC758 \uC124\uC815\uC740 \uADF8\uB300\uB85C \uB450\uACE0, \uC804\uC5ED Codex \uC124\uC815\uC5D0 JuTell \uAD00\uB9AC \uBE14\uB85D\uB9CC \uCD94\uAC00\uD569\uB2C8\uB2E4." });
+    }
+    if (method === "POST" && url.pathname === "/api/mcp/register") {
+      const errorMessage = confirmBody(await body(req), "Codex \uC5F0\uACB0 \uC124\uC815 \uC0DD\uC131 \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      if (errorMessage) return error(res, 400, errorMessage);
+      const config = (await readConfig(paths)).config;
+      return json(res, 200, { registration: await registerCodexMcp(projectRoot, config.mcp.enabled) });
+    }
+    if (method === "POST" && url.pathname === "/api/mcp/remove") {
+      const errorMessage = confirmBody(await body(req), "Codex \uC5F0\uACB0 \uC124\uC815 \uC81C\uAC70 \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      if (errorMessage) return error(res, 400, errorMessage);
+      return json(res, 200, { registration: await removeCodexMcp(projectRoot) });
+    }
+    if (method === "POST" && (url.pathname === "/api/mcp/connect" || url.pathname === "/api/mcp/disconnect" || url.pathname === "/api/mcp/set-default")) {
+      const requested = await providerRequest(await body(req));
+      if ("error" in requested) return error(res, 400, requested.error);
+      const { provider } = requested;
+      const action = url.pathname === "/api/mcp/connect" ? "connect" : url.pathname === "/api/mcp/disconnect" ? "disconnect" : "default";
+      const config = (await readConfig(paths)).config;
+      const next = await applyProviderAction(projectRoot, provider, action, config);
+      if (action === "connect" || action === "default") await saveConfig(paths, next);
+      return json(res, 200, { providers: await readProviderStatuses(projectRoot, next) });
+    }
+    if (method === "POST" && url.pathname === "/api/mcp/start") {
+      const config = (await readConfig(paths)).config;
+      if (!config.mcp.enabled) return error(res, 409, "MCP \uC5F0\uACB0\uC774 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 MCP \uC0AC\uC6A9\uC744 \uCF1C\uC138\uC694.");
+      return json(res, 200, { server: await startMcpRuntime(projectRoot) });
+    }
+    if (method === "POST" && url.pathname === "/api/mcp/stop") return json(res, 200, { server: await stopMcpRuntime() });
+    if (method === "POST" && url.pathname === "/api/mcp/check") {
+      lastMcpCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+      return json(res, 200, { connection: { state: "not_checked", lastCheckedAt: lastMcpCheckAt, message: "\uC2E4\uC81C \uB3C4\uAD6C \uD638\uCD9C \uC5EC\uBD80\uB294 \uC0C8 Codex \uC138\uC158\uC5D0\uC11C \uC9C1\uC811 \uD655\uC778\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4." } });
+    }
+    if (method === "GET" && url.pathname === "/api/config/history") return json(res, 200, { history: await getHistory(paths) });
+    if (method === "PUT" && url.pathname === "/api/config") {
+      const result = validateConfig(await body(req));
+      if (!result.ok) return error(res, 400, result.error);
+      const saved = await saveConfig(paths, result.value);
+      return json(res, 200, { ...saved, ...await readOverview(paths) });
+    }
+    if (method === "POST" && url.pathname === "/api/config/reset") {
+      const input = await body(req);
+      if (!input || typeof input !== "object" || input.confirm !== true) {
+        return error(res, 400, "\uAE30\uBCF8\uAC12 \uBCF5\uC6D0 \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      }
+      const saved = await saveConfig(paths, structuredClone(DEFAULT_CONFIG));
+      return json(res, 200, { ...saved, ...await readOverview(paths) });
+    }
+    if (method === "DELETE" && url.pathname === "/api/config/history") {
+      const input = await body(req);
+      if (!input || typeof input !== "object" || input.confirm !== true) {
+        return error(res, 400, "\uC124\uC815 \uAE30\uB85D \uC0AD\uC81C \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      }
+      await withWriteLock(() => writeJsonAtomically(paths.historyFile, []));
+      return json(res, 200, { history: [] });
+    }
+    if (method === "GET" && url.pathname === "/api/feedback") return json(res, 200, { feedback: await getFeedback(paths) });
+    if (method === "POST" && url.pathname === "/api/feedback") {
+      const result = validateFeedback(await body(req));
+      if (!result.ok) return error(res, 400, result.error);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const item = { ...result.value, id: randomUUID2(), createdAt: now, updatedAt: now };
+      await withWriteLock(async () => {
+        const items = await getFeedback(paths);
+        await saveFeedback(paths, [...items, item]);
+      });
+      return json(res, 201, { feedback: item });
+    }
+    const feedbackMatch = url.pathname.match(/^\/api\/feedback\/([^/]+)$/);
+    if (feedbackMatch && !safeId(feedbackMatch[1])) return error(res, 400, "\uD53C\uB4DC\uBC31 \uC2DD\uBCC4\uC790\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+    if (feedbackMatch && method === "PUT") {
+      const result = validateFeedback(await body(req));
+      if (!result.ok) return error(res, 400, result.error);
+      const item = await withWriteLock(async () => {
+        const items = await getFeedback(paths);
+        const index = items.findIndex((item2) => item2.id === feedbackMatch[1]);
+        if (index < 0) return null;
+        const updated = { ...result.value, id: items[index].id, createdAt: items[index].createdAt, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        items[index] = updated;
+        await saveFeedback(paths, items);
+        return updated;
+      });
+      if (!item) return error(res, 404, "\uD53C\uB4DC\uBC31\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+      return json(res, 200, { feedback: item });
+    }
+    if (feedbackMatch && method === "DELETE") {
+      const next = await withWriteLock(async () => {
+        const items = await getFeedback(paths);
+        const updated = items.filter((item) => item.id !== feedbackMatch[1]);
+        if (updated.length === items.length) return null;
+        await saveFeedback(paths, updated);
+        return updated;
+      });
+      if (!next) return error(res, 404, "\uD53C\uB4DC\uBC31\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+      return json(res, 200, { feedback: next });
+    }
+    if (method === "DELETE" && url.pathname === "/api/feedback") {
+      const input = await body(req);
+      if (!input || typeof input !== "object" || input.confirm !== true) {
+        return error(res, 400, "\uD53C\uB4DC\uBC31 \uC804\uCCB4 \uC0AD\uC81C \uD655\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      }
+      await withWriteLock(() => saveFeedback(paths, []));
+      return json(res, 200, { feedback: [] });
+    }
+    return error(res, 404, "\uC694\uCCAD\uD55C \uC8FC\uC18C\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  } catch (caught) {
+    const message = caught instanceof Error ? caught.message : "\uB85C\uCEEC \uC694\uCCAD\uC744 \uCC98\uB9AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.";
+    return error(res, 500, message.includes("\uC694\uCCAD\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4") || message.includes("JSON \uD615\uC2DD") ? message : "\uB85C\uCEEC \uC800\uC7A5\uC744 \uCC98\uB9AC\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+  }
+}
+async function startLocalAdminServer(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 8787;
+  const server = createServer((req, res) => {
+    void handleApiRequest(req, res, options.projectRoot);
+  });
+  server.once("close", () => {
+    void stopMcpRuntime();
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  return { server, port: typeof address === "object" && address ? address.port : port };
+}
+export {
+  handleApiRequest,
+  startLocalAdminServer
+};