agentinit 1.22.1 → 1.24.0

package/dist/cli.js

@@ -15070,7 +15070,7 @@ class CodexCliAgent extends Agent {
           sse: false
         },
         rules: true,
-        hooks: false,
+        hooks: true,
         commands: false,
         subagents: false,
         statusline: false,
@@ -16888,6 +16888,13 @@ function createDefaultUserConfig() {
     verifiedGithubRepos: []
   };
 }
+function normalizeAgentSettingsDefaultScope(scope) {
+  const normalized = scope.trim().toLowerCase();
+  if (!AGENT_SETTINGS_SCOPES.has(normalized)) {
+    throw new Error("Invalid agent settings default scope. Use global, project, or local.");
+  }
+  return normalized;
+}
 function normalizeMarketplaceIdentifier(identifier) {
   const normalized = identifier.trim().toLowerCase();
   if (!MARKETPLACE_IDENTIFIER_PATTERN.test(normalized)) {
@@ -16959,8 +16966,17 @@ function sanitizeUserConfig(raw) {
       defaultMarketplace = undefined;
     }
   }
+  let defaultAgentSettingsScope;
+  if (typeof parsed.defaultAgentSettingsScope === "string") {
+    try {
+      defaultAgentSettingsScope = normalizeAgentSettingsDefaultScope(parsed.defaultAgentSettingsScope);
+    } catch {
+      defaultAgentSettingsScope = undefined;
+    }
+  }
   return {
     ...defaultMarketplace ? { defaultMarketplace } : {},
+    ...defaultAgentSettingsScope ? { defaultAgentSettingsScope } : {},
     customMarketplaces,
     verifiedGithubRepos
   };
@@ -16993,6 +17009,19 @@ async function writeUserConfig(config) {
 function getBuiltInVerifiedGithubRepos() {
   return [...BUILTIN_VERIFIED_GITHUB_REPOS];
 }
+function getConfiguredAgentSettingsDefaultScopeSync() {
+  return readUserConfigSync().defaultAgentSettingsScope;
+}
+function getEffectiveAgentSettingsDefaultScopeSync() {
+  const envScope = process.env.AGENTINIT_AGENT_DEFAULT_SCOPE;
+  if (typeof envScope === "string") {
+    try {
+      return normalizeAgentSettingsDefaultScope(envScope);
+    } catch {
+    }
+  }
+  return getConfiguredAgentSettingsDefaultScopeSync() ?? "global";
+}
 function getEffectiveVerifiedGithubReposSync() {
   const repos = new Set(BUILTIN_VERIFIED_GITHUB_REPOS);
   for (const repo of readUserConfigSync().verifiedGithubRepos) {
@@ -17004,7 +17033,7 @@ function isVerifiedGitHubRepoSync(owner, repo) {
   const normalized = normalizeGitHubRepoRef(`${owner}/${repo}`);
   return getEffectiveVerifiedGithubReposSync().includes(normalized);
 }
-var sanitizeCustomMarketplaceConfig, MARKETPLACE_IDENTIFIER_PATTERN, GITHUB_REPO_PATTERN, GIT_REPO_URL_PATTERN, BUILTIN_VERIFIED_GITHUB_REPOS;
+var sanitizeCustomMarketplaceConfig, MARKETPLACE_IDENTIFIER_PATTERN, GITHUB_REPO_PATTERN, GIT_REPO_URL_PATTERN, BUILTIN_VERIFIED_GITHUB_REPOS, AGENT_SETTINGS_SCOPES;
 var init_userConfig = __esm(() => {
   init_fs();
   sanitizeCustomMarketplaceConfig = function(entry) {
@@ -17027,6 +17056,7 @@ var init_userConfig = __esm(() => {
   GITHUB_REPO_PATTERN = /^([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/;
   GIT_REPO_URL_PATTERN = /^(https?:\/\/|ssh:\/\/|git@).+/;
   BUILTIN_VERIFIED_GITHUB_REPOS = ["openai/codex-plugin-cc"];
+  AGENT_SETTINGS_SCOPES = new Set(["global", "project", "local"]);
 });
 
 // dist/core/marketplaceRegistry.js
@@ -27085,6 +27115,152 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports._enoent = enoent;
 });
 
+// node_modules/jsonc-parser/lib/umd/main.js
+var require_main = __commonJS((exports, module) => {
+  (function(factory) {
+    if (typeof module === "object" && typeof exports === "object") {
+      var v = factory(__require, exports);
+      if (v !== undefined)
+        module.exports = v;
+    } else if (typeof define === "function" && define.amd) {
+      define(["require", "exports", "./impl/format", "./impl/edit", "./impl/scanner", "./impl/parser"], factory);
+    }
+  })(function(require2, exports2) {
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.applyEdits = exports2.modify = exports2.format = exports2.printParseErrorCode = exports2.ParseErrorCode = exports2.stripComments = exports2.visit = exports2.getNodeValue = exports2.getNodePath = exports2.findNodeAtOffset = exports2.findNodeAtLocation = exports2.parseTree = exports2.parse = exports2.getLocation = exports2.SyntaxKind = exports2.ScanError = exports2.createScanner = undefined;
+    const formatter = require2("./impl/format");
+    const edit = require2("./impl/edit");
+    const scanner = require2("./impl/scanner");
+    const parser = require2("./impl/parser");
+    exports2.createScanner = scanner.createScanner;
+    var ScanError;
+    (function(ScanError2) {
+      ScanError2[ScanError2["None"] = 0] = "None";
+      ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+      ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+      ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+      ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+      ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+      ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+    })(ScanError || (exports2.ScanError = ScanError = {}));
+    var SyntaxKind;
+    (function(SyntaxKind2) {
+      SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+      SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+      SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+      SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+      SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+      SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+      SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+      SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+      SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+      SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+      SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+      SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+      SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+      SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+      SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+      SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+      SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+    })(SyntaxKind || (exports2.SyntaxKind = SyntaxKind = {}));
+    exports2.getLocation = parser.getLocation;
+    exports2.parse = parser.parse;
+    exports2.parseTree = parser.parseTree;
+    exports2.findNodeAtLocation = parser.findNodeAtLocation;
+    exports2.findNodeAtOffset = parser.findNodeAtOffset;
+    exports2.getNodePath = parser.getNodePath;
+    exports2.getNodeValue = parser.getNodeValue;
+    exports2.visit = parser.visit;
+    exports2.stripComments = parser.stripComments;
+    var ParseErrorCode;
+    (function(ParseErrorCode2) {
+      ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+      ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+      ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+      ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+      ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+      ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+      ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+      ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+      ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+      ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+      ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+      ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+      ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+      ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+    })(ParseErrorCode || (exports2.ParseErrorCode = ParseErrorCode = {}));
+    function printParseErrorCode(code) {
+      switch (code) {
+        case 1:
+          return "InvalidSymbol";
+        case 2:
+          return "InvalidNumberFormat";
+        case 3:
+          return "PropertyNameExpected";
+        case 4:
+          return "ValueExpected";
+        case 5:
+          return "ColonExpected";
+        case 6:
+          return "CommaExpected";
+        case 7:
+          return "CloseBraceExpected";
+        case 8:
+          return "CloseBracketExpected";
+        case 9:
+          return "EndOfFileExpected";
+        case 10:
+          return "InvalidCommentToken";
+        case 11:
+          return "UnexpectedEndOfComment";
+        case 12:
+          return "UnexpectedEndOfString";
+        case 13:
+          return "UnexpectedEndOfNumber";
+        case 14:
+          return "InvalidUnicode";
+        case 15:
+          return "InvalidEscapeCharacter";
+        case 16:
+          return "InvalidCharacter";
+      }
+      return "<unknown ParseErrorCode>";
+    }
+    exports2.printParseErrorCode = printParseErrorCode;
+    function format(documentText, range, options2) {
+      return formatter.format(documentText, range, options2);
+    }
+    exports2.format = format;
+    function modify(text, path, value, options2) {
+      return edit.setProperty(text, path, value, options2);
+    }
+    exports2.modify = modify;
+    function applyEdits(text, edits) {
+      let sortedEdits = edits.slice(0).sort((a, b) => {
+        const diff = a.offset - b.offset;
+        if (diff === 0) {
+          return a.length - b.length;
+        }
+        return diff;
+      });
+      let lastModifiedOffset = text.length;
+      for (let i = sortedEdits.length - 1;i >= 0; i--) {
+        let e = sortedEdits[i];
+        if (e.offset + e.length <= lastModifiedOffset) {
+          text = edit.applyEdit(text, e);
+        } else {
+          throw new Error("Overlapping edit");
+        }
+        lastModifiedOffset = e.offset;
+      }
+      return text;
+    }
+    exports2.applyEdits = applyEdits;
+  });
+});
+
 // node_modules/commander/esm.mjs
 var import_ = __toESM(require_commander(), 1);
 var {
@@ -42094,6 +42270,49 @@ function registerConfigCommand(program2) {
     await writeUserConfig(sortConfig(configState));
     logger.success("Cleared the configured default marketplace.");
   });
+  const agentSettings = config.command("agent-settings").description("Manage AgentInit defaults for agent settings commands");
+  agentSettings.command("scope [scope]").description("Get or set the default scope used by `agentinit agent` when no scope flag is provided").action(async (scopeArg) => {
+    logger.titleBox("AgentInit  Configuration");
+    try {
+      if (!scopeArg) {
+        const configState2 = await readUserConfig();
+        const configuredScope = configState2.defaultAgentSettingsScope;
+        const effectiveScope = getEffectiveAgentSettingsDefaultScopeSync();
+        logger.info(`Effective default agent settings scope: ${cyan(effectiveScope)}`);
+        if (configuredScope) {
+          logger.info(`Configured in user config: ${cyan(configuredScope)}`);
+        } else {
+          logger.info("No user-configured agent settings scope. Built-in default is global.");
+        }
+        if (process.env.AGENTINIT_AGENT_DEFAULT_SCOPE !== undefined) {
+          try {
+            logger.info(`Environment override: ${cyan(normalizeAgentSettingsDefaultScope(process.env.AGENTINIT_AGENT_DEFAULT_SCOPE))}`);
+          } catch {
+            logger.info(`Invalid environment override ignored: ${cyan(process.env.AGENTINIT_AGENT_DEFAULT_SCOPE)}`);
+          }
+        }
+        return;
+      }
+      const scope = normalizeAgentSettingsDefaultScope(scopeArg);
+      const configState = await readUserConfig();
+      configState.defaultAgentSettingsScope = scope;
+      await writeUserConfig(sortConfig(configState));
+      logger.success(`Set default agent settings scope to ${green(scope)}.`);
+    } catch (error) {
+      failConfigCommand(error);
+    }
+  });
+  agentSettings.command("clear-scope").description("Clear the user-configured default scope used by `agentinit agent`").action(async () => {
+    logger.titleBox("AgentInit  Configuration");
+    const configState = await readUserConfig();
+    if (!configState.defaultAgentSettingsScope) {
+      logger.info("No user-configured agent settings scope to clear.");
+      return;
+    }
+    delete configState.defaultAgentSettingsScope;
+    await writeUserConfig(sortConfig(configState));
+    logger.success("Cleared the user-configured default agent settings scope.");
+  });
   const verifiedRepos = config.command("verified-repos").description("Manage exact verified GitHub repositories");
   verifiedRepos.command("list").description("List verified GitHub repositories").action(async () => {
     logger.titleBox("AgentInit  Configuration");
@@ -45137,6 +45356,1531 @@ Dry run \u2014 no changes made.`));
   });
 }
 
+// dist/core/agentSettings/settingsManager.js
+var TOML4 = __toESM(require_toml(), 1);
+var import_jsonc_parser = __toESM(require_main(), 1);
+init_fs();
+init_userConfig();
+
+// dist/core/agentSettings/valueParser.js
+var parseJsonValue = function(raw, key) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Value for "${key}" is not valid JSON.`);
+  }
+};
+function parseAgentSettingValue(definition, raw, parseJson = false) {
+  switch (definition.valueType) {
+    case "string":
+      return raw;
+    case "boolean": {
+      const normalized = raw.trim().toLowerCase();
+      if (TRUE_VALUES.has(normalized)) {
+        return true;
+      }
+      if (FALSE_VALUES.has(normalized)) {
+        return false;
+      }
+      throw new Error(`Value for "${definition.key}" must be one of: on, off, true, false, yes, no, 1, 0.`);
+    }
+    case "number": {
+      const value = Number(raw);
+      if (!Number.isFinite(value)) {
+        throw new Error(`Value for "${definition.key}" must be a finite number.`);
+      }
+      return value;
+    }
+    case "positiveInteger": {
+      const value = Number(raw);
+      if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`Value for "${definition.key}" must be a positive integer.`);
+      }
+      return value;
+    }
+    case "enum": {
+      if (!definition.allowedValues?.includes(raw)) {
+        throw new Error(`Value for "${definition.key}" must be one of: ${definition.allowedValues?.join(", ")}.`);
+      }
+      return raw;
+    }
+    case "booleanOrEnum": {
+      const normalized = raw.trim().toLowerCase();
+      if (TRUE_VALUES.has(normalized)) {
+        return true;
+      }
+      if (FALSE_VALUES.has(normalized)) {
+        return false;
+      }
+      if (definition.allowedValues?.includes(raw)) {
+        return raw;
+      }
+      throw new Error(`Value for "${definition.key}" must be one of: on, off, true, false, yes, no, 1, 0, ${definition.allowedValues?.join(", ")}.`);
+    }
+    case "array": {
+      if (parseJson) {
+        const value = parseJsonValue(raw, definition.key);
+        if (!Array.isArray(value)) {
+          throw new Error(`JSON value for "${definition.key}" must be an array.`);
+        }
+        return value;
+      }
+      return [raw];
+    }
+    case "object": {
+      if (!parseJson) {
+        throw new Error(`Value for "${definition.key}" must be valid JSON. Use --value-json when setting it from the CLI.`);
+      }
+      const value = parseJsonValue(raw, definition.key);
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`JSON value for "${definition.key}" must be an object.`);
+      }
+      return value;
+    }
+  }
+}
+var TRUE_VALUES = new Set(["true", "on", "yes", "1"]);
+var FALSE_VALUES = new Set(["false", "off", "no", "0"]);
+
+// dist/core/agentSettings/adapters/claude.js
+init_paths();
+import {join as join12} from "path";
+var setting = function(key, valueType, title, description, options2 = {}) {
+  const definition = {
+    agent: "claude",
+    key,
+    nativePath: key.split("."),
+    title,
+    description,
+    valueType,
+    scopes: options2.scopes ?? ALL_SCOPES,
+    defaultScope: options2.defaultScope ?? "global",
+    category: options2.category ?? "settings",
+    risk: options2.risk ?? "safe"
+  };
+  if (options2.allowedValues) {
+    definition.allowedValues = options2.allowedValues;
+  }
+  if (options2.store) {
+    definition.store = options2.store;
+  }
+  if (options2.deprecated !== undefined) {
+    definition.deprecated = options2.deprecated;
+  }
+  if (options2.replacement) {
+    definition.replacement = options2.replacement;
+  }
+  return definition;
+};
+var globalConfigSetting = function(key, valueType, title, description, options2 = {}) {
+  return setting(key, valueType, title, description, {
+    ...options2,
+    scopes: GLOBAL_CONFIG_SCOPES,
+    defaultScope: "global",
+    store: "globalConfig"
+  });
+};
+var ALL_SCOPES = ["global", "project", "local"];
+var PERSONAL_SCOPES = ["global", "local"];
+var GLOBAL_CONFIG_SCOPES = ["global"];
+var CLAUDE_HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "Notification",
+  "PermissionRequest",
+  "Stop",
+  "SessionStart",
+  "SessionEnd"
+];
+var THEME_VALUES = ["auto", "dark", "light", "light-daltonized", "dark-daltonized", "light-ansi", "dark-ansi"];
+var NOTIFICATION_CHANNELS = ["auto", "iterm2", "iterm2_with_bell", "terminal_bell", "kitty", "ghostty", "notifications_disabled"];
+var TEAMMATE_MODES = ["auto", "tmux", "in-process"];
+var claudeSettingsAdapter = {
+  agent: "claude",
+  displayName: "Claude Code",
+  hookEvents: CLAUDE_HOOK_EVENTS,
+  hookScopes: ALL_SCOPES,
+  definitions: [
+    globalConfigSetting("theme", "enum", "Theme", "Claude Code UI color theme.", {
+      allowedValues: THEME_VALUES,
+      category: "ui"
+    }),
+    globalConfigSetting("editorMode", "enum", "Editor mode", "Keyboard editing mode.", {
+      allowedValues: ["normal", "vim"],
+      category: "ui"
+    }),
+    globalConfigSetting("verbose", "boolean", "Verbose output", "Show detailed debug output.", {
+      category: "runtime"
+    }),
+    globalConfigSetting("preferredNotifChannel", "enum", "Notification channel", "Preferred local notification delivery method.", {
+      allowedValues: NOTIFICATION_CHANNELS,
+      category: "notifications"
+    }),
+    globalConfigSetting("autoCompactEnabled", "boolean", "Auto compact", "Auto-compact conversation context when it gets full.", {
+      category: "runtime"
+    }),
+    globalConfigSetting("fileCheckpointingEnabled", "boolean", "File checkpointing", "Enable code rewind checkpoint snapshots.", {
+      category: "runtime"
+    }),
+    globalConfigSetting("showTurnDuration", "boolean", "Turn duration", "Show how long Claude spent on each turn.", {
+      category: "ui"
+    }),
+    globalConfigSetting("terminalProgressBarEnabled", "boolean", "Terminal progress bar", "Show terminal progress in supported terminals.", {
+      category: "ui"
+    }),
+    globalConfigSetting("todoFeatureEnabled", "boolean", "Todo feature", "Enable Claude todo and task tracking.", {
+      category: "ui"
+    }),
+    globalConfigSetting("teammateMode", "enum", "Teammate mode", "Control how Claude spawns teammate agents.", {
+      allowedValues: TEAMMATE_MODES,
+      category: "agents"
+    }),
+    globalConfigSetting("autoConnectIde", "boolean", "Auto-connect IDE", "Auto-connect to an IDE from external terminals.", {
+      category: "ide"
+    }),
+    globalConfigSetting("autoInstallIdeExtension", "boolean", "Auto-install IDE extension", "Auto-install the IDE extension when supported.", {
+      category: "ide"
+    }),
+    globalConfigSetting("diffTool", "enum", "Diff tool", "Choose where diffs are shown.", {
+      allowedValues: ["terminal", "auto"],
+      category: "ide"
+    }),
+    globalConfigSetting("respectGitignore", "boolean", "Respect gitignore", "Hide gitignored files from Claude file pickers.", {
+      category: "ui"
+    }),
+    globalConfigSetting("copyFullResponse", "boolean", "Copy full response", "Copy full responses without the copy picker flow.", {
+      category: "ui"
+    }),
+    globalConfigSetting("copyOnSelect", "boolean", "Copy on select", "Copy selected text automatically in fullscreen mode.", {
+      category: "ui"
+    }),
+    globalConfigSetting("remoteControlAtStartup", "boolean", "Remote control at startup", "Enable Remote Control for new Claude sessions. Unset to restore Claude defaults.", {
+      category: "remote-control"
+    }),
+    globalConfigSetting("taskCompleteNotifEnabled", "boolean", "Task complete push notifications", "Push when Claude finishes and becomes idle.", {
+      category: "notifications"
+    }),
+    globalConfigSetting("inputNeededNotifEnabled", "boolean", "Input needed push notifications", "Push when Claude needs user input.", {
+      category: "notifications"
+    }),
+    globalConfigSetting("agentPushNotifEnabled", "boolean", "Agent push notifications", "Allow Claude to decide when to send push notifications.", {
+      category: "notifications"
+    }),
+    globalConfigSetting("showStatusInTerminalTab", "boolean", "Terminal tab status", "Show Claude status in the terminal tab status area.", {
+      category: "ui"
+    }),
+    globalConfigSetting("prStatusFooterEnabled", "boolean", "PR status footer", "Show pull request status in Claude footer.", {
+      category: "git"
+    }),
+    globalConfigSetting("claudeInChromeDefaultEnabled", "boolean", "Claude in Chrome default", "Enable Claude in Chrome by default.", {
+      category: "browser"
+    }),
+    globalConfigSetting("teammateDefaultModel", "string", "Teammate default model", "Default model for spawned teammate agents.", {
+      category: "agents"
+    }),
+    setting("model", "string", "Model", "Override the default Claude Code model.", {
+      defaultScope: "global",
+      category: "model"
+    }),
+    setting("agent", "string", "Agent", "Run the main thread as a named Claude subagent.", {
+      category: "model"
+    }),
+    setting("env", "object", "Environment", "Environment variables applied to every Claude Code session.", {
+      category: "runtime"
+    }),
+    setting("permissions.allow", "array", "Allowed permissions", "Permission rules to allow.", {
+      category: "permissions"
+    }),
+    setting("permissions.deny", "array", "Denied permissions", "Permission rules to deny.", {
+      category: "permissions"
+    }),
+    setting("permissions.ask", "array", "Ask permissions", "Permission rules that require confirmation.", {
+      category: "permissions"
+    }),
+    setting("permissions.defaultMode", "enum", "Default permission mode", "Default permission mode when opening Claude Code.", {
+      allowedValues: ["default", "acceptEdits", "plan", "dontAsk"],
+      category: "permissions",
+      risk: "security-sensitive"
+    }),
+    setting("permissions.disableBypassPermissionsMode", "enum", "Disable bypass permissions mode", "Disable Claude bypass-permissions mode.", {
+      allowedValues: ["disable"],
+      category: "permissions",
+      risk: "security-sensitive"
+    }),
+    setting("permissions.additionalDirectories", "array", "Additional directories", "Additional working directories for file access.", {
+      category: "permissions"
+    }),
+    setting("worktree.symlinkDirectories", "array", "Worktree symlink directories", "Directories to symlink into Claude Code worktrees.", {
+      category: "worktree"
+    }),
+    setting("worktree.sparsePaths", "array", "Worktree sparse paths", "Paths to check out via sparse checkout in Claude Code worktrees.", {
+      category: "worktree"
+    }),
+    setting("plansDirectory", "string", "Plans directory", "Directory where Claude Code stores plan files.", {
+      category: "runtime"
+    }),
+    setting("autoMemoryDirectory", "string", "Auto memory directory", "Custom directory for Claude Code auto memory storage.", {
+      scopes: PERSONAL_SCOPES,
+      defaultScope: "global",
+      category: "memory"
+    }),
+    setting("autoMemoryEnabled", "boolean", "Auto memory", "Enable automatic memory capture.", {
+      defaultScope: "global",
+      category: "memory"
+    }),
+    setting("autoDreamEnabled", "boolean", "Auto dream", "Enable background memory consolidation.", {
+      defaultScope: "global",
+      category: "memory"
+    }),
+    setting("alwaysThinkingEnabled", "boolean", "Always thinking", "Enable extended thinking by default for Claude Code sessions.", {
+      defaultScope: "global",
+      category: "model"
+    }),
+    setting("effortLevel", "enum", "Effort level", "Persist Claude Code effort level across sessions.", {
+      allowedValues: ["low", "medium", "high", "xhigh"],
+      defaultScope: "global",
+      category: "model"
+    }),
+    setting("prefersReducedMotion", "boolean", "Reduced motion", "Reduce or disable Claude Code UI animations.", {
+      defaultScope: "global",
+      category: "ui"
+    }),
+    setting("attribution", "object", "Attribution", "Customize Claude Code git commit and pull request attribution.", {
+      defaultScope: "global",
+      category: "git"
+    }),
+    setting("includeGitInstructions", "boolean", "Git instructions", "Include built-in git workflow instructions in Claude Code context.", {
+      defaultScope: "global",
+      category: "git"
+    }),
+    setting("cleanupPeriodDays", "number", "Cleanup period", "Delete session files older than this many days at startup.", {
+      defaultScope: "global",
+      category: "runtime"
+    }),
+    setting("showThinkingSummaries", "boolean", "Thinking summaries", "Show extended thinking summaries in interactive sessions.", {
+      defaultScope: "global",
+      category: "ui"
+    }),
+    setting("spinnerTipsEnabled", "boolean", "Spinner tips", "Show or hide tips while Claude Code is working.", {
+      defaultScope: "global",
+      category: "ui"
+    }),
+    setting("autoUpdatesChannel", "enum", "Auto updates channel", "Claude Code release channel for automatic updates.", {
+      allowedValues: ["stable", "latest"],
+      defaultScope: "global",
+      category: "runtime"
+    }),
+    setting("language", "string", "Language", "Preferred language for Claude responses and voice dictation.", {
+      defaultScope: "global",
+      category: "ui"
+    }),
+    setting("outputStyle", "string", "Output style", "Claude response output style.", {
+      defaultScope: "global",
+      category: "ui"
+    }),
+    setting("defaultView", "enum", "Default view", "Default Claude view. Unset to restore Claude defaults.", {
+      allowedValues: ["transcript", "chat"],
+      category: "ui"
+    }),
+    setting("useAutoModeDuringPlan", "boolean", "Use auto mode during plan", "Allow auto permission mode during plan mode.", {
+      scopes: PERSONAL_SCOPES,
+      defaultScope: "global",
+      category: "permissions",
+      risk: "security-sensitive"
+    }),
+    setting("includeCoAuthoredBy", "boolean", "Include co-authored-by", "Deprecated Claude Code attribution toggle.", {
+      defaultScope: "global",
+      category: "git",
+      risk: "deprecated",
+      deprecated: true,
+      replacement: "attribution"
+    }),
+    setting("enableAllProjectMcpServers", "boolean", "Enable all project MCP servers", "Automatically approve project .mcp.json servers.", {
+      category: "mcp",
+      risk: "security-sensitive"
+    }),
+    setting("enabledMcpjsonServers", "array", "Enabled MCP JSON servers", "Specific project .mcp.json servers to approve.", {
+      category: "mcp"
+    }),
+    setting("disabledMcpjsonServers", "array", "Disabled MCP JSON servers", "Specific project .mcp.json servers to reject.", {
+      category: "mcp"
+    }),
+    setting("skipDangerousModePermissionPrompt", "boolean", "Skip dangerous mode prompt", "Skip confirmation before bypass permissions mode.", {
+      scopes: PERSONAL_SCOPES,
+      defaultScope: "global",
+      category: "permissions",
+      risk: "security-sensitive"
+    })
+  ],
+  getSettingsPath(scope, projectPath, definition) {
+    if (definition?.store === "globalConfig") {
+      return expandTilde("~/.claude.json");
+    }
+    switch (scope) {
+      case "global":
+        return expandTilde("~/.claude/settings.json");
+      case "project":
+        return join12(projectPath, ".claude", "settings.json");
+      case "local":
+        return join12(projectPath, ".claude", "settings.local.json");
+    }
+  }
+};
+
+// dist/core/agentSettings/adapters/codex.js
+init_paths();
+import {join as join13} from "path";
+var setting2 = function(key, valueType, title, description, options2 = {}) {
+  const definition = {
+    agent: "codex",
+    key,
+    nativePath: key.split("."),
+    title,
+    description,
+    valueType,
+    scopes: options2.scopes ?? ALL_SCOPES2,
+    defaultScope: options2.defaultScope ?? "global",
+    category: options2.category ?? "settings",
+    risk: options2.risk ?? "safe"
+  };
+  if (options2.allowedValues) {
+    definition.allowedValues = options2.allowedValues;
+  }
+  if (options2.deprecated !== undefined) {
+    definition.deprecated = options2.deprecated;
+  }
+  if (options2.replacement) {
+    definition.replacement = options2.replacement;
+  }
+  return definition;
+};
+var featureSetting = function(key, title, description, options2 = {}) {
+  return setting2(`features.${key}`, "boolean", title, description, {
+    ...options2,
+    category: "features"
+  });
+};
+var ALL_SCOPES2 = ["global", "project"];
+var CODEX_HOOK_EVENTS = [
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "SessionStart",
+  "UserPromptSubmit",
+  "Stop"
+];
+var codexSettingsAdapter = {
+  agent: "codex",
+  displayName: "OpenAI Codex CLI",
+  format: "toml",
+  hookEvents: CODEX_HOOK_EVENTS,
+  hookScopes: ALL_SCOPES2,
+  definitions: [
+    setting2("model", "string", "Model", "Override the default Codex model.", {
+      category: "model"
+    }),
+    setting2("model_provider", "string", "Model provider", "Select a configured model provider.", {
+      category: "model"
+    }),
+    setting2("model_reasoning_effort", "enum", "Reasoning effort", "Reasoning effort for supported models.", {
+      allowedValues: ["minimal", "low", "medium", "high"],
+      category: "model"
+    }),
+    setting2("approval_policy", "enum", "Approval policy", "Control when Codex asks for approval before running commands.", {
+      allowedValues: ["untrusted", "on-failure", "on-request", "never"],
+      category: "permissions",
+      risk: "security-sensitive"
+    }),
+    setting2("sandbox_mode", "enum", "Sandbox mode", "Control Codex command sandboxing.", {
+      allowedValues: ["read-only", "workspace-write", "danger-full-access"],
+      category: "permissions",
+      risk: "security-sensitive"
+    }),
+    setting2("web_search", "enum", "Web search", "Top-level Codex web search mode.", {
+      allowedValues: ["live", "cached", "disabled"],
+      category: "tools"
+    }),
+    setting2("notify", "array", "Notifications", "Program arguments for a notification command run after agent turns.", {
+      category: "notifications"
+    }),
+    setting2("instructions", "string", "Instructions", "Additional user instructions for Codex.", {
+      category: "runtime"
+    }),
+    setting2("model_instructions_file", "string", "Model instructions file", "Path to a model instructions file for Codex.", {
+      category: "runtime"
+    }),
+    featureSetting("apps", "Apps", "Enable ChatGPT Apps/connectors support.", {
+      risk: "risky"
+    }),
+    featureSetting("codex_hooks", "Codex hooks", "Enable lifecycle hooks from hooks.json or inline [hooks]."),
+    featureSetting("fast_mode", "Fast mode", 'Enable Fast mode selection and the service_tier = "fast" path.'),
+    featureSetting("memories", "Memories", "Enable Codex Memories."),
+    featureSetting("multi_agent", "Multi-agent", "Enable subagent collaboration tools."),
+    featureSetting("personality", "Personality", "Enable personality selection controls."),
+    featureSetting("shell_snapshot", "Shell snapshot", "Snapshot your shell environment to speed up repeated commands."),
+    featureSetting("shell_tool", "Shell tool", "Enable the default shell tool."),
+    featureSetting("unified_exec", "Unified exec", "Use the unified PTY-backed exec tool."),
+    featureSetting("undo", "Undo", "Enable undo via per-turn git ghost snapshots."),
+    featureSetting("web_search", "Legacy web search feature", "Deprecated legacy web search feature toggle; prefer top-level web_search.", {
+      risk: "deprecated",
+      deprecated: true,
+      replacement: "web_search"
+    }),
+    featureSetting("web_search_cached", "Legacy cached web search", 'Deprecated legacy toggle that maps to web_search = "cached" when unset.', {
+      risk: "deprecated",
+      deprecated: true,
+      replacement: "web_search"
+    }),
+    featureSetting("web_search_request", "Legacy live web search", 'Deprecated legacy toggle that maps to web_search = "live" when unset.', {
+      risk: "deprecated",
+      deprecated: true,
+      replacement: "web_search"
+    })
+  ],
+  getSettingsPath(scope, projectPath) {
+    switch (scope) {
+      case "global":
+        return expandTilde("~/.codex/config.toml");
+      case "project":
+        return join13(projectPath, ".codex", "config.toml");
+      case "local":
+        return join13(projectPath, ".codex", "config.toml");
+    }
+  }
+};
+
+// dist/core/agentSettings/adapters/opencode.js
+init_paths();
+import {existsSync as existsSync3} from "fs";
+import {join as join14} from "path";
+var firstExistingPath = function(paths9, fallback2) {
+  return paths9.find((candidate) => existsSync3(candidate)) ?? fallback2;
+};
+var setting3 = function(key, valueType, title, description, options2 = {}) {
+  const definition = {
+    agent: "opencode",
+    key,
+    nativePath: options2.nativePath ?? key.split("."),
+    title,
+    description,
+    valueType,
+    scopes: options2.scopes ?? SUPPORTED_SCOPES,
+    defaultScope: options2.defaultScope ?? "global",
+    category: options2.category ?? "settings",
+    risk: options2.risk ?? "safe"
+  };
+  if (options2.allowedValues) {
+    definition.allowedValues = options2.allowedValues;
+  }
+  if (options2.deprecated !== undefined) {
+    definition.deprecated = options2.deprecated;
+  }
+  if (options2.replacement) {
+    definition.replacement = options2.replacement;
+  }
+  return definition;
+};
+var SUPPORTED_SCOPES = ["global", "project"];
+var PERMISSION_ACTIONS = ["allow", "ask", "deny"];
+var opencodeSettingsAdapter = {
+  agent: "opencode",
+  displayName: "OpenCode",
+  format: "jsonc",
+  definitions: [
+    setting3("model", "string", "Model", "Default model identifier in provider/model format (e.g. anthropic/claude-sonnet-4-5).", {
+      category: "model"
+    }),
+    setting3("small_model", "string", "Small model", "Small model used for tasks such as title generation, in provider/model format.", {
+      category: "model"
+    }),
+    setting3("provider", "object", "Providers", "Custom OpenCode provider configurations and model overrides.", {
+      category: "provider",
+      risk: "security-sensitive"
+    }),
+    setting3("default_agent", "string", "Default agent", "Default primary agent to use when none is specified.", {
+      category: "agent"
+    }),
+    setting3("autoupdate", "booleanOrEnum", "Auto update", "Control automatic updates: true, false, or notify.", {
+      allowedValues: ["notify"],
+      scopes: ["global"],
+      defaultScope: "global",
+      category: "runtime"
+    }),
+    setting3("shell", "string", "Shell", "Default shell to use for terminal and bash tool execution.", {
+      category: "runtime"
+    }),
+    setting3("share", "enum", "Share", "Control sharing behavior: manual, auto, or disabled.", {
+      allowedValues: ["manual", "auto", "disabled"],
+      category: "sharing"
+    }),
+    setting3("username", "string", "Username", "Custom username displayed in conversations instead of system username.", {
+      category: "ui"
+    }),
+    setting3("logLevel", "enum", "Log level", "Log verbosity level.", {
+      allowedValues: ["DEBUG", "INFO", "WARN", "ERROR"],
+      category: "runtime"
+    }),
+    setting3("snapshot", "boolean", "Snapshot tracking", "Enable or disable filesystem snapshot tracking for undo/redo.", {
+      category: "runtime"
+    }),
+    setting3("permission.*", "enum", "Default permission", "Fallback permission rule for all tools: allow, ask, or deny.", {
+      nativePath: ["permission", "*"],
+      category: "permissions",
+      risk: "security-sensitive",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.bash", "enum", "Bash permission", "Permission rule for shell command execution.", {
+      category: "permissions",
+      risk: "security-sensitive",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.read", "enum", "Read permission", "Permission rule for file reads.", {
+      category: "permissions",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.edit", "enum", "Edit permission", "Permission rule for editing and writing files.", {
+      category: "permissions",
+      risk: "risky",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.webfetch", "enum", "Web fetch permission", "Permission rule for fetching external URLs.", {
+      category: "permissions",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.task", "enum", "Task permission", "Permission rule for spawning subagent tasks.", {
+      category: "permissions",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("permission.websearch", "enum", "Web search permission", "Permission rule for web search operations.", {
+      category: "permissions",
+      allowedValues: PERMISSION_ACTIONS
+    }),
+    setting3("compaction.auto", "boolean", "Auto compaction", "Enable automatic context compaction when context is full.", {
+      category: "compaction"
+    }),
+    setting3("tool_output.max_lines", "positiveInteger", "Tool output max lines", "Maximum lines of tool output before truncation.", {
+      category: "output"
+    }),
+    setting3("tool_output.max_bytes", "positiveInteger", "Tool output max bytes", "Maximum bytes of tool output before truncation.", {
+      category: "output"
+    })
+  ],
+  getSettingsPath(scope, projectPath) {
+    switch (scope) {
+      case "global":
+        return firstExistingPath([
+          expandTilde("~/.config/opencode/opencode.jsonc"),
+          expandTilde("~/.config/opencode/opencode.json"),
+          expandTilde("~/.config/opencode/config.json")
+        ], expandTilde("~/.config/opencode/opencode.json"));
+      case "project":
+        return firstExistingPath([
+          join14(projectPath, ".opencode", "opencode.jsonc"),
+          join14(projectPath, ".opencode", "opencode.json")
+        ], join14(projectPath, ".opencode", "opencode.json"));
+      case "local":
+        throw new Error("OpenCode settings do not support local scope. Use --global or --project.");
+    }
+  }
+};
+
+// dist/core/agentSettings/registry.js
+function getAgentSettingsAdapters() {
+  return [...ADAPTERS];
+}
+function getAgentSettingsAdapter(agent) {
+  return ADAPTERS.find((adapter) => adapter.agent === agent);
+}
+function getAgentSettingDefinition(agent, key) {
+  return getAgentSettingsAdapter(agent)?.definitions.find((definition) => definition.key === key);
+}
+function toSchemaEntry(definition) {
+  return {
+    ...definition,
+    nativePath: definition.nativePath.join(".")
+  };
+}
+var ADAPTERS = [
+  claudeSettingsAdapter,
+  codexSettingsAdapter,
+  opencodeSettingsAdapter
+];
+
+// dist/core/agentSettings/settingsManager.js
+var assertObject = function(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} contains JSON that is not an object.`);
+  }
+  return value;
+};
+var getNestedValue = function(config, path) {
+  let current = config;
+  for (const segment of path) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return;
+    }
+    current = current[segment];
+  }
+  return current;
+};
+var setNestedValue = function(config, path, value) {
+  let current = config;
+  for (const segment of path.slice(0, -1)) {
+    const next = current[segment];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  current[path[path.length - 1]] = value;
+};
+var normalizeHookEvent = function(event) {
+  const exact = event;
+  if (HOOK_EVENTS.has(exact)) {
+    return exact;
+  }
+  const normalized = event.trim().replace(/_/g, "-").toLowerCase();
+  const mapped = HOOK_EVENT_ALIASES[normalized];
+  if (mapped) {
+    return mapped;
+  }
+  throw new Error(`Unsupported hook event: ${event}. Supported: ${[...HOOK_EVENTS].join(", ")}.`);
+};
+var assertHookMatchers = function(value) {
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("Existing hooks value is not an array.");
+  }
+  return value.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("Existing hook matcher is not an object.");
+    }
+    const entryObject = entry;
+    const matcher = entryObject.matcher;
+    const hooks = entryObject.hooks;
+    if (matcher !== undefined && typeof matcher !== "string") {
+      throw new Error("Existing hook matcher must be a string.");
+    }
+    if (!Array.isArray(hooks)) {
+      throw new Error("Existing hook commands must be an array.");
+    }
+    return {
+      ...entryObject,
+      ...matcher !== undefined ? { matcher } : {},
+      hooks: hooks.map((hook) => {
+        if (!hook || typeof hook !== "object" || Array.isArray(hook)) {
+          throw new Error("Existing hook command is not an object.");
+        }
+        const hookObject = hook;
+        const type2 = hookObject.type;
+        const command = hookObject.command;
+        const name = hookObject.name;
+        if (type2 !== undefined && typeof type2 !== "string") {
+          throw new Error("Existing hook command type must be a string when present.");
+        }
+        if (command !== undefined && typeof command !== "string") {
+          throw new Error("Existing hook command must be a string when present.");
+        }
+        if (name !== undefined && typeof name !== "string") {
+          throw new Error("Existing hook name must be a string when present.");
+        }
+        return {
+          ...hookObject,
+          ...typeof type2 === "string" ? { type: type2 } : {},
+          ...typeof command === "string" ? { command } : {},
+          ...typeof name === "string" ? { name } : {}
+        };
+      })
+    };
+  });
+};
+var getHookMatchers = function(config, event) {
+  const hooks = getNestedValue(config, ["hooks"]);
+  if (hooks === undefined) {
+    return [];
+  }
+  if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+    throw new Error("Existing hooks value is not an object.");
+  }
+  return assertHookMatchers(hooks[event]);
+};
+var setHookMatchers = function(config, event, matchers) {
+  const hooks = getNestedValue(config, ["hooks"]);
+  if (hooks !== undefined && (!hooks || typeof hooks !== "object" || Array.isArray(hooks))) {
+    throw new Error("Existing hooks value is not an object.");
+  }
+  const hooksObject = hooks;
+  const nextHooks = hooksObject ?? {};
+  if (matchers.length === 0) {
+    delete nextHooks[event];
+  } else {
+    nextHooks[event] = matchers;
+  }
+  if (Object.keys(nextHooks).length === 0) {
+    deleteNestedValue(config, ["hooks"]);
+    return;
+  }
+  setNestedValue(config, ["hooks"], nextHooks);
+};
+var buildHookCommand = function(command, name) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    throw new Error("Hook command cannot be empty.");
+  }
+  return {
+    type: "command",
+    command: trimmed,
+    ...name ? { name } : {}
+  };
+};
+var normalizeApiKeyForConfig = function(apiKey) {
+  const trimmed = apiKey.trim();
+  if (!trimmed) {
+    throw new Error("API key cannot be empty.");
+  }
+  return trimmed.slice(-20);
+};
+var getApiKeyResponses = function(config) {
+  const current = config.customApiKeyResponses;
+  if (current !== undefined && (!current || typeof current !== "object" || Array.isArray(current))) {
+    throw new Error("Existing customApiKeyResponses value is not an object.");
+  }
+  const responses = current ?? {};
+  const approved = responses.approved ?? [];
+  const rejected = responses.rejected ?? [];
+  if (!Array.isArray(approved) || !approved.every((value) => typeof value === "string")) {
+    throw new Error("Existing customApiKeyResponses.approved value must be an array of strings.");
+  }
+  if (!Array.isArray(rejected) || !rejected.every((value) => typeof value === "string")) {
+    throw new Error("Existing customApiKeyResponses.rejected value must be an array of strings.");
+  }
+  return {
+    approved,
+    rejected
+  };
+};
+var getApiKeyStatusFromResponses = function(responses, fingerprint) {
+  if (responses.approved.includes(fingerprint)) {
+    return "approved";
+  }
+  if (responses.rejected.includes(fingerprint)) {
+    return "rejected";
+  }
+  return "unknown";
+};
+var setApiKeyResponses = function(config, approved, rejected) {
+  config.customApiKeyResponses = {
+    ...config.customApiKeyResponses && typeof config.customApiKeyResponses === "object" && !Array.isArray(config.customApiKeyResponses) ? config.customApiKeyResponses : {},
+    approved,
+    rejected
+  };
+};
+var deleteNestedValue = function(config, path) {
+  const parents = [];
+  let current = config;
+  for (const segment of path.slice(0, -1)) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return false;
+    }
+    parents.push({ object: current, key: segment });
+    current = current[segment];
+  }
+  if (!current || typeof current !== "object" || Array.isArray(current)) {
+    return false;
+  }
+  const finalKey = path[path.length - 1];
+  if (!(finalKey in current)) {
+    return false;
+  }
+  delete current[finalKey];
+  for (let i = parents.length - 1;i >= 0; i--) {
+    const { object, key } = parents[i];
+    const value = object[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+      delete object[key];
+    } else {
+      break;
+    }
+  }
+  return true;
+};
+var resolveProjectPath = function(projectPath) {
+  return projectPath ?? process.cwd();
+};
+var resolveScope = function(definition, scope) {
+  const defaultScope = getEffectiveAgentSettingsDefaultScopeSync();
+  const resolvedScope = scope ?? (definition.store === "globalConfig" && !definition.scopes.includes(defaultScope) ? definition.defaultScope : defaultScope);
+  if (!definition.scopes.includes(resolvedScope)) {
+    throw new Error(`"${definition.key}" does not support ${resolvedScope} scope. Supported scopes: ${definition.scopes.join(", ")}.`);
+  }
+  return resolvedScope;
+};
+var getSupportedSettingScopes = function(adapter) {
+  return [...new Set(adapter.definitions.flatMap((definition) => definition.scopes))];
+};
+var resolveFullReadScope = function(adapter, scope) {
+  const resolvedScope = scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+  const supportedScopes = getSupportedSettingScopes(adapter);
+  if (!supportedScopes.includes(resolvedScope)) {
+    throw new Error(`Agent ${adapter.agent} settings do not support ${resolvedScope} scope. Supported scopes: ${supportedScopes.join(", ")}.`);
+  }
+  return resolvedScope;
+};
+async function readConfigObject(adapter, path) {
+  const content = await readFileIfExists(path);
+  if (!content) {
+    return {};
+  }
+  if (adapter.format === "toml") {
+    try {
+      return assertObject(TOML4.parse(content), path);
+    } catch (error) {
+      if (error instanceof SyntaxError || error instanceof Error) {
+        throw new Error(`${path} contains invalid TOML.`);
+      }
+      throw error;
+    }
+  }
+  try {
+    const errors5 = [];
+    const value = adapter.format === "jsonc" ? import_jsonc_parser.parse(content, errors5, { allowTrailingComma: true }) : JSON.parse(content);
+    if (errors5.length > 0) {
+      throw new SyntaxError("Invalid JSONC");
+    }
+    return assertObject(value, path);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`${path} contains invalid ${adapter.format === "jsonc" ? "JSONC" : "JSON"}.`);
+    }
+    throw error;
+  }
+}
+var stringifyConfigObject = function(adapter, config) {
+  if (adapter.format === "toml") {
+    return TOML4.stringify(config);
+  }
+  return `${JSON.stringify(config, null, 2)}\n`;
+};
+async function writeConfigObject(adapter, path, config) {
+  await writeFile(path, stringifyConfigObject(adapter, config));
+}
+var assertHookEventSupported = function(adapter, event) {
+  if (adapter.hookEvents && !adapter.hookEvents.includes(event)) {
+    throw new Error(`Agent ${adapter.agent} does not support ${event} hooks. Supported: ${adapter.hookEvents.join(", ")}.`);
+  }
+};
+var resolveHookScope = function(adapter, scope) {
+  const resolvedScope = scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+  const supportedScopes = adapter.hookScopes ?? ["global", "project", "local"];
+  if (!supportedScopes.includes(resolvedScope)) {
+    throw new Error(`Agent ${adapter.agent} hooks do not support ${resolvedScope} scope. Supported scopes: ${supportedScopes.join(", ")}.`);
+  }
+  return resolvedScope;
+};
+var HOOK_EVENT_ALIASES = {
+  "pre-tool-use": "PreToolUse",
+  "before-tool-use": "PreToolUse",
+  "post-tool-use": "PostToolUse",
+  "after-tool-use": "PostToolUse",
+  "post-tool-use-failure": "PostToolUseFailure",
+  notification: "Notification",
+  "permission-request": "PermissionRequest",
+  stop: "Stop",
+  "session-start": "SessionStart",
+  "session-end": "SessionEnd",
+  "user-prompt-submit": "UserPromptSubmit"
+};
+var HOOK_EVENTS = new Set(Object.values(HOOK_EVENT_ALIASES));
+var CLAUDE_API_KEY_RESPONSES_DEFINITION = {
+  agent: "claude",
+  key: "customApiKeyResponses",
+  nativePath: ["customApiKeyResponses"],
+  title: "Custom API key responses",
+  description: "Remembered custom API key trust responses.",
+  valueType: "object",
+  scopes: ["global"],
+  defaultScope: "global",
+  category: "auth",
+  risk: "security-sensitive",
+  store: "globalConfig"
+};
+
+class AgentSettingsManager {
+  getSupportedAgents() {
+    return getAgentSettingsAdapters().map((adapter) => adapter.agent);
+  }
+  getSchema(agent) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    return {
+      agent: adapter.agent,
+      displayName: adapter.displayName,
+      effectiveDefaultScope: getEffectiveAgentSettingsDefaultScopeSync(),
+      settings: adapter.definitions.map(toSchemaEntry)
+    };
+  }
+  async get(agent, key, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (!key) {
+      const scope2 = resolveFullReadScope(adapter, options2.scope);
+      const path2 = adapter.getSettingsPath(scope2, resolveProjectPath(options2.projectPath));
+      const config2 = await readConfigObject(adapter, path2);
+      if (scope2 !== "global") {
+        return config2;
+      }
+      const globalConfigDefinitions = adapter.definitions.filter((definition2) => definition2.store === "globalConfig" && definition2.scopes.includes("global"));
+      if (globalConfigDefinitions.length === 0) {
+        return config2;
+      }
+      const globalConfigPath = adapter.getSettingsPath("global", resolveProjectPath(options2.projectPath), globalConfigDefinitions[0]);
+      const globalConfig = await readConfigObject(adapter, globalConfigPath);
+      const result = { ...config2 };
+      for (const definition2 of globalConfigDefinitions) {
+        const value = getNestedValue(globalConfig, definition2.nativePath);
+        if (value !== undefined) {
+          setNestedValue(result, definition2.nativePath, value);
+        }
+      }
+      return result;
+    }
+    const definition = getAgentSettingDefinition(agent, key);
+    if (!definition) {
+      throw new Error(`Unknown ${agent} setting: ${key}.`);
+    }
+    const scope = resolveScope(definition, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath), definition);
+    const config = await readConfigObject(adapter, path);
+    return getNestedValue(config, definition.nativePath);
+  }
+  async set(agent, key, rawValue, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    const definition = getAgentSettingDefinition(agent, key);
+    if (!definition) {
+      throw new Error(`Unknown ${agent} setting: ${key}.`);
+    }
+    const scope = resolveScope(definition, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath), definition);
+    const config = await readConfigObject(adapter, path);
+    const previousValue = getNestedValue(config, definition.nativePath);
+    const value = parseAgentSettingValue(definition, rawValue, options2.parseJson);
+    setNestedValue(config, definition.nativePath, value);
+    if (!options2.dryRun) {
+      await writeConfigObject(adapter, path, config);
+    }
+    return {
+      agent,
+      key,
+      scope,
+      path,
+      value,
+      previousValue,
+      dryRun: Boolean(options2.dryRun)
+    };
+  }
+  async unset(agent, key, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    const definition = getAgentSettingDefinition(agent, key);
+    if (!definition) {
+      throw new Error(`Unknown ${agent} setting: ${key}.`);
+    }
+    const scope = resolveScope(definition, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath), definition);
+    const config = await readConfigObject(adapter, path);
+    const previousValue = getNestedValue(config, definition.nativePath);
+    deleteNestedValue(config, definition.nativePath);
+    if (!options2.dryRun) {
+      await writeConfigObject(adapter, path, config);
+    }
+    return {
+      agent,
+      key,
+      scope,
+      path,
+      previousValue,
+      dryRun: Boolean(options2.dryRun)
+    };
+  }
+  async listHooks(agent, event, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (!adapter.hookEvents) {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const hookEvent = event ? normalizeHookEvent(event) : undefined;
+    if (hookEvent) {
+      assertHookEventSupported(adapter, hookEvent);
+    }
+    const scope = resolveHookScope(adapter, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readConfigObject(adapter, path);
+    if (hookEvent) {
+      return getHookMatchers(config, hookEvent);
+    }
+    const hooks = getNestedValue(config, ["hooks"]);
+    if (hooks === undefined) {
+      return {};
+    }
+    if (!hooks || typeof hooks !== "object" || Array.isArray(hooks)) {
+      throw new Error("Existing hooks value is not an object.");
+    }
+    const result = {};
+    for (const [hookEvent2, value] of Object.entries(hooks)) {
+      result[hookEvent2] = assertHookMatchers(value);
+    }
+    return result;
+  }
+  async addHook(agent, event, command, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (!adapter.hookEvents) {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const hookEvent = normalizeHookEvent(event);
+    assertHookEventSupported(adapter, hookEvent);
+    const scope = resolveHookScope(adapter, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readConfigObject(adapter, path);
+    const hook = buildHookCommand(command, options2.name);
+    const matchers = getHookMatchers(config, hookEvent);
+    const matcher = options2.matcher ?? "*";
+    const existingMatcher = matchers.find((entry) => (entry.matcher ?? "*") === matcher);
+    if (existingMatcher) {
+      existingMatcher.hooks.push(hook);
+    } else {
+      matchers.push({
+        ...matcher === "*" ? {} : { matcher },
+        hooks: [hook]
+      });
+    }
+    setHookMatchers(config, hookEvent, matchers);
+    if (!options2.dryRun) {
+      await writeConfigObject(adapter, path, config);
+    }
+    return {
+      agent,
+      event: hookEvent,
+      scope,
+      path,
+      hook,
+      dryRun: Boolean(options2.dryRun)
+    };
+  }
+  async removeHook(agent, event, commandOrName, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (!adapter.hookEvents) {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const hookEvent = normalizeHookEvent(event);
+    assertHookEventSupported(adapter, hookEvent);
+    const scope = resolveHookScope(adapter, options2.scope);
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readConfigObject(adapter, path);
+    const matchers = getHookMatchers(config, hookEvent);
+    let removed = 0;
+    const nextMatchers = matchers.map((entry) => {
+      if (options2.matcher !== undefined && (entry.matcher ?? "*") !== options2.matcher) {
+        return entry;
+      }
+      const hooks = entry.hooks.filter((hook) => {
+        const matches = hook.name === commandOrName || hook.command === commandOrName;
+        if (matches) {
+          removed++;
+        }
+        return !matches;
+      });
+      return { ...entry, hooks };
+    }).filter((entry) => entry.hooks.length > 0);
+    setHookMatchers(config, hookEvent, nextMatchers);
+    if (!options2.dryRun) {
+      await writeConfigObject(adapter, path, config);
+    }
+    return {
+      agent,
+      event: hookEvent,
+      scope,
+      path,
+      removed,
+      dryRun: Boolean(options2.dryRun)
+    };
+  }
+  async getApiKeyStatus(agent, apiKey, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (agent !== "claude") {
+      throw new Error(`Agent ${agent} does not support API key trust management.`);
+    }
+    const path = adapter.getSettingsPath("global", resolveProjectPath(options2.projectPath), CLAUDE_API_KEY_RESPONSES_DEFINITION);
+    const config = await readConfigObject(adapter, path);
+    const fingerprint = normalizeApiKeyForConfig(apiKey);
+    const responses = getApiKeyResponses(config);
+    return {
+      agent,
+      path,
+      fingerprint,
+      status: getApiKeyStatusFromResponses(responses, fingerprint),
+      dryRun: false
+    };
+  }
+  async updateApiKeyTrust(agent, action, apiKey, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    if (agent !== "claude") {
+      throw new Error(`Agent ${agent} does not support API key trust management.`);
+    }
+    const path = adapter.getSettingsPath("global", resolveProjectPath(options2.projectPath), CLAUDE_API_KEY_RESPONSES_DEFINITION);
+    const config = await readConfigObject(adapter, path);
+    const fingerprint = normalizeApiKeyForConfig(apiKey);
+    const responses = getApiKeyResponses(config);
+    const previousStatus = getApiKeyStatusFromResponses(responses, fingerprint);
+    let approved = responses.approved.filter((value) => value !== fingerprint);
+    let rejected = responses.rejected.filter((value) => value !== fingerprint);
+    if (action === "approve") {
+      approved = [...approved, fingerprint];
+    } else if (action === "reject") {
+      rejected = [...rejected, fingerprint];
+    }
+    const status = action === "approve" ? "approved" : action === "reject" ? "rejected" : "unknown";
+    setApiKeyResponses(config, approved, rejected);
+    if (!options2.dryRun) {
+      await writeConfigObject(adapter, path, config);
+    }
+    return {
+      agent,
+      path,
+      fingerprint,
+      status,
+      previousStatus,
+      dryRun: Boolean(options2.dryRun)
+    };
+  }
+}
+
+// dist/commands/agent.js
+init_logger();
+var failAgentCommand = function(error) {
+  logger.error(error instanceof Error ? error.message : "Agent settings command failed.");
+  process.exitCode = 1;
+};
+var resolveScopeOption = function(options2) {
+  const requested = [
+    options2.global ? "global" : null,
+    options2.project ? "project" : null,
+    options2.local ? "local" : null
+  ].filter(Boolean);
+  if (requested.length > 1) {
+    throw new Error("Choose only one scope: --global, --project, or --local.");
+  }
+  return requested[0];
+};
+var printJson = function(value) {
+  console.log(JSON.stringify(value === undefined ? null : value, null, 2));
+};
+var printValue = function(value) {
+  if (value === undefined) {
+    logger.info("Not set.");
+    return;
+  }
+  if (typeof value === "string") {
+    console.log(value);
+    return;
+  }
+  printJson(value);
+};
+var buildSetOptions = function(options2) {
+  const result = {};
+  const scope = resolveScopeOption(options2);
+  if (scope) {
+    result.scope = scope;
+  }
+  if (options2.valueJson !== undefined) {
+    result.parseJson = options2.valueJson;
+  }
+  if (options2.dryRun !== undefined) {
+    result.dryRun = options2.dryRun;
+  }
+  return result;
+};
+var buildReadOptions = function(options2) {
+  const result = {};
+  const scope = resolveScopeOption(options2);
+  if (scope) {
+    result.scope = scope;
+  }
+  return result;
+};
+var buildHookAddOptions = function(options2) {
+  const result = {};
+  const scope = resolveScopeOption(options2);
+  if (scope) {
+    result.scope = scope;
+  }
+  if (options2.matcher !== undefined) {
+    result.matcher = options2.matcher;
+  }
+  if (options2.name !== undefined) {
+    result.name = options2.name;
+  }
+  if (options2.dryRun !== undefined) {
+    result.dryRun = options2.dryRun;
+  }
+  return result;
+};
+var buildHookRemoveOptions = function(options2) {
+  const result = {};
+  const scope = resolveScopeOption(options2);
+  if (scope) {
+    result.scope = scope;
+  }
+  if (options2.matcher !== undefined) {
+    result.matcher = options2.matcher;
+  }
+  if (options2.dryRun !== undefined) {
+    result.dryRun = options2.dryRun;
+  }
+  return result;
+};
+var resolveApiKeyOption = function(options2) {
+  if (options2.env && options2.key) {
+    throw new Error("Choose only one API key source: --env or --key.");
+  }
+  if (options2.env) {
+    const value = process.env[options2.env];
+    if (!value) {
+      throw new Error(`Environment variable ${options2.env} is not set.`);
+    }
+    return value;
+  }
+  if (options2.key) {
+    return options2.key;
+  }
+  throw new Error("API key source is required. Use --env <name> or --key <key>.");
+};
+var warnForRawApiKeyOption = function(options2) {
+  if (options2.key && !options2.json) {
+    logger.warning("Using --key can expose the raw API key in shell history and process listings. Prefer --env when possible.");
+  }
+};
+var buildApiKeyOptions = function(options2) {
+  return {
+    dryRun: Boolean(options2.dryRun)
+  };
+};
+var apiKeyActionVerb = function(action, dryRun) {
+  if (dryRun) {
+    return `Would ${action}`;
+  }
+  switch (action) {
+    case "approve":
+      return "Approved";
+    case "reject":
+      return "Rejected";
+    case "forget":
+      return "Forgot";
+  }
+};
+function registerAgentCommand(program2) {
+  const manager = new AgentSettingsManager;
+  const agent = program2.command("agent").description("Manage native agent settings");
+  agent.command("set <agent> <key> <value...>").description("Set an agent setting").option("--global", "Write global user settings").option("--project", "Write shared project settings").option("--local", "Write local project settings").option("--value-json", "Parse the value as JSON for arrays and objects").option("--json", "Print JSON output").option("--dry-run", "Preview the write without changing files").action(async (agentId, key, valueParts, options2) => {
+    try {
+      const value = valueParts.join(" ");
+      const result = await manager.set(agentId, key, value, buildSetOptions(options2));
+      if (options2.json) {
+        printJson(result);
+        return;
+      }
+      const verb = result.dryRun ? "Would set" : "Set";
+      logger.success(`${verb} ${green(result.agent)} ${cyan(result.key)} in ${result.scope} settings.`);
+      logger.info(`Path: ${result.path}`);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  const hook = agent.command("hook").description("Manage native agent hooks with typed operations");
+  hook.command("add <agent> <event>").description("Add a command hook without replacing existing hooks").option("--command <command>", "Shell command to execute for this hook").option("--matcher <matcher>", "Claude hook matcher, defaults to all matching tools/events").option("--name <name>", "Stable name used to identify this hook later").option("--global", "Write global user settings").option("--project", "Write shared project settings").option("--local", "Write local project settings").option("--json", "Print JSON output").option("--dry-run", "Preview the write without changing files").action(async (agentId, event, options2) => {
+    try {
+      if (!options2.command) {
+        throw new Error("agent hook add requires --command <command>.");
+      }
+      const result = await manager.addHook(agentId, event, options2.command, buildHookAddOptions(options2));
+      if (options2.json) {
+        printJson(result);
+        return;
+      }
+      const verb = result.dryRun ? "Would add" : "Added";
+      logger.success(`${verb} ${green(result.agent)} ${cyan(result.event)} hook in ${result.scope} settings.`);
+      logger.info(`Path: ${result.path}`);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  hook.command("list <agent> [event]").description("List configured hooks").option("--global", "Read global user settings").option("--project", "Read shared project settings").option("--local", "Read local project settings").option("--json", "Print JSON output").action(async (agentId, event, options2) => {
+    try {
+      const hooks = await manager.listHooks(agentId, event, buildReadOptions(options2));
+      if (options2.json) {
+        printJson(hooks);
+        return;
+      }
+      logger.titleBox(`AgentInit  ${agentId} Hooks`);
+      if (Array.isArray(hooks)) {
+        hooks.forEach((entry, index) => logger.tree(`${cyan(entry.matcher ?? "*")} ${entry.hooks.map((hook2) => hook2.name ?? hook2.command ?? hook2.type ?? "hook").join(", ")}`, index === hooks.length - 1));
+        return;
+      }
+      const entries = Object.entries(hooks);
+      if (entries.length === 0) {
+        logger.info("No hooks configured.");
+        return;
+      }
+      entries.forEach(([hookEvent, matchers], index) => logger.tree(`${cyan(hookEvent)} ${matchers.length} matcher(s)`, index === entries.length - 1));
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  hook.command("remove <agent> <event> <commandOrName>").alias("rm").description("Remove hooks by command string or hook name").option("--matcher <matcher>", "Only remove hooks from this matcher").option("--global", "Write global user settings").option("--project", "Write shared project settings").option("--local", "Write local project settings").option("--json", "Print JSON output").option("--dry-run", "Preview the write without changing files").action(async (agentId, event, commandOrName, options2) => {
+    try {
+      const result = await manager.removeHook(agentId, event, commandOrName, buildHookRemoveOptions(options2));
+      if (options2.json) {
+        printJson(result);
+        return;
+      }
+      const verb = result.dryRun ? "Would remove" : "Removed";
+      logger.success(`${verb} ${result.removed ?? 0} ${green(result.agent)} ${cyan(result.event)} hook(s) from ${result.scope} settings.`);
+      logger.info(`Path: ${result.path}`);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  const apiKey = agent.command("api-key").description("Manage Claude custom API key trust responses");
+  apiKey.command("status <agent>").description("Check whether a custom API key is approved, rejected, or unknown").option("--env <name>", "Read the API key from this environment variable").option("--key <key>", "Use this API key value directly; prefer --env to avoid shell-history exposure").option("--json", "Print JSON output").action(async (agentId, options2) => {
+    try {
+      warnForRawApiKeyOption(options2);
+      const result = await manager.getApiKeyStatus(agentId, resolveApiKeyOption(options2));
+      if (options2.json) {
+        printJson(result);
+        return;
+      }
+      logger.info(`${green(result.agent)} API key fingerprint ${cyan(result.fingerprint)} is ${result.status}.`);
+      logger.info(`Path: ${result.path}`);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  for (const action of ["approve", "reject", "forget"]) {
+    apiKey.command(`${action} <agent>`).description(`${action[0].toUpperCase()}${action.slice(1)} a custom API key trust response`).option("--env <name>", "Read the API key from this environment variable").option("--key <key>", "Use this API key value directly; prefer --env to avoid shell-history exposure").option("--json", "Print JSON output").option("--dry-run", "Preview the write without changing files").action(async (agentId, options2) => {
+      try {
+        warnForRawApiKeyOption(options2);
+        const result = await manager.updateApiKeyTrust(agentId, action, resolveApiKeyOption(options2), buildApiKeyOptions(options2));
+        if (options2.json) {
+          printJson(result);
+          return;
+        }
+        logger.success(`${apiKeyActionVerb(action, result.dryRun)} ${green(result.agent)} API key fingerprint ${cyan(result.fingerprint)}.`);
+        logger.info(`Status: ${result.status}`);
+        logger.info(`Path: ${result.path}`);
+      } catch (error) {
+        failAgentCommand(error);
+      }
+    });
+  }
+  agent.command("get <agent> [key]").description("Get an agent setting or settings file").option("--global", "Read global user settings").option("--project", "Read shared project settings").option("--local", "Read local project settings").option("--json", "Print JSON output").action(async (agentId, key, options2) => {
+    try {
+      const value = await manager.get(agentId, key, buildReadOptions(options2));
+      if (options2.json) {
+        printJson(value);
+        return;
+      }
+      printValue(value);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  agent.command("unset <agent> <key>").description("Unset an agent setting").option("--global", "Write global user settings").option("--project", "Write shared project settings").option("--local", "Write local project settings").option("--json", "Print JSON output").option("--dry-run", "Preview the write without changing files").action(async (agentId, key, options2) => {
+    try {
+      const result = await manager.unset(agentId, key, buildSetOptions(options2));
+      if (options2.json) {
+        printJson(result);
+        return;
+      }
+      const verb = result.dryRun ? "Would unset" : "Unset";
+      logger.success(`${verb} ${green(result.agent)} ${cyan(result.key)} in ${result.scope} settings.`);
+      logger.info(`Path: ${result.path}`);
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  agent.command("list [agent]").description("List supported agents or setting keys for one agent").option("--json", "Print JSON output").action((agentId, options2) => {
+    try {
+      if (!agentId) {
+        const agents = manager.getSupportedAgents();
+        if (options2.json) {
+          printJson(agents);
+          return;
+        }
+        logger.titleBox("AgentInit  Agent Settings");
+        agents.forEach((entry, index) => logger.tree(cyan(entry), index === agents.length - 1));
+        return;
+      }
+      const schema2 = manager.getSchema(agentId);
+      const keys = schema2.settings.map((setting4) => setting4.key);
+      if (options2.json) {
+        printJson(keys);
+        return;
+      }
+      logger.titleBox(`AgentInit  ${agentId} Settings`);
+      schema2.settings.forEach((setting4, index) => logger.tree(`${cyan(setting4.key)} ${dim(setting4.category)}`, index === schema2.settings.length - 1));
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+  agent.command("schema <agent>").description("Show the setting schema for an agent").option("--json", "Print JSON output").action((agentId, options2) => {
+    try {
+      const schema2 = manager.getSchema(agentId);
+      if (options2.json) {
+        printJson(schema2);
+        return;
+      }
+      logger.titleBox(`AgentInit  ${schema2.displayName} Schema`);
+      logger.info(`Default omitted scope: ${cyan(schema2.effectiveDefaultScope)}`);
+      for (const setting4 of schema2.settings) {
+        const flags = [
+          setting4.valueType,
+          setting4.category,
+          setting4.risk !== "safe" ? setting4.risk : null,
+          setting4.deprecated ? `use ${setting4.replacement}` : null
+        ].filter(Boolean).join(", ");
+        logger.tree(`${cyan(setting4.key)} ${dim(`[${flags}]`)} ${setting4.description}`, false);
+      }
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+}
+
 // dist/cli.js
 init_logger();
 var program2 = new Command;
@@ -45147,6 +46891,7 @@ registerRulesCommand(program2);
 registerPluginsCommand(program2);
 registerConfigCommand(program2);
 registerLockCommand(program2);
+registerAgentCommand(program2);
 program2.command("init").description("Initialize agents.md configuration for the current project").option("-f, --force", "Overwrite existing configuration").option("-t, --template <template>", "Use specific template (web, cli, library)").action(initCommand);
 program2.command("detect").description("Detect current project stack and existing agent configurations").option("-v, --verbose", "Show detailed detection results").action(detectCommand);
 program2.command("sync").description("Sync agents.md with agent-specific configuration files").option("-a, --agent <agents...>", "Target specific agent(s)").option("-d, --dry-run", "Show what would be changed without making changes").option("-b, --backup", "Create backup before syncing").action(syncCommand);