agentinit 1.23.0 → 1.25.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,
@@ -27115,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 {
@@ -45211,6 +45357,8 @@ 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();
 
@@ -45243,12 +45391,32 @@ function parseAgentSettingValue(definition, raw, parseJson = false) {
       }
       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);
@@ -45293,6 +45461,9 @@ var setting = function(key, valueType, title, description, options2 = {}) {
   if (options2.allowedValues) {
     definition.allowedValues = options2.allowedValues;
   }
+  if (options2.store) {
+    definition.store = options2.store;
+  }
   if (options2.deprecated !== undefined) {
     definition.deprecated = options2.deprecated;
   }
@@ -45301,12 +45472,113 @@ var setting = function(key, valueType, title, description, options2 = {}) {
   }
   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"
@@ -45327,7 +45599,12 @@ var claudeSettingsAdapter = {
       category: "permissions"
     }),
     setting("permissions.defaultMode", "enum", "Default permission mode", "Default permission mode when opening Claude Code.", {
-      allowedValues: ["default", "acceptEdits", "plan"],
+      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"
     }),
@@ -45348,6 +45625,14 @@ var claudeSettingsAdapter = {
       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"
@@ -45386,6 +45671,24 @@ var claudeSettingsAdapter = {
       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",
@@ -45410,7 +45713,10 @@ var claudeSettingsAdapter = {
       risk: "security-sensitive"
     })
   ],
-  getSettingsPath(scope, projectPath) {
+  getSettingsPath(scope, projectPath, definition) {
+    if (definition?.store === "globalConfig") {
+      return expandTilde("~/.claude.json");
+    }
     switch (scope) {
       case "global":
         return expandTilde("~/.claude/settings.json");
@@ -45422,6 +45728,263 @@ var claudeSettingsAdapter = {
   }
 };
 
+// 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];
@@ -45439,7 +46002,9 @@ function toSchemaEntry(definition) {
   };
 }
 var ADAPTERS = [
-  claudeSettingsAdapter
+  claudeSettingsAdapter,
+  codexSettingsAdapter,
+  opencodeSettingsAdapter
 ];
 
 // dist/core/agentSettings/settingsManager.js
@@ -45571,6 +46136,48 @@ var buildHookCommand = function(command, name) {
     ...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;
@@ -45604,26 +46211,87 @@ var resolveProjectPath = function(projectPath) {
   return projectPath ?? process.cwd();
 };
 var resolveScope = function(definition, scope) {
-  const resolvedScope = scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+  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;
 };
-async function readJsonObject(path) {
+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 {
-    return assertObject(JSON.parse(content), path);
+    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 JSON.`);
+      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`;
+};
+var summarizeSettingValue = function(value) {
+  if (value === undefined) {
+    return "not set";
+  }
+  if (Array.isArray(value)) {
+    return `set (array, ${value.length} item${value.length === 1 ? "" : "s"})`;
+  }
+  if (value && typeof value === "object") {
+    return "set (object)";
+  }
+  return JSON.stringify(value);
+};
+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",
@@ -45634,9 +46302,23 @@ var HOOK_EVENT_ALIASES = {
   "permission-request": "PermissionRequest",
   stop: "Stop",
   "session-start": "SessionStart",
-  "session-end": "SessionEnd"
+  "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() {
@@ -45654,23 +46336,84 @@ class AgentSettingsManager {
       settings: adapter.definitions.map(toSchemaEntry)
     };
   }
+  async listSettings(agent, options2 = {}) {
+    const adapter = getAgentSettingsAdapter(agent);
+    if (!adapter) {
+      throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
+    }
+    const scope = resolveFullReadScope(adapter, options2.scope);
+    const projectPath = resolveProjectPath(options2.projectPath);
+    const configByPath = new Map;
+    const readConfigForDefinition = async (definition) => {
+      const path = adapter.getSettingsPath(scope, projectPath, definition);
+      const cached = configByPath.get(path);
+      if (cached) {
+        return cached;
+      }
+      const config = await readConfigObject(adapter, path);
+      configByPath.set(path, config);
+      return config;
+    };
+    const settings = [];
+    for (const definition of adapter.definitions) {
+      const schemaEntry = toSchemaEntry(definition);
+      if (!definition.scopes.includes(scope)) {
+        settings.push({
+          ...schemaEntry,
+          currentStatus: "not-applicable",
+          currentSummary: "n/a"
+        });
+        continue;
+      }
+      const config = await readConfigForDefinition(definition);
+      const value = getNestedValue(config, definition.nativePath);
+      settings.push({
+        ...schemaEntry,
+        currentStatus: value === undefined ? "not-set" : "set",
+        currentSummary: summarizeSettingValue(value)
+      });
+    }
+    return {
+      agent: adapter.agent,
+      displayName: adapter.displayName,
+      scope,
+      settings
+    };
+  }
   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 = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+      const scope2 = resolveFullReadScope(adapter, options2.scope);
       const path2 = adapter.getSettingsPath(scope2, resolveProjectPath(options2.projectPath));
-      return await readJsonObject(path2);
+      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));
-    const config = await readJsonObject(path);
+    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 = {}) {
@@ -45683,13 +46426,13 @@ class AgentSettingsManager {
       throw new Error(`Unknown ${agent} setting: ${key}.`);
     }
     const scope = resolveScope(definition, options2.scope);
-    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
-    const config = await readJsonObject(path);
+    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 writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+      await writeConfigObject(adapter, path, config);
     }
     return {
       agent,
@@ -45711,12 +46454,12 @@ class AgentSettingsManager {
       throw new Error(`Unknown ${agent} setting: ${key}.`);
     }
     const scope = resolveScope(definition, options2.scope);
-    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
-    const config = await readJsonObject(path);
+    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 writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+      await writeConfigObject(adapter, path, config);
     }
     return {
       agent,
@@ -45732,14 +46475,18 @@ class AgentSettingsManager {
     if (!adapter) {
       throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
     }
-    if (agent !== "claude") {
+    if (!adapter.hookEvents) {
       throw new Error(`Agent ${agent} does not support hook management.`);
     }
-    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    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 readJsonObject(path);
-    if (event) {
-      return getHookMatchers(config, normalizeHookEvent(event));
+    const config = await readConfigObject(adapter, path);
+    if (hookEvent) {
+      return getHookMatchers(config, hookEvent);
     }
     const hooks = getNestedValue(config, ["hooks"]);
     if (hooks === undefined) {
@@ -45749,8 +46496,8 @@ class AgentSettingsManager {
       throw new Error("Existing hooks value is not an object.");
     }
     const result = {};
-    for (const [hookEvent, value] of Object.entries(hooks)) {
-      result[hookEvent] = assertHookMatchers(value);
+    for (const [hookEvent2, value] of Object.entries(hooks)) {
+      result[hookEvent2] = assertHookMatchers(value);
     }
     return result;
   }
@@ -45759,13 +46506,14 @@ class AgentSettingsManager {
     if (!adapter) {
       throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
     }
-    if (agent !== "claude") {
+    if (!adapter.hookEvents) {
       throw new Error(`Agent ${agent} does not support hook management.`);
     }
     const hookEvent = normalizeHookEvent(event);
-    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    assertHookEventSupported(adapter, hookEvent);
+    const scope = resolveHookScope(adapter, options2.scope);
     const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
-    const config = await readJsonObject(path);
+    const config = await readConfigObject(adapter, path);
     const hook = buildHookCommand(command, options2.name);
     const matchers = getHookMatchers(config, hookEvent);
     const matcher = options2.matcher ?? "*";
@@ -45780,7 +46528,7 @@ class AgentSettingsManager {
     }
     setHookMatchers(config, hookEvent, matchers);
     if (!options2.dryRun) {
-      await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+      await writeConfigObject(adapter, path, config);
     }
     return {
       agent,
@@ -45796,13 +46544,14 @@ class AgentSettingsManager {
     if (!adapter) {
       throw new Error(`Unsupported agent settings adapter: ${agent}. Supported: ${this.getSupportedAgents().join(", ")}`);
     }
-    if (agent !== "claude") {
+    if (!adapter.hookEvents) {
       throw new Error(`Agent ${agent} does not support hook management.`);
     }
     const hookEvent = normalizeHookEvent(event);
-    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    assertHookEventSupported(adapter, hookEvent);
+    const scope = resolveHookScope(adapter, options2.scope);
     const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
-    const config = await readJsonObject(path);
+    const config = await readConfigObject(adapter, path);
     const matchers = getHookMatchers(config, hookEvent);
     let removed = 0;
     const nextMatchers = matchers.map((entry) => {
@@ -45820,7 +46569,7 @@ class AgentSettingsManager {
     }).filter((entry) => entry.hooks.length > 0);
     setHookMatchers(config, hookEvent, nextMatchers);
     if (!options2.dryRun) {
-      await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+      await writeConfigObject(adapter, path, config);
     }
     return {
       agent,
@@ -45831,6 +46580,60 @@ class AgentSettingsManager {
       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
@@ -45864,6 +46667,14 @@ var printValue = function(value) {
   }
   printJson(value);
 };
+var buildSettingFlags = function(setting4) {
+  return [
+    setting4.valueType,
+    setting4.category,
+    setting4.risk !== "safe" ? setting4.risk : null,
+    setting4.deprecated ? `use ${setting4.replacement}` : null
+  ].filter(Boolean).join(", ");
+};
 var buildSetOptions = function(options2) {
   const result = {};
   const scope = resolveScopeOption(options2);
@@ -45917,6 +46728,45 @@ var buildHookRemoveOptions = function(options2) {
   }
   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");
@@ -45989,6 +46839,38 @@ function registerAgentCommand(program2) {
       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));
@@ -46015,7 +46897,7 @@ function registerAgentCommand(program2) {
       failAgentCommand(error);
     }
   });
-  agent.command("list [agent]").description("List supported agents or setting keys for one agent").option("--json", "Print JSON output").action((agentId, options2) => {
+  agent.command("list [agent]").description("List supported agents or setting keys for one agent").option("--global", "Read global user settings").option("--project", "Read shared project settings").option("--local", "Read local project settings").option("--json", "Print JSON output").option("--details", "Print detailed setting metadata with safe current-value summaries").action(async (agentId, options2) => {
     try {
       if (!agentId) {
         const agents = manager.getSupportedAgents();
@@ -46028,13 +46910,23 @@ function registerAgentCommand(program2) {
         return;
       }
       const schema2 = manager.getSchema(agentId);
-      const keys = schema2.settings.map((setting2) => setting2.key);
+      const keys = schema2.settings.map((setting4) => setting4.key);
       if (options2.json) {
+        if (options2.details) {
+          const list2 = await manager.listSettings(agentId, buildReadOptions(options2));
+          printJson(list2.settings);
+          return;
+        }
         printJson(keys);
         return;
       }
+      const list = await manager.listSettings(agentId, buildReadOptions(options2));
       logger.titleBox(`AgentInit  ${agentId} Settings`);
-      schema2.settings.forEach((setting2, index) => logger.tree(`${cyan(setting2.key)} ${dim(setting2.category)}`, index === schema2.settings.length - 1));
+      logger.info(`Scope: ${cyan(list.scope)}`);
+      list.settings.forEach((setting4, index) => {
+        const flags = buildSettingFlags(setting4);
+        logger.tree(`${cyan(setting4.key)} ${dim(`[${flags}]`)} ${setting4.description} ${dim(`current: ${setting4.currentSummary}`)}`, index === list.settings.length - 1);
+      });
     } catch (error) {
       failAgentCommand(error);
     }
@@ -46048,14 +46940,9 @@ function registerAgentCommand(program2) {
       }
       logger.titleBox(`AgentInit  ${schema2.displayName} Schema`);
       logger.info(`Default omitted scope: ${cyan(schema2.effectiveDefaultScope)}`);
-      for (const setting2 of schema2.settings) {
-        const flags = [
-          setting2.valueType,
-          setting2.category,
-          setting2.risk !== "safe" ? setting2.risk : null,
-          setting2.deprecated ? `use ${setting2.replacement}` : null
-        ].filter(Boolean).join(", ");
-        logger.tree(`${cyan(setting2.key)} ${dim(`[${flags}]`)} ${setting2.description}`, false);
+      for (const setting4 of schema2.settings) {
+        const flags = buildSettingFlags(setting4);
+        logger.tree(`${cyan(setting4.key)} ${dim(`[${flags}]`)} ${setting4.description}`, false);
       }
     } catch (error) {
       failAgentCommand(error);