agentinit 1.22.0 → 1.23.0

package/dist/cli.js

@@ -12636,11 +12636,14 @@ class Agent {
   getSkillsDir(projectPath, global3) {
     if (!this.definition.skillPaths)
       return null;
-    if (global3) {
+    if (this.getSkillsScope(global3) === "global") {
       return this.definition.skillPaths.global.replace("~", homedir2());
     }
     return resolve6(projectPath, this.definition.skillPaths.project);
   }
+  getSkillsScope(global3) {
+    return global3 || this.definition.skillsConfigScope === "global-only" ? "global" : "project";
+  }
   getProjectRulesStandard() {
     return this.definition.projectStandards?.rules || null;
   }
@@ -16148,6 +16151,7 @@ class HermesAgent extends Agent {
         project: ".agents/skills/",
         global: "~/.hermes/skills/"
       },
+      skillsConfigScope: "global-only",
       projectStandards: {
         skills: "agents"
       }
@@ -16884,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)) {
@@ -16955,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
   };
@@ -16989,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) {
@@ -17000,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) {
@@ -17023,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
@@ -19745,7 +19779,7 @@ class SkillsManager {
         mode: "copy"
       };
     }
-    const canonicalPath = this.resolveInstallPath(this.getCanonicalSkillsDir(projectPath, options2.global ?? false), normalizedSkillName);
+    const canonicalPath = this.resolveInstallPath(this.getCanonicalSkillsDir(projectPath, agent.getSkillsScope(options2.global) === "global"), normalizedSkillName);
     if (agentPath === canonicalPath) {
       return {
         path: canonicalPath,
@@ -20200,12 +20234,14 @@ class SkillsManager {
           for (const entry of entries) {
             const hashPath = entry.canonicalPath || entry.path;
             const contentHash = await hashDirectory(hashPath);
+            const agent = this.agentManager.getAgentById(entry.agent);
+            const scope = agent?.getSkillsScope(options2.global) ?? (options2.global ? "global" : "project");
             await lock.recordSkill({
               action,
               name: entry.skill.name,
               projectPath: resolve9(projectPath),
               agents: [entry.agent],
-              scope: options2.global ? "global" : "project",
+              scope,
               source: lockSource,
               installPath: entry.path,
               mode: entry.mode,
@@ -20235,7 +20271,7 @@ class SkillsManager {
       if (!agent.supportsSkills())
         continue;
       const scopes = [];
-      if (!options2.global) {
+      if (!options2.global && agent.getSkillsScope(false) === "project") {
         scopes.push({ scope: "project", dir: agent.getSkillsDir(projectPath, false) });
       }
       scopes.push({ scope: "global", dir: agent.getSkillsDir(projectPath, true) });
@@ -42088,6 +42124,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");
@@ -45131,6 +45210,859 @@ Dry run \u2014 no changes made.`));
   });
 }
 
+// dist/core/agentSettings/settingsManager.js
+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 "enum": {
+      if (!definition.allowedValues?.includes(raw)) {
+        throw new Error(`Value for "${definition.key}" must be one of: ${definition.allowedValues?.join(", ")}.`);
+      }
+      return raw;
+    }
+    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.deprecated !== undefined) {
+    definition.deprecated = options2.deprecated;
+  }
+  if (options2.replacement) {
+    definition.replacement = options2.replacement;
+  }
+  return definition;
+};
+var ALL_SCOPES = ["global", "project", "local"];
+var PERSONAL_SCOPES = ["global", "local"];
+var claudeSettingsAdapter = {
+  agent: "claude",
+  displayName: "Claude Code",
+  definitions: [
+    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"],
+      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("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("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) {
+    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/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
+];
+
+// 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 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 resolvedScope = scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+  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) {
+  const content = await readFileIfExists(path);
+  if (!content) {
+    return {};
+  }
+  try {
+    return assertObject(JSON.parse(content), path);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`${path} contains invalid JSON.`);
+    }
+    throw error;
+  }
+}
+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"
+};
+var HOOK_EVENTS = new Set(Object.values(HOOK_EVENT_ALIASES));
+
+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 = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+      const path2 = adapter.getSettingsPath(scope2, resolveProjectPath(options2.projectPath));
+      return await readJsonObject(path2);
+    }
+    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);
+    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));
+    const config = await readJsonObject(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`);
+    }
+    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));
+    const config = await readJsonObject(path);
+    const previousValue = getNestedValue(config, definition.nativePath);
+    deleteNestedValue(config, definition.nativePath);
+    if (!options2.dryRun) {
+      await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    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 (agent !== "claude") {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readJsonObject(path);
+    if (event) {
+      return getHookMatchers(config, normalizeHookEvent(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.");
+    }
+    const result = {};
+    for (const [hookEvent, value] of Object.entries(hooks)) {
+      result[hookEvent] = 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 (agent !== "claude") {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const hookEvent = normalizeHookEvent(event);
+    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readJsonObject(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 writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    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 (agent !== "claude") {
+      throw new Error(`Agent ${agent} does not support hook management.`);
+    }
+    const hookEvent = normalizeHookEvent(event);
+    const scope = options2.scope ?? getEffectiveAgentSettingsDefaultScopeSync();
+    const path = adapter.getSettingsPath(scope, resolveProjectPath(options2.projectPath));
+    const config = await readJsonObject(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 writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    return {
+      agent,
+      event: hookEvent,
+      scope,
+      path,
+      removed,
+      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;
+};
+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);
+    }
+  });
+  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((setting2) => setting2.key);
+      if (options2.json) {
+        printJson(keys);
+        return;
+      }
+      logger.titleBox(`AgentInit  ${agentId} Settings`);
+      schema2.settings.forEach((setting2, index) => logger.tree(`${cyan(setting2.key)} ${dim(setting2.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 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);
+      }
+    } catch (error) {
+      failAgentCommand(error);
+    }
+  });
+}
+
 // dist/cli.js
 init_logger();
 var program2 = new Command;
@@ -45141,6 +46073,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);