farming-code 2.2.29 → 2.2.32

package/backend/config-manager.cjs

@@ -0,0 +1,1263 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_manager_exports = {};
+__export(config_manager_exports, {
+  ConfigManager: () => ConfigManager,
+  DEFAULT_CODE_CONTENT_FONT_SIZE: () => DEFAULT_CODE_CONTENT_FONT_SIZE,
+  DEFAULT_CRT_CONTENT_FONT_SIZE: () => DEFAULT_CRT_CONTENT_FONT_SIZE,
+  DEFAULT_CRT_TERMINAL_FONT_SIZE: () => DEFAULT_CRT_TERMINAL_FONT_SIZE,
+  DEFAULT_SEARCH_TIMEOUT_MS: () => DEFAULT_SEARCH_TIMEOUT_MS,
+  MAX_CONTENT_FONT_SIZE: () => MAX_CONTENT_FONT_SIZE,
+  MAX_CRT_TERMINAL_FONT_SIZE: () => MAX_CRT_TERMINAL_FONT_SIZE,
+  MIN_CONTENT_FONT_SIZE: () => MIN_CONTENT_FONT_SIZE,
+  MIN_CRT_TERMINAL_FONT_SIZE: () => MIN_CRT_TERMINAL_FONT_SIZE
+});
+module.exports = __toCommonJS(config_manager_exports);
+var import_atomic_json_store = require("./atomic-json-store.cjs");
+var import_main_agent_skills = require("./main-agent-skills.cjs");
+var import_farming_agent_bootstrap = require("./farming-agent-bootstrap.cjs");
+var import_claude_settings = require("./claude-settings.cjs");
+var import_provider_session_id = require("./provider-session-id.cjs");
+var import_farming_session_store = require("./farming-session-store.cjs");
+var import_run_history_store = require("./run-history-store.cjs");
+var import_cli_agents = require("./cli-agents.cjs");
+var storageLayout = __toESM(require("./storage-layout.cjs"));
+var import_computer_constants = require("../extensions/computer/backend/computer-constants.cjs");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+function objectRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function objectProperty(value, key) {
+  return value !== null && typeof value === "object" ? value[key] : void 0;
+}
+function spreadableObject(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function validProjectOperationEntry(entry) {
+  const [id, operation] = entry;
+  const record = objectRecord(operation);
+  return PROJECT_OPERATION_ID_PATTERN.test(id) && record !== null && (record.type === "create-worktree" || record.type === "delete-worktree") && (record.state === "pending" || record.state === "unknown" || record.state === "succeeded" || record.state === "failed" || record.state === "blocked");
+}
+function splitCodexModelPreset(preset) {
+  if (preset === "config") {
+    return { model: "config", effort: "config" };
+  }
+  if (typeof preset !== "string") {
+    return { model: "config", effort: "config" };
+  }
+  const [model, effort] = preset.split(":");
+  return {
+    model: model || "config",
+    effort: effort || "config"
+  };
+}
+function joinCodexModelPreset(model, effort) {
+  if (model === "config") return "config";
+  return effort ? `${model}:${effort}` : model;
+}
+const DEFAULT_CODEX_LAUNCH_PROFILE = {
+  approvalMode: "approve",
+  model: "config",
+  reasoningEffort: "config",
+  serviceTier: "config",
+  modelPreset: "config"
+};
+const DEFAULT_CLAUDE_LAUNCH_PROFILE = {
+  permissionMode: "default",
+  model: "config",
+  effort: "config"
+};
+const DEFAULT_AGENT_LAUNCH_PROFILES = {
+  codex: DEFAULT_CODEX_LAUNCH_PROFILE,
+  claude: DEFAULT_CLAUDE_LAUNCH_PROFILE
+};
+const DEFAULT_LAUNCH_AGENT_NAMES = /* @__PURE__ */ new Set(["codex", "claude", "opencode", "qoder", "qwen", "bash", "zsh"]);
+const DEFAULT_AGENT_HOMES = {
+  codex: [{
+    id: "default",
+    path: "~/.codex",
+    order: 0,
+    newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+  }],
+  claude: [{
+    id: "default",
+    path: "~/.claude",
+    order: 1,
+    newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+  }],
+  opencode: [{
+    id: "default",
+    path: "~/.opencode",
+    order: 2,
+    newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+  }],
+  qoder: [{
+    id: "default",
+    path: "~/.qoder",
+    order: 3,
+    newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+  }],
+  qwen: [{
+    id: "default",
+    path: "~/.qwen",
+    order: 4,
+    newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+  }]
+};
+const LEGACY_DEFAULT_WORKSPACE_FILE_SEARCH_TIMEOUT_MS = 3e3;
+const DEFAULT_SEARCH_TIMEOUT_MS = 15e3;
+const MIN_SEARCH_TIMEOUT_MS = 3e3;
+const MAX_SEARCH_TIMEOUT_MS = 18e4;
+const DEFAULT_CODE_CONTENT_FONT_SIZE = 14;
+const DEFAULT_CRT_CONTENT_FONT_SIZE = 14;
+const MIN_CONTENT_FONT_SIZE = 10;
+const MAX_CONTENT_FONT_SIZE = 20;
+const DEFAULT_CRT_TERMINAL_FONT_SIZE = 15;
+const MIN_CRT_TERMINAL_FONT_SIZE = 10;
+const MAX_CRT_TERMINAL_FONT_SIZE = 20;
+const MAX_INSTANCE_NAME_LENGTH = 80;
+const MAX_PROJECT_OPERATIONS = 32;
+const PROJECT_OPERATION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,160}$/;
+const PERSISTED_SETTING_KEYS = /* @__PURE__ */ new Set([
+  "workspace",
+  "lastMainWorkspace",
+  "workspaceHistory",
+  "projectWorkspaces",
+  "pinnedProjectWorkspaces",
+  "projectNames",
+  "projectOperations",
+  "instanceName",
+  "theme",
+  "appearance",
+  "language",
+  "restReminderIntervalSeconds",
+  "heartbeatInterval",
+  "dangerouslySkipAgentPermissionsByDefault",
+  "browserExtensionEnabled",
+  "browserSource",
+  "browserExecutablePath",
+  "browserExternalCdpUrl",
+  "computerExtensionEnabled",
+  "computerCompatibilityMode",
+  "computerImage",
+  "codeContentFontSize",
+  "composerFollowUpBehavior",
+  "crtContentFontSize",
+  "crtSkinEffectsEnabled",
+  "crtDynamicHeatEnabled",
+  "crtTerminalFontSize",
+  "defaultLaunchAgent",
+  "agentLaunchProfiles",
+  "agentHomes",
+  "searchTimeoutMs",
+  "codexApprovalMode",
+  "codexModel",
+  "codexReasoningEffort",
+  "codexServiceTier",
+  "codexModelPreset",
+  "version"
+]);
+function cloneLaunchProfile(profile) {
+  return { ...profile };
+}
+function cloneAgentHomes(agentHomes) {
+  const cloned = {};
+  Object.entries(agentHomes || {}).forEach(([provider, homes]) => {
+    cloned[provider] = Array.isArray(homes) ? homes.map((home) => ({
+      ...home,
+      newAgentDefaults: { ...home.newAgentDefaults }
+    })) : [];
+  });
+  return cloned;
+}
+class ConfigManager {
+  farmingDir;
+  settings;
+  settingsFile;
+  sessionStore;
+  runHistoryStore;
+  writeJson;
+  constructor(options = {}) {
+    this.farmingDir = options.configDir || storageLayout.farmingConfigDir();
+    this.settingsFile = storageLayout.settingsFile(this.farmingDir);
+    this.sessionStore = new import_farming_session_store.FarmingSessionStore(this.farmingDir, {
+      normalizeMainPageSessionKeys: (keys) => this.normalizeMainPageSessionKeys(keys)
+    });
+    this.runHistoryStore = new import_run_history_store.RunHistoryStore(this.farmingDir, {
+      normalizeTaskHistory: (entries) => this.normalizeTaskHistory(entries)
+    });
+    this.writeJson = typeof options.writeJson === "function" ? options.writeJson : import_atomic_json_store.atomicWriteJson;
+  }
+  expandWorkspacePath(workspace) {
+    if (typeof workspace !== "string") return "";
+    const value = workspace.trim();
+    if (!value) return "";
+    if (value === "~") return os.homedir();
+    if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
+    return value;
+  }
+  canonicalAgentHomePath(homePath) {
+    const expanded = this.expandWorkspacePath(homePath);
+    if (!expanded) return "";
+    const resolved = path.resolve(expanded);
+    let canonical = resolved;
+    try {
+      canonical = fs.realpathSync.native(resolved);
+    } catch {
+    }
+    return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+  }
+  agentHomeBindings(records = this.listAgentSessionRecords()) {
+    const bindings = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const provider = String(record.provider || "").trim().toLowerCase();
+      const providerHomeId = String(record.providerHomeId || "default").trim() || "default";
+      const providerHomePath = this.expandWorkspacePath(record.providerHomePath);
+      if (!provider || !providerHomePath) continue;
+      const key = `${provider}\0${providerHomeId}`;
+      const existing = bindings.get(key);
+      if (existing && this.canonicalAgentHomePath(existing.providerHomePath) !== this.canonicalAgentHomePath(providerHomePath)) {
+        const error = new Error(
+          `${provider} Agent Home "${providerHomeId}" has persisted sessions in more than one path`
+        );
+        error.code = "AGENT_HOME_BINDING_CONFLICT";
+        error.status = 409;
+        throw error;
+      }
+      bindings.set(key, { provider, providerHomeId, providerHomePath });
+    }
+    return [...bindings.values()];
+  }
+  assertAgentHomeBindings(nextHomes) {
+    for (const binding of this.agentHomeBindings()) {
+      const configured = (nextHomes[binding.provider] || []).find((home) => home.id === binding.providerHomeId);
+      if (configured && this.canonicalAgentHomePath(configured.path) !== this.canonicalAgentHomePath(binding.providerHomePath)) {
+        const error = new Error(
+          `${binding.provider} Agent Home "${binding.providerHomeId}" already owns persisted Agent sessions at ${binding.providerHomePath}`
+        );
+        error.code = "AGENT_HOME_REFERENCED";
+        error.status = 409;
+        throw error;
+      }
+    }
+  }
+  isTemporaryWorkspace(workspace) {
+    const resolved = path.resolve(this.expandWorkspacePath(workspace));
+    return resolved === "/tmp" || resolved.startsWith("/tmp/") || resolved === "/private/tmp" || resolved.startsWith("/private/tmp/") || resolved === "/var/tmp" || resolved.startsWith("/var/tmp/") || resolved === "/private/var/tmp" || resolved.startsWith("/private/var/tmp/") || resolved === "/var/folders" || resolved.startsWith("/var/folders/") || resolved === "/private/var/folders" || resolved.startsWith("/private/var/folders/");
+  }
+  isUsableWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    if (!expanded || this.isTemporaryWorkspace(expanded)) return false;
+    try {
+      return fs.statSync(expanded).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  isInternalWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    if (!expanded) return false;
+    const resolvedWorkspace = path.resolve(expanded);
+    const resolvedFarmingDir = path.resolve(this.farmingDir);
+    return resolvedWorkspace === resolvedFarmingDir || path.basename(resolvedWorkspace) === ".farming";
+  }
+  normalizeMainWorkspace(workspace, fallback = this.farmingDir) {
+    const expanded = this.expandWorkspacePath(workspace);
+    if (this.isUsableWorkspace(expanded)) {
+      return expanded;
+    }
+    const expandedFallback = this.expandWorkspacePath(fallback);
+    if (this.isUsableWorkspace(expandedFallback)) {
+      return expandedFallback;
+    }
+    return this.farmingDir;
+  }
+  normalizeInstanceName(value) {
+    if (typeof value !== "string") return "";
+    return value.replace(/[\x00-\x1f\x7f]/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_INSTANCE_NAME_LENGTH);
+  }
+  getInstanceName() {
+    return this.settings?.instanceName || this.normalizeInstanceName(os.hostname()) || "Farming";
+  }
+  normalizeWorkspaceHistory(history) {
+    const entries = Array.isArray(history) ? history : [];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const expanded = this.expandWorkspacePath(entry);
+      if (!this.isUsableWorkspace(expanded) || this.isInternalWorkspace(expanded) || seen.has(expanded)) continue;
+      seen.add(expanded);
+      result.push(expanded);
+    }
+    return result.slice(0, 5);
+  }
+  normalizeProjectWorkspaces(projects) {
+    const entries = Array.isArray(projects) ? projects : [];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const expanded = this.expandWorkspacePath(entry);
+      if (!expanded) continue;
+      const resolved = path.resolve(expanded);
+      if (this.isInternalWorkspace(resolved)) continue;
+      let canonical = resolved;
+      try {
+        canonical = fs.realpathSync(resolved);
+      } catch {
+      }
+      if (this.isInternalWorkspace(canonical)) continue;
+      if (seen.has(canonical)) continue;
+      seen.add(canonical);
+      result.push(canonical);
+    }
+    return result.slice(0, 200);
+  }
+  normalizeMainPageSessionKeys(keys) {
+    const entries = Array.isArray(keys) ? keys : [];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (typeof entry !== "string") continue;
+      const value = entry.trim();
+      if (!/^agent-session:[a-z][a-z0-9_-]*:.+$/i.test(value)) continue;
+      const sessionId = value.replace(/^agent-session:[^:]+:/i, "");
+      if (sessionId.startsWith("-")) continue;
+      if ((0, import_provider_session_id.isTemporaryProviderSessionId)(sessionId)) continue;
+      if (seen.has(value)) continue;
+      seen.add(value);
+      result.push(value);
+    }
+    return result.slice(0, import_farming_session_store.MAX_MAIN_PAGE_SESSION_KEYS);
+  }
+  normalizeTaskHistory(history) {
+    const entries = Array.isArray(history) ? history : [];
+    const normalized = [];
+    for (const entry of entries) {
+      const record = objectRecord(entry);
+      if (!record) continue;
+      if (typeof record.id !== "string" || !record.id) continue;
+      if (typeof record.agentId !== "string" || !record.agentId) continue;
+      if (typeof record.reason !== "string" || !record.reason) continue;
+      if (typeof record.archivedAt !== "number" || !Number.isFinite(record.archivedAt)) continue;
+      if (!(0, import_cli_agents.isSupportedHistoryAgent)(record.command)) continue;
+      normalized.push({
+        id: record.id,
+        agentId: record.agentId,
+        command: typeof record.command === "string" ? record.command : "",
+        cwd: typeof record.cwd === "string" ? record.cwd : "",
+        projectWorkspace: typeof record.projectWorkspace === "string" ? record.projectWorkspace : "",
+        title: typeof record.title === "string" ? record.title : "",
+        customTitle: typeof record.customTitle === "string" ? record.customTitle.trim().slice(0, 80) : "",
+        task: typeof record.task === "string" ? record.task : "",
+        workflowTemplate: typeof record.workflowTemplate === "string" ? record.workflowTemplate : "",
+        source: typeof record.source === "string" ? record.source : "ui",
+        reason: record.reason,
+        status: typeof record.status === "string" ? record.status : "stopped",
+        startedAt: typeof record.startedAt === "number" ? record.startedAt : null,
+        lastActivity: typeof record.lastActivity === "number" ? record.lastActivity : null,
+        archivedAt: record.archivedAt
+      });
+    }
+    return normalized.sort((a, b) => b.archivedAt - a.archivedAt).slice(0, 200);
+  }
+  init() {
+    if (!fs.existsSync(this.farmingDir)) {
+      fs.mkdirSync(this.farmingDir, { recursive: true });
+      console.log("Created farming directory:", this.farmingDir);
+    }
+    if (!fs.existsSync(this.settingsFile)) {
+      const defaultSettings = {
+        workspace: this.farmingDir,
+        lastMainWorkspace: this.farmingDir,
+        workspaceHistory: [],
+        projectWorkspaces: [],
+        pinnedProjectWorkspaces: [],
+        projectNames: {},
+        projectOperations: {},
+        instanceName: "",
+        theme: "terminal",
+        appearance: "system",
+        language: "en",
+        restReminderIntervalSeconds: null,
+        heartbeatInterval: 1e3,
+        dangerouslySkipAgentPermissionsByDefault: false,
+        browserExtensionEnabled: false,
+        browserSource: process.env.FARMING_BROWSER_CDP_URL ? "external-cdp" : "system",
+        browserExecutablePath: process.env.FARMING_BROWSER_EXECUTABLE || "",
+        browserExternalCdpUrl: process.env.FARMING_BROWSER_CDP_URL || "http://127.0.0.1:9222",
+        computerExtensionEnabled: false,
+        computerCompatibilityMode: false,
+        computerImage: import_computer_constants.COMPUTER_IMAGE,
+        codeContentFontSize: DEFAULT_CODE_CONTENT_FONT_SIZE,
+        composerFollowUpBehavior: "queue",
+        crtContentFontSize: DEFAULT_CRT_CONTENT_FONT_SIZE,
+        crtSkinEffectsEnabled: true,
+        crtDynamicHeatEnabled: false,
+        crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
+        defaultLaunchAgent: "codex",
+        agentLaunchProfiles: {
+          codex: cloneLaunchProfile(DEFAULT_CODEX_LAUNCH_PROFILE),
+          claude: cloneLaunchProfile(DEFAULT_CLAUDE_LAUNCH_PROFILE)
+        },
+        agentHomes: cloneAgentHomes(DEFAULT_AGENT_HOMES),
+        searchTimeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
+        codexApprovalMode: "approve",
+        codexModel: "config",
+        codexReasoningEffort: "config",
+        codexServiceTier: "config",
+        codexModelPreset: "config",
+        version: "2"
+      };
+      this.writeSettingsFile(defaultSettings);
+      console.log("Created default settings:", this.settingsFile);
+    }
+    const rawSettings = JSON.parse(fs.readFileSync(this.settingsFile, "utf8"));
+    this.settings = {
+      workspace: this.farmingDir,
+      lastMainWorkspace: this.farmingDir,
+      workspaceHistory: [],
+      projectWorkspaces: [],
+      pinnedProjectWorkspaces: [],
+      projectNames: {},
+      projectOperations: {},
+      instanceName: "",
+      theme: "terminal",
+      appearance: "system",
+      language: "en",
+      restReminderIntervalSeconds: null,
+      heartbeatInterval: 1e3,
+      dangerouslySkipAgentPermissionsByDefault: false,
+      browserExtensionEnabled: false,
+      browserSource: process.env.FARMING_BROWSER_CDP_URL ? "external-cdp" : "system",
+      browserExecutablePath: process.env.FARMING_BROWSER_EXECUTABLE || "",
+      browserExternalCdpUrl: process.env.FARMING_BROWSER_CDP_URL || "http://127.0.0.1:9222",
+      computerExtensionEnabled: false,
+      computerCompatibilityMode: false,
+      computerImage: import_computer_constants.COMPUTER_IMAGE,
+      codeContentFontSize: DEFAULT_CODE_CONTENT_FONT_SIZE,
+      composerFollowUpBehavior: "queue",
+      crtContentFontSize: DEFAULT_CRT_CONTENT_FONT_SIZE,
+      crtSkinEffectsEnabled: true,
+      crtDynamicHeatEnabled: false,
+      crtTerminalFontSize: DEFAULT_CRT_TERMINAL_FONT_SIZE,
+      defaultLaunchAgent: "codex",
+      agentLaunchProfiles: {
+        codex: cloneLaunchProfile(DEFAULT_CODEX_LAUNCH_PROFILE),
+        claude: cloneLaunchProfile(DEFAULT_CLAUDE_LAUNCH_PROFILE)
+      },
+      agentHomes: cloneAgentHomes(DEFAULT_AGENT_HOMES),
+      searchTimeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
+      codexApprovalMode: "approve",
+      codexModel: "config",
+      codexReasoningEffort: "config",
+      codexServiceTier: "config",
+      codexModelPreset: "config",
+      version: "2",
+      ...rawSettings
+    };
+    if (rawSettings.searchTimeoutMs === void 0 && rawSettings.workspaceFileSearchTimeoutMs !== void 0) {
+      const legacyTimeoutMs = Number(rawSettings.workspaceFileSearchTimeoutMs);
+      this.settings.searchTimeoutMs = legacyTimeoutMs === LEGACY_DEFAULT_WORKSPACE_FILE_SEARCH_TIMEOUT_MS ? DEFAULT_SEARCH_TIMEOUT_MS : legacyTimeoutMs;
+    }
+    delete this.settings.workspaceFileSearchTimeoutMs;
+    if (this.settings.dangerouslySkipAgentPermissionsByDefault === void 0 && this.settings.skipPermissionCheckByDefault !== void 0) {
+      this.settings.dangerouslySkipAgentPermissionsByDefault = this.settings.skipPermissionCheckByDefault === true;
+    }
+    delete this.settings.skipPermissionCheckByDefault;
+    const launchRawSettings = { ...rawSettings };
+    if (rawSettings.codexApprovalMode === void 0 && this.settings.dangerouslySkipAgentPermissionsByDefault === true) {
+      this.settings.codexApprovalMode = "full";
+      launchRawSettings.codexApprovalMode = "full";
+    }
+    this.settings.workspace = this.farmingDir;
+    this.settings.lastMainWorkspace = this.normalizeMainWorkspace(this.settings.lastMainWorkspace, this.farmingDir);
+    this.settings.workspaceHistory = this.normalizeWorkspaceHistory(this.settings.workspaceHistory);
+    this.settings.projectWorkspaces = this.normalizeProjectWorkspaces(this.settings.projectWorkspaces);
+    this.settings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(this.settings.pinnedProjectWorkspaces);
+    this.settings.projectNames = this.normalizeProjectNames(this.settings.projectNames);
+    this.settings.projectOperations = this.normalizeProjectOperations(this.settings.projectOperations);
+    this.settings.instanceName = this.normalizeInstanceName(this.settings.instanceName);
+    this.settings.agentHomes = this.normalizeAgentHomes(this.settings.agentHomes);
+    delete this.settings.updateUrl;
+    this.settings.searchTimeoutMs = this.normalizeSearchTimeoutMs(this.settings.searchTimeoutMs);
+    delete this.settings.codexRuntimeMode;
+    const legacyMainPageSessionKeys = this.normalizeMainPageSessionKeys(this.settings.mainPageSessionKeys);
+    delete this.settings.mainPageSessionKeys;
+    this.sessionStore.init({ legacyMainPageSessionKeys });
+    this.assertAgentHomeBindings(this.settings.agentHomes);
+    const legacyTaskHistory = this.normalizeTaskHistory(this.settings.taskHistory);
+    delete this.settings.taskHistory;
+    this.runHistoryStore.init({ legacyTaskHistory });
+    this.settings.appearance = this.normalizeAppearance(this.settings.appearance);
+    this.settings.language = this.normalizeLanguage(this.settings.language);
+    this.settings.restReminderIntervalSeconds = this.normalizeRestReminderIntervalSeconds(
+      this.settings.restReminderIntervalSeconds
+    );
+    this.settings.browserExtensionEnabled = this.settings.browserExtensionEnabled === true;
+    this.settings.browserSource = this.normalizeBrowserSource(this.settings.browserSource);
+    this.settings.browserExecutablePath = this.normalizeBrowserSetting(this.settings.browserExecutablePath);
+    this.settings.browserExternalCdpUrl = this.normalizeBrowserSetting(this.settings.browserExternalCdpUrl) || "http://127.0.0.1:9222";
+    this.settings.computerExtensionEnabled = this.settings.computerExtensionEnabled === true;
+    if (this.settings.browserExtensionEnabled && this.settings.browserSource === "isolated") {
+      this.settings.computerExtensionEnabled = true;
+    }
+    this.settings.computerCompatibilityMode = this.settings.computerCompatibilityMode === true;
+    this.settings.computerImage = this.normalizeBrowserSetting(this.settings.computerImage) || import_computer_constants.COMPUTER_IMAGE;
+    this.settings.codeContentFontSize = this.normalizeContentFontSize(
+      this.settings.codeContentFontSize,
+      DEFAULT_CODE_CONTENT_FONT_SIZE
+    );
+    this.settings.composerFollowUpBehavior = this.normalizeComposerFollowUpBehavior(
+      this.settings.composerFollowUpBehavior
+    );
+    this.settings.crtContentFontSize = this.normalizeContentFontSize(
+      rawSettings.crtContentFontSize === void 0 ? Number(this.settings.crtTerminalFontSize) - 1 : this.settings.crtContentFontSize,
+      DEFAULT_CRT_CONTENT_FONT_SIZE
+    );
+    this.settings.crtSkinEffectsEnabled = this.settings.crtSkinEffectsEnabled !== false;
+    this.settings.crtDynamicHeatEnabled = this.settings.crtDynamicHeatEnabled === true;
+    this.settings.crtTerminalFontSize = this.crtTerminalFontSizeFromContent(this.settings.crtContentFontSize);
+    this.normalizeAgentLaunchSettings(launchRawSettings);
+    this.pruneUnknownSettings();
+    (0, import_main_agent_skills.ensureMainAgentSkillFiles)(this.farmingDir);
+    (0, import_farming_agent_bootstrap.ensureFarmingAgentBootstrapFile)(this.farmingDir);
+    this.writeSettingsFile();
+    console.log("Loaded settings:", this.settings);
+  }
+  pruneUnknownSettings(settings = this.settings) {
+    for (const key of Object.keys(settings || {})) {
+      if (!PERSISTED_SETTING_KEYS.has(key)) {
+        delete settings[key];
+      }
+    }
+  }
+  normalizeDefaultLaunchAgent(agentName) {
+    return typeof agentName === "string" && DEFAULT_LAUNCH_AGENT_NAMES.has(agentName) ? agentName : "codex";
+  }
+  normalizeSearchTimeoutMs(value) {
+    const timeoutMs = Number(value);
+    if (!Number.isFinite(timeoutMs)) return DEFAULT_SEARCH_TIMEOUT_MS;
+    return Math.min(
+      MAX_SEARCH_TIMEOUT_MS,
+      Math.max(MIN_SEARCH_TIMEOUT_MS, Math.round(timeoutMs))
+    );
+  }
+  normalizeContentFontSize(value, fallback) {
+    const fontSize = Number(value);
+    if (!Number.isFinite(fontSize)) return fallback;
+    return Math.min(MAX_CONTENT_FONT_SIZE, Math.max(MIN_CONTENT_FONT_SIZE, Math.round(fontSize)));
+  }
+  normalizeComposerFollowUpBehavior(value) {
+    return value === "steer" ? "steer" : "queue";
+  }
+  crtTerminalFontSizeFromContent(value) {
+    return this.normalizeCrtTerminalFontSize(
+      this.normalizeContentFontSize(value, DEFAULT_CRT_CONTENT_FONT_SIZE) + 1
+    );
+  }
+  normalizeRestReminderIntervalSeconds(value) {
+    if (value === null || value === void 0 || value === "") return null;
+    const seconds = Number(value);
+    if (!Number.isInteger(seconds)) return null;
+    if (seconds === 0 || seconds === 5) return seconds;
+    return seconds >= 60 && seconds <= 240 * 60 && seconds % 60 === 0 ? seconds : null;
+  }
+  normalizeCrtTerminalFontSize(value) {
+    const fontSize = Number(value);
+    if (!Number.isFinite(fontSize)) return DEFAULT_CRT_TERMINAL_FONT_SIZE;
+    return Math.min(
+      MAX_CRT_TERMINAL_FONT_SIZE,
+      Math.max(MIN_CRT_TERMINAL_FONT_SIZE, Math.round(fontSize))
+    );
+  }
+  normalizeAgentHomes(agentHomes) {
+    const source = objectRecord(agentHomes) || {};
+    const normalized = {};
+    Object.entries(source).forEach(([rawProvider, rawHomes]) => {
+      const provider = String(rawProvider || "").trim().toLowerCase();
+      if (!/^[a-z0-9._-]+$/.test(provider)) return;
+      if (!Object.prototype.hasOwnProperty.call(DEFAULT_AGENT_HOMES, provider)) return;
+      if (!Array.isArray(rawHomes)) return;
+      const seenIds = /* @__PURE__ */ new Set();
+      const seenPaths = /* @__PURE__ */ new Map();
+      const homes = [];
+      rawHomes.forEach((rawHome, homeIndex) => {
+        const record = objectRecord(rawHome);
+        if (!record) return;
+        const id = String(record.id || "").trim();
+        const homePath = String(record.path || "").trim();
+        if (!id || !homePath) return;
+        if (!/^[A-Za-z0-9._-]+$/.test(id)) return;
+        const idKey = id.toLowerCase();
+        if (seenIds.has(idKey)) {
+          const error = new Error(`${provider} contains more than one Agent Home named "${id}"`);
+          error.code = "AGENT_HOME_DUPLICATE_ID";
+          error.status = 409;
+          throw error;
+        }
+        seenIds.add(idKey);
+        const canonicalPath = this.canonicalAgentHomePath(homePath);
+        const existingPathHomeId = seenPaths.get(canonicalPath);
+        if (existingPathHomeId) {
+          const error = new Error(
+            `${provider} Agent Homes "${existingPathHomeId}" and "${id}" use the same Home path`
+          );
+          error.code = "AGENT_HOME_DUPLICATE_PATH";
+          error.status = 409;
+          throw error;
+        }
+        seenPaths.set(canonicalPath, id);
+        const rawDefaults = objectRecord(record.newAgentDefaults) || {};
+        const model = String(rawDefaults.model || "inherit").trim();
+        const reasoning = String(rawDefaults.reasoning || "inherit").trim();
+        const fast = String(rawDefaults.fast || "inherit").trim();
+        const providerRank = Object.keys(DEFAULT_AGENT_HOMES).indexOf(provider);
+        const requestedOrder = Number(record.order);
+        homes.push({
+          id,
+          path: homePath,
+          order: Number.isFinite(requestedOrder) && requestedOrder >= 0 ? requestedOrder : providerRank * 1e3 + homeIndex,
+          newAgentDefaults: {
+            model: model && model.length <= 200 && !/[\r\n\0]/.test(model) ? model : "inherit",
+            reasoning: /^[A-Za-z0-9._-]{1,80}$/.test(reasoning) ? reasoning : "inherit",
+            fast: fast === "on" || fast === "off" ? fast : "inherit"
+          }
+        });
+      });
+      if (homes.length > 0) normalized[provider] = homes;
+    });
+    for (const [provider, homes] of Object.entries(DEFAULT_AGENT_HOMES)) {
+      const defaultHome = homes[0];
+      const providerHomes = normalized[provider] || [];
+      if (!providerHomes.some((home) => String(home.id || "").toLowerCase() === "default")) {
+        normalized[provider] = [{ ...defaultHome }, ...providerHomes];
+      }
+    }
+    for (const [provider, homes] of Object.entries(normalized)) {
+      const ownersByPath = /* @__PURE__ */ new Map();
+      for (const home of homes) {
+        const canonicalPath = this.canonicalAgentHomePath(home.path);
+        const existingHomeId = ownersByPath.get(canonicalPath);
+        if (existingHomeId && existingHomeId !== home.id) {
+          const error = new Error(
+            `${provider} Agent Homes "${existingHomeId}" and "${home.id}" use the same Home path`
+          );
+          error.code = "AGENT_HOME_DUPLICATE_PATH";
+          error.status = 409;
+          throw error;
+        }
+        ownersByPath.set(canonicalPath, home.id);
+      }
+    }
+    return normalized;
+  }
+  normalizeProjectNames(projectNames) {
+    const source = objectRecord(projectNames);
+    if (!source) return {};
+    const normalized = {};
+    Object.entries(source).forEach(([workspace, name]) => {
+      const key = this.expandWorkspacePath(String(workspace || "").trim());
+      const value = String(name || "").trim().slice(0, 80);
+      if (!key || !value) return;
+      normalized[key] = value;
+    });
+    return normalized;
+  }
+  normalizeProjectOperations(projectOperations) {
+    const source = objectRecord(projectOperations);
+    if (!source) return {};
+    const entries = Object.entries(source).filter(validProjectOperationEntry).sort((left, right) => (Number(right[1].updatedAt) || 0) - (Number(left[1].updatedAt) || 0)).map(([id, operation]) => {
+      const normalizedOperation = {
+        id,
+        type: operation.type,
+        state: operation.state,
+        signature: typeof operation.signature === "string" ? operation.signature.slice(0, 128) : "",
+        request: objectRecord(operation.request) ? objectRecord(JSON.parse(JSON.stringify(operation.request))) || {} : {},
+        result: objectRecord(operation.result) ? objectRecord(JSON.parse(JSON.stringify(operation.result))) : null,
+        error: typeof operation.error === "string" ? operation.error.slice(0, 2e3) : "",
+        startedAt: Number(operation.startedAt) || 0,
+        updatedAt: Number(operation.updatedAt) || 0,
+        finishedAt: Number(operation.finishedAt) || null
+      };
+      return [id, normalizedOperation];
+    });
+    const unresolved = entries.filter(([, operation]) => ["pending", "unknown", "blocked"].includes(operation.state));
+    const terminal = entries.filter(([, operation]) => !["pending", "unknown", "blocked"].includes(operation.state));
+    return Object.fromEntries([
+      ...unresolved,
+      ...terminal.slice(0, Math.max(0, MAX_PROJECT_OPERATIONS - unresolved.length))
+    ]);
+  }
+  setProjectName(workspace, name) {
+    const normalized = this.normalizeProjectNames({ [String(workspace)]: name });
+    const entry = Object.entries(normalized)[0];
+    if (!entry) throw new Error("Project workspace and name are required");
+    const [normalizedWorkspace, normalizedName] = entry;
+    const nextSettings = {
+      ...this.settings,
+      projectNames: {
+        ...this.settings.projectNames,
+        [normalizedWorkspace]: normalizedName
+      }
+    };
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
+    return {
+      workspace: normalizedWorkspace,
+      name: normalizedName
+    };
+  }
+  normalizeAppearance(appearance) {
+    return typeof appearance === "string" && ["system", "light", "dark"].includes(appearance) ? appearance : "system";
+  }
+  normalizeLanguage(language) {
+    return typeof language === "string" && ["en", "zh"].includes(language) ? language : "en";
+  }
+  normalizeBrowserSource(source) {
+    return typeof source === "string" && ["external-cdp", "isolated"].includes(source) ? source : "system";
+  }
+  normalizeBrowserSetting(value) {
+    return String(value || "").trim().slice(0, 2e3);
+  }
+  normalizeClaudePermissionMode(mode) {
+    return typeof mode === "string" && ["acceptEdits", "auto", "bypassPermissions", "default", "dontAsk", "plan"].includes(mode) ? mode : "default";
+  }
+  normalizeClaudeModel(model) {
+    if (model === "config") return model;
+    return (0, import_claude_settings.normalizeClaudeModelValue)(model) || "config";
+  }
+  normalizeClaudeEffort(effort) {
+    if (effort === "config") return effort;
+    if (typeof effort === "string" && ["low", "medium", "high", "xhigh", "max"].includes(effort)) return effort;
+    return "config";
+  }
+  normalizeCodexApprovalMode(mode) {
+    return typeof mode === "string" && ["ask", "approve", "full", "custom"].includes(mode) ? mode : "approve";
+  }
+  normalizeCodexModelPreset(preset) {
+    if (preset === "config") return preset;
+    if (typeof preset !== "string") return "config";
+    if (/^[A-Za-z0-9._-]+(?::[A-Za-z0-9._-]+)?$/.test(preset)) return preset;
+    return "config";
+  }
+  normalizeCodexModelId(model) {
+    if (model === "config") return model;
+    if (typeof model !== "string") return "config";
+    if (/^[A-Za-z0-9._-]+$/.test(model)) return model;
+    return "config";
+  }
+  normalizeCodexReasoningEffort(effort) {
+    if (effort === "config") return effort;
+    if (typeof effort !== "string") return "config";
+    if (/^[A-Za-z0-9._-]+$/.test(effort)) return effort;
+    return "config";
+  }
+  normalizeCodexServiceTier(tier) {
+    if (typeof tier !== "string") return "config";
+    if (/^[A-Za-z0-9._-]+$/.test(tier)) return tier;
+    return "config";
+  }
+  normalizeCodexModelSettings(rawSettings = {}) {
+    const codexProfile = this.normalizeCodexLaunchProfile({
+      approvalMode: this.settings.codexApprovalMode,
+      model: this.settings.codexModel,
+      reasoningEffort: this.settings.codexReasoningEffort,
+      serviceTier: this.settings.codexServiceTier,
+      modelPreset: this.settings.codexModelPreset
+    }, {
+      approvalMode: rawSettings.codexApprovalMode,
+      model: rawSettings.codexModel,
+      reasoningEffort: rawSettings.codexReasoningEffort,
+      serviceTier: rawSettings.codexServiceTier,
+      modelPreset: rawSettings.codexModelPreset
+    });
+    this.applyCodexProfileToLegacySettings(codexProfile);
+  }
+  normalizeCodexLaunchProfile(profile = {}, changed = {}) {
+    const next = {
+      ...DEFAULT_CODEX_LAUNCH_PROFILE,
+      ...spreadableObject(profile)
+    };
+    next.approvalMode = this.normalizeCodexApprovalMode(next.approvalMode);
+    const hasDirectModelChange = changed.model !== void 0 || changed.reasoningEffort !== void 0;
+    const hasPresetChange = changed.modelPreset !== void 0;
+    const normalizedPreset = this.normalizeCodexModelPreset(next.modelPreset);
+    if (hasPresetChange && !hasDirectModelChange) {
+      const fromPreset = splitCodexModelPreset(normalizedPreset);
+      next.model = fromPreset.model;
+      next.reasoningEffort = fromPreset.effort;
+    } else {
+      next.model = this.normalizeCodexModelId(next.model);
+      next.reasoningEffort = this.normalizeCodexReasoningEffort(next.reasoningEffort);
+    }
+    next.serviceTier = this.normalizeCodexServiceTier(next.serviceTier);
+    next.modelPreset = joinCodexModelPreset(
+      next.model,
+      next.reasoningEffort === "config" ? "" : next.reasoningEffort
+    );
+    return next;
+  }
+  normalizeClaudeLaunchProfile(profile = {}) {
+    const next = {
+      ...DEFAULT_CLAUDE_LAUNCH_PROFILE,
+      ...spreadableObject(profile)
+    };
+    return {
+      permissionMode: this.normalizeClaudePermissionMode(next.permissionMode),
+      model: this.normalizeClaudeModel(next.model),
+      effort: this.normalizeClaudeEffort(next.effort)
+    };
+  }
+  getChangedAgentLaunchProfiles(rawSettings = {}) {
+    const changedProfiles = {};
+    if (rawSettings.agentLaunchProfiles && typeof rawSettings.agentLaunchProfiles === "object") {
+      for (const [agentName, profile] of Object.entries(rawSettings.agentLaunchProfiles)) {
+        if (!Object.prototype.hasOwnProperty.call(DEFAULT_AGENT_LAUNCH_PROFILES, agentName)) continue;
+        if (profile && typeof profile === "object") changedProfiles[agentName] = profile;
+      }
+    }
+    const codexChanged = {};
+    if (rawSettings.codexApprovalMode !== void 0) codexChanged.approvalMode = rawSettings.codexApprovalMode;
+    if (rawSettings.codexModel !== void 0) codexChanged.model = rawSettings.codexModel;
+    if (rawSettings.codexReasoningEffort !== void 0) codexChanged.reasoningEffort = rawSettings.codexReasoningEffort;
+    if (rawSettings.codexServiceTier !== void 0) codexChanged.serviceTier = rawSettings.codexServiceTier;
+    if (rawSettings.codexModelPreset !== void 0) codexChanged.modelPreset = rawSettings.codexModelPreset;
+    if (Object.keys(codexChanged).length > 0) {
+      changedProfiles.codex = {
+        ...changedProfiles.codex || {},
+        ...codexChanged
+      };
+    }
+    return changedProfiles;
+  }
+  mergeAgentLaunchProfiles(existingProfiles = {}, incomingProfiles = {}) {
+    const merged = {
+      codex: cloneLaunchProfile(DEFAULT_CODEX_LAUNCH_PROFILE),
+      claude: cloneLaunchProfile(DEFAULT_CLAUDE_LAUNCH_PROFILE)
+    };
+    for (const [agentName, defaultProfile] of Object.entries(DEFAULT_AGENT_LAUNCH_PROFILES)) {
+      merged[agentName] = {
+        ...defaultProfile,
+        ...spreadableObject(objectProperty(existingProfiles, agentName)),
+        ...spreadableObject(objectProperty(incomingProfiles, agentName))
+      };
+    }
+    return merged;
+  }
+  applyCodexProfileToLegacySettings(codexProfile, settings = this.settings) {
+    settings.codexApprovalMode = codexProfile.approvalMode;
+    settings.codexModel = codexProfile.model;
+    settings.codexReasoningEffort = codexProfile.reasoningEffort;
+    settings.codexServiceTier = codexProfile.serviceTier;
+    settings.codexModelPreset = codexProfile.modelPreset;
+  }
+  normalizeAgentLaunchSettings(rawSettings = {}, settings = this.settings) {
+    const changedProfiles = this.getChangedAgentLaunchProfiles(rawSettings);
+    const mergedProfiles = this.mergeAgentLaunchProfiles(settings.agentLaunchProfiles, changedProfiles);
+    settings.agentLaunchProfiles = {
+      codex: this.normalizeCodexLaunchProfile(mergedProfiles.codex, changedProfiles.codex || {}),
+      claude: this.normalizeClaudeLaunchProfile(mergedProfiles.claude)
+    };
+    settings.defaultLaunchAgent = this.normalizeDefaultLaunchAgent(settings.defaultLaunchAgent);
+    this.applyCodexProfileToLegacySettings(settings.agentLaunchProfiles.codex, settings);
+  }
+  getWorkspace() {
+    return this.settings ? this.settings.workspace : this.farmingDir;
+  }
+  getHeartbeatInterval() {
+    return this.settings ? this.settings.heartbeatInterval || 1e3 : 1e3;
+  }
+  getDangerouslySkipAgentPermissionsByDefault() {
+    return this.settings ? this.settings.dangerouslySkipAgentPermissionsByDefault === true : false;
+  }
+  getCodexApprovalMode() {
+    if (!this.settings) return "approve";
+    return this.getAgentLaunchProfile("codex").approvalMode;
+  }
+  getCodexModelPreset() {
+    if (!this.settings) return "config";
+    return this.getAgentLaunchProfile("codex").modelPreset;
+  }
+  getCodexModel() {
+    if (!this.settings) return "config";
+    return this.getAgentLaunchProfile("codex").model;
+  }
+  getCodexReasoningEffort() {
+    if (!this.settings) return "config";
+    return this.getAgentLaunchProfile("codex").reasoningEffort;
+  }
+  getCodexServiceTier() {
+    if (!this.settings) return "config";
+    return this.getAgentLaunchProfile("codex").serviceTier;
+  }
+  getAgentHomes(provider) {
+    const providerKey = String(provider);
+    const homes = this.settings && this.settings.agentHomes && this.settings.agentHomes[providerKey] ? this.settings.agentHomes[providerKey] : [];
+    return homes.map((home) => ({
+      ...home,
+      newAgentDefaults: { ...home.newAgentDefaults },
+      path: this.expandWorkspacePath(home.path)
+    }));
+  }
+  getAgentHome(provider, homeId = "default") {
+    const normalizedProvider = String(provider || "").trim().toLowerCase();
+    const normalizedHomeId = String(homeId || "default").trim();
+    const homes = this.getAgentHomes(normalizedProvider);
+    return homes.find((home) => home.id === normalizedHomeId) || null;
+  }
+  getKnownAgentHomes(provider, bindings = this.agentHomeBindings()) {
+    const normalizedProvider = String(provider || "").trim().toLowerCase();
+    const homes = this.getAgentHomes(normalizedProvider);
+    const knownIds = new Set(homes.map((home) => home.id));
+    for (const binding of bindings) {
+      if (binding.provider !== normalizedProvider || knownIds.has(binding.providerHomeId)) continue;
+      knownIds.add(binding.providerHomeId);
+      homes.push({
+        id: binding.providerHomeId,
+        path: binding.providerHomePath,
+        order: Number.MAX_SAFE_INTEGER,
+        newAgentDefaults: { model: "inherit", reasoning: "inherit", fast: "inherit" }
+      });
+    }
+    return homes;
+  }
+  getKnownAgentHome(provider, homeId = "default") {
+    const normalizedHomeId = String(homeId || "default").trim();
+    return this.getKnownAgentHomes(provider).find((home) => home.id === normalizedHomeId) || null;
+  }
+  getDefaultLaunchAgent() {
+    return this.settings ? this.normalizeDefaultLaunchAgent(this.settings.defaultLaunchAgent) : "codex";
+  }
+  getAgentLaunchProfiles() {
+    const profiles = this.settings && this.settings.agentLaunchProfiles ? this.settings.agentLaunchProfiles : DEFAULT_AGENT_LAUNCH_PROFILES;
+    return {
+      codex: { ...profiles.codex },
+      claude: { ...profiles.claude }
+    };
+  }
+  getAgentLaunchProfile(agentName) {
+    const profiles = this.getAgentLaunchProfiles();
+    const profileName = String(agentName);
+    const profile = profiles[profileName] || DEFAULT_AGENT_LAUNCH_PROFILES[profileName];
+    return profile ? { ...profile } : {};
+  }
+  getAgentLaunchProfileForHome(agentName, homeId = "default") {
+    const provider = String(agentName || "").trim().toLowerCase();
+    const profile = this.getAgentLaunchProfile(provider);
+    const home = this.getAgentHome(provider, homeId);
+    if (!home) return profile;
+    if (provider === "codex") {
+      return {
+        ...profile,
+        model: "config",
+        reasoningEffort: "config",
+        serviceTier: "config",
+        modelPreset: "config"
+      };
+    }
+    if (provider === "claude") {
+      return {
+        ...profile,
+        model: "config",
+        effort: "config"
+      };
+    }
+    return profile;
+  }
+  getSettings() {
+    const {
+      projectOperations: _privateProjectOperations,
+      ...publicSettings
+    } = this.settings;
+    return {
+      ...publicSettings,
+      instanceName: this.getInstanceName(),
+      workspace: this.farmingDir,
+      mainPageSessionKeys: this.getMainPageSessionKeys(),
+      taskHistory: this.getTaskHistory()
+    };
+  }
+  mountProjectWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    const resolved = expanded ? path.resolve(expanded) : "";
+    let canonicalWorkspace = "";
+    if (resolved) {
+      try {
+        canonicalWorkspace = fs.realpathSync(resolved);
+        if (!fs.statSync(canonicalWorkspace).isDirectory()) canonicalWorkspace = "";
+      } catch {
+        canonicalWorkspace = "";
+      }
+    }
+    if (!canonicalWorkspace || this.isInternalWorkspace(canonicalWorkspace)) {
+      throw new Error("Project workspace is invalid or unavailable");
+    }
+    const current = this.settings.projectWorkspaces || [];
+    if (!current.includes(canonicalWorkspace)) {
+      this.commitProjectMembership({
+        projectWorkspaces: [canonicalWorkspace, ...current]
+      });
+    }
+    return {
+      workspace: canonicalWorkspace,
+      projectWorkspaces: [...this.settings.projectWorkspaces || []],
+      pinnedProjectWorkspaces: [...this.settings.pinnedProjectWorkspaces || []]
+    };
+  }
+  removeProjectWorkspace(workspace) {
+    const expanded = this.expandWorkspacePath(workspace);
+    if (!expanded) throw new Error("Project workspace is required");
+    const resolved = path.resolve(expanded);
+    const candidates = /* @__PURE__ */ new Set([expanded, resolved]);
+    try {
+      candidates.add(fs.realpathSync(resolved));
+    } catch {
+    }
+    const current = this.settings.projectWorkspaces || [];
+    const nextProjects = current.filter((entry) => !candidates.has(entry));
+    const currentPinned = this.settings.pinnedProjectWorkspaces || [];
+    const nextPinned = currentPinned.filter((entry) => !candidates.has(entry));
+    if (nextProjects.length !== current.length || nextPinned.length !== currentPinned.length) {
+      this.commitProjectMembership({
+        projectWorkspaces: nextProjects,
+        pinnedProjectWorkspaces: nextPinned
+      });
+    }
+    return {
+      workspace: current.find((entry) => candidates.has(entry)) || resolved,
+      projectWorkspaces: [...this.settings.projectWorkspaces || []],
+      pinnedProjectWorkspaces: [...this.settings.pinnedProjectWorkspaces || []]
+    };
+  }
+  setProjectWorkspacePinned(workspace, pinned) {
+    const [canonicalWorkspace] = this.normalizeProjectWorkspaces([workspace]);
+    if (!canonicalWorkspace || !(this.settings.projectWorkspaces || []).includes(canonicalWorkspace)) {
+      throw new Error("Project does not exist");
+    }
+    const current = this.settings.pinnedProjectWorkspaces || [];
+    const nextPinned = pinned ? [...current.filter((entry) => entry !== canonicalWorkspace), canonicalWorkspace] : current.filter((entry) => entry !== canonicalWorkspace);
+    if (nextPinned.length !== current.length || nextPinned.some((entry, index) => entry !== current[index])) {
+      this.commitProjectMembership({ pinnedProjectWorkspaces: nextPinned });
+    }
+    return {
+      workspace: canonicalWorkspace,
+      projectWorkspaces: [...this.settings.projectWorkspaces || []],
+      pinnedProjectWorkspaces: [...this.settings.pinnedProjectWorkspaces || []]
+    };
+  }
+  commitProjectMembership(settingsPatch) {
+    const previousSettings = this.settings;
+    try {
+      this.updateSettings(settingsPatch);
+    } catch (error) {
+      this.settings = previousSettings;
+      throw error;
+    }
+  }
+  getProjectOperation(requestId) {
+    const id = String(requestId || "").trim();
+    if (!PROJECT_OPERATION_ID_PATTERN.test(id)) return null;
+    const operation = this.settings.projectOperations?.[id];
+    return operation ? JSON.parse(JSON.stringify(operation)) : null;
+  }
+  commitProjectOperation(operation, membership = {}) {
+    const operationId = String(objectProperty(operation, "id"));
+    const normalized = this.normalizeProjectOperations({ [operationId]: operation });
+    const nextOperation = normalized[operationId];
+    if (!nextOperation) throw new Error("Project operation is invalid");
+    const existingOperation = this.settings.projectOperations?.[nextOperation.id];
+    const unresolvedCount = Object.values(this.settings.projectOperations || {}).filter((candidate) => ["pending", "unknown", "blocked"].includes(candidate.state)).length;
+    if (!existingOperation && nextOperation.state === "pending" && unresolvedCount >= MAX_PROJECT_OPERATIONS) {
+      throw new Error("Too many unresolved Project operations require reconciliation");
+    }
+    const nextOperations = this.normalizeProjectOperations({
+      ...this.settings.projectOperations,
+      [nextOperation.id]: nextOperation
+    });
+    const nextSettings = {
+      ...this.settings,
+      projectOperations: nextOperations
+    };
+    if (membership.mountWorkspace) {
+      const mounted = this.normalizeProjectWorkspaces([
+        membership.mountWorkspace,
+        ...this.settings.projectWorkspaces || []
+      ]);
+      nextSettings.projectWorkspaces = mounted;
+      nextSettings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(
+        this.settings.pinnedProjectWorkspaces
+      );
+    }
+    if (membership.removeWorkspace) {
+      const expanded = this.expandWorkspacePath(membership.removeWorkspace);
+      const resolved = expanded ? path.resolve(expanded) : "";
+      const candidates = new Set([expanded, resolved].filter(Boolean));
+      try {
+        candidates.add(fs.realpathSync(resolved));
+      } catch {
+      }
+      nextSettings.projectWorkspaces = (this.settings.projectWorkspaces || []).filter((workspace) => !candidates.has(workspace));
+      nextSettings.pinnedProjectWorkspaces = (this.settings.pinnedProjectWorkspaces || []).filter((workspace) => !candidates.has(workspace));
+    }
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
+    return {
+      operation: JSON.parse(JSON.stringify(nextOperation)),
+      projectWorkspaces: [...nextSettings.projectWorkspaces || []],
+      pinnedProjectWorkspaces: [...nextSettings.pinnedProjectWorkspaces || []]
+    };
+  }
+  getMainPageSessionKeys() {
+    return this.sessionStore ? this.sessionStore.getMainPageSessionKeys() : [];
+  }
+  setMainPageSessionKeys(keys) {
+    return this.sessionStore ? this.sessionStore.setMainPageSessionKeys(keys) : [];
+  }
+  rememberMainPageSessionKey(sessionKey, patch = {}) {
+    return this.sessionStore ? this.sessionStore.rememberMainPageSessionKey(sessionKey, patch) : [];
+  }
+  removeMainPageSessionKey(sessionKey) {
+    return this.sessionStore ? this.sessionStore.removeMainPageSessionKey(sessionKey) : false;
+  }
+  removeMainPageSessionKeys(keys) {
+    return this.sessionStore ? this.sessionStore.removeMainPageSessionKeys(keys) : [];
+  }
+  ensureAgentSessionRecord(agent, patch = {}) {
+    return this.sessionStore ? this.sessionStore.ensureRecordForAgent(agent, { ...patch }) : "";
+  }
+  getAgentSessionRecordForProviderSessionKey(sessionKey) {
+    const record = this.sessionStore ? this.sessionStore.getRecordForProviderSessionKey(sessionKey) : null;
+    return record && typeof record.id === "string" ? { ...record, id: record.id } : null;
+  }
+  setProviderSessionDisplayState(sessionKey, patch = {}) {
+    return this.sessionStore ? this.sessionStore.setProviderSessionDisplayState(sessionKey, { ...patch }) : "";
+  }
+  listAgentSessionRecords() {
+    const records = this.sessionStore ? this.sessionStore.listAgentRecords() : [];
+    return records.flatMap((record) => typeof record.id === "string" ? [{ ...record, id: record.id }] : []);
+  }
+  rememberAgentSessionRecord(agent) {
+    return this.sessionStore ? this.sessionStore.rememberAgent(agent) : "";
+  }
+  getTaskHistory() {
+    return this.runHistoryStore ? this.runHistoryStore.getEntries() : [];
+  }
+  writeSettingsFile(settings = this.settings) {
+    this.writeJson(this.settingsFile, settings);
+  }
+  appendTaskHistory(entry) {
+    if (!this.runHistoryStore) return;
+    this.runHistoryStore.appendEntry(entry);
+  }
+  updateSettings(newSettings) {
+    const incomingMainPageSessionKeys = Object.prototype.hasOwnProperty.call(newSettings || {}, "mainPageSessionKeys") ? newSettings.mainPageSessionKeys : void 0;
+    const settingsPatch = { ...newSettings || {} };
+    delete settingsPatch.mainPageSessionKeys;
+    delete settingsPatch.projectOperations;
+    const incomingTaskHistory = Object.prototype.hasOwnProperty.call(settingsPatch, "taskHistory") ? settingsPatch.taskHistory : void 0;
+    delete settingsPatch.taskHistory;
+    const previousMainWorkspace = this.settings.lastMainWorkspace || this.farmingDir;
+    const previousProfiles = this.settings.agentLaunchProfiles || {};
+    const incomingProfiles = settingsPatch.agentLaunchProfiles || {};
+    const nextSettings = {
+      ...this.settings,
+      ...settingsPatch,
+      agentLaunchProfiles: this.mergeAgentLaunchProfiles(previousProfiles, incomingProfiles),
+      workspace: this.farmingDir
+    };
+    nextSettings.lastMainWorkspace = this.normalizeMainWorkspace(nextSettings.lastMainWorkspace, previousMainWorkspace);
+    nextSettings.workspaceHistory = this.normalizeWorkspaceHistory(nextSettings.workspaceHistory);
+    nextSettings.projectWorkspaces = this.normalizeProjectWorkspaces(nextSettings.projectWorkspaces);
+    nextSettings.pinnedProjectWorkspaces = this.normalizeProjectWorkspaces(nextSettings.pinnedProjectWorkspaces);
+    nextSettings.projectNames = this.normalizeProjectNames(nextSettings.projectNames);
+    nextSettings.projectOperations = this.normalizeProjectOperations(nextSettings.projectOperations);
+    nextSettings.instanceName = this.normalizeInstanceName(nextSettings.instanceName);
+    nextSettings.agentHomes = this.normalizeAgentHomes(nextSettings.agentHomes);
+    this.assertAgentHomeBindings(nextSettings.agentHomes);
+    delete nextSettings.updateUrl;
+    nextSettings.searchTimeoutMs = this.normalizeSearchTimeoutMs(nextSettings.searchTimeoutMs);
+    delete nextSettings.codexRuntimeMode;
+    delete nextSettings.mainPageSessionKeys;
+    delete nextSettings.taskHistory;
+    if (incomingMainPageSessionKeys !== void 0) {
+      this.setMainPageSessionKeys(incomingMainPageSessionKeys);
+    }
+    if (incomingTaskHistory !== void 0 && this.runHistoryStore) {
+      this.runHistoryStore.setEntries(incomingTaskHistory);
+    }
+    nextSettings.appearance = this.normalizeAppearance(nextSettings.appearance);
+    nextSettings.language = this.normalizeLanguage(nextSettings.language);
+    nextSettings.restReminderIntervalSeconds = this.normalizeRestReminderIntervalSeconds(
+      nextSettings.restReminderIntervalSeconds
+    );
+    nextSettings.browserExtensionEnabled = nextSettings.browserExtensionEnabled === true;
+    nextSettings.browserSource = this.normalizeBrowserSource(nextSettings.browserSource);
+    nextSettings.browserExecutablePath = this.normalizeBrowserSetting(nextSettings.browserExecutablePath);
+    nextSettings.browserExternalCdpUrl = this.normalizeBrowserSetting(nextSettings.browserExternalCdpUrl) || "http://127.0.0.1:9222";
+    nextSettings.computerExtensionEnabled = nextSettings.computerExtensionEnabled === true;
+    if (nextSettings.browserExtensionEnabled && nextSettings.browserSource === "isolated") {
+      nextSettings.computerExtensionEnabled = true;
+    }
+    nextSettings.computerCompatibilityMode = nextSettings.computerCompatibilityMode === true;
+    nextSettings.computerImage = this.normalizeBrowserSetting(nextSettings.computerImage) || import_computer_constants.COMPUTER_IMAGE;
+    nextSettings.codeContentFontSize = this.normalizeContentFontSize(
+      nextSettings.codeContentFontSize,
+      DEFAULT_CODE_CONTENT_FONT_SIZE
+    );
+    nextSettings.composerFollowUpBehavior = this.normalizeComposerFollowUpBehavior(
+      nextSettings.composerFollowUpBehavior
+    );
+    nextSettings.crtContentFontSize = this.normalizeContentFontSize(
+      Object.prototype.hasOwnProperty.call(settingsPatch, "crtContentFontSize") ? settingsPatch.crtContentFontSize : Object.prototype.hasOwnProperty.call(settingsPatch, "crtTerminalFontSize") ? Number(settingsPatch.crtTerminalFontSize) - 1 : nextSettings.crtContentFontSize,
+      DEFAULT_CRT_CONTENT_FONT_SIZE
+    );
+    nextSettings.crtSkinEffectsEnabled = nextSettings.crtSkinEffectsEnabled !== false;
+    nextSettings.crtDynamicHeatEnabled = nextSettings.crtDynamicHeatEnabled === true;
+    nextSettings.crtTerminalFontSize = this.crtTerminalFontSizeFromContent(nextSettings.crtContentFontSize);
+    this.normalizeAgentLaunchSettings(settingsPatch, nextSettings);
+    this.pruneUnknownSettings(nextSettings);
+    this.writeSettingsFile(nextSettings);
+    this.settings = nextSettings;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigManager,
+  DEFAULT_CODE_CONTENT_FONT_SIZE,
+  DEFAULT_CRT_CONTENT_FONT_SIZE,
+  DEFAULT_CRT_TERMINAL_FONT_SIZE,
+  DEFAULT_SEARCH_TIMEOUT_MS,
+  MAX_CONTENT_FONT_SIZE,
+  MAX_CRT_TERMINAL_FONT_SIZE,
+  MIN_CONTENT_FONT_SIZE,
+  MIN_CRT_TERMINAL_FONT_SIZE
+});