@martinffx/atelier 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 - **breaking:** rename the `recon` agent to `sentinel`. Existing Atelier configuration is migrated automatically and legacy generated files are removed during the next command.
 
+## [3.6.0](https://github.com/martinffx/atelier/compare/v3.5.0...v3.6.0) (2026-10-25)
+
+
+### Features
+
+* **claude:** disable conflicting Claude Code built-ins ([40e074d](https://github.com/martinffx/atelier/commit/40e074df4e55a300ea4521fb05fad9232525715d))
+
 ## [3.5.0](https://github.com/martinffx/atelier/compare/v3.4.0...v3.5.0) (2026-10-18)
 
 

package/README.md

@@ -141,7 +141,7 @@ Run `atelier update --harness <claude|codex|opencode>` to choose models and thin
 
 Thinking is stored as `agents[].thinking`, `build_thinking`, and `plan_thinking` in `~/.atelier/config.json`. Values are model-specific: `default`, `off`, `on`, `low`, `medium`, `high`, `xhigh`, or `max`. The picker offers only verified capabilities. Custom models and catalog models whose controls have not been verified offer `default` only. Missing fields preserve legacy behavior; **Keep existing behavior** preserves that omission when editing. In particular, old Codex configurations retain medium agent/Build effort and high Plan effort. An explicit `default` omits Atelier's native effort override; other harness settings can still apply.
 
-- **Claude Code:** `opusplan` switches Opus/Sonnet by mode. Other session models share one thinking setting across modes. Atelier writes canonical `modelSettings.<model>.effortLevel` entries and subagent `effort`. Session `max` cannot be persisted, though supported subagents can use it. Use Claude Code **2.1.280 or later** for Opus 5.5 and the current aliases. Atelier also sets `disableClaudeAiConnectors: true`, `syncClaudeAiSkills: false` and `syncClaudeAiPlugins: false` in `~/.claude/settings.json`, so nothing from claude.ai is synced into Claude Code; `atelier remove` clears them unless you changed them. [Claude configuration](https://code.claude.com/docs/en/model-config)
+- **Claude Code:** `opusplan` switches Opus/Sonnet by mode. Other session models share one thinking setting across modes. Atelier writes canonical `modelSettings.<model>.effortLevel` entries and subagent `effort`. Session `max` cannot be persisted, though supported subagents can use it. Use Claude Code **2.1.280 or later** for Opus 5.5 and the current aliases. Atelier also sets `disableClaudeAiConnectors: true`, `syncClaudeAiSkills: false` and `syncClaudeAiPlugins: false` in `~/.claude/settings.json`, so nothing from claude.ai is synced into Claude Code; `atelier remove` clears them unless you changed them. It also disables the Claude Code built-ins that clash with Atelier skills (`disableBundledSkills`, `enableArtifact: false`, `disableWorkflows`, deny rules for `Artifact`, `ArtifactComments`, `ArtifactData`, `Workflow` and `DesignSync`, and `skillOverrides` turning off the `/security-review` and `/ultrareview` commands). Interactive `init` also offers a checklist of optional built-ins to disable, none selected by default: `cron` (`/loop` and the Cron tools), `chrome` (the claude-in-chrome MCP server) and `remote-trigger` (`RemoteTrigger`). `atelier remove` and unticking an option undo these the same way. [Claude configuration](https://code.claude.com/docs/en/model-config)
 - **Codex:** Plan and Build share the selected session model, with separate reasoning settings. Oracle and Architect use independent Astra configurations. `off` maps to native `none`, available on Sol/Luna but not Astra. [Codex configuration](https://developers.openai.com/codex/config-reference/)
 - **OpenCode:** all five assignments are independent. Use **1.18.30 or later** for GPT-6 integration. Atelier sends explicit provider options rather than relying on automatically discovered reasoning variants: `reasoningEffort` for OpenAI-compatible routes, `effort` for Anthropic, and `reasoningConfig` for Bedrock. GLM 5.3 supports low/high/max; it does not support medium. Bedrock defaults use US inference profiles with `us-east-1`. [OpenCode agents](https://opencode.ai/docs/agents/)
 - **MiMo:** `on`/`off` maps to `thinking.type: enabled`/`disabled`. There are no graded effort tiers. OpenCode agent files omit the old fixed temperature override so provider defaults apply. [MiMo API](https://mimo.mi.com/docs/en-US/api/chat/openai-api)

package/dist/atelier.js

@@ -32570,7 +32570,10 @@ var OpenCodeConfigSchema = objectType({
   plan_thinking: ThinkingSchema.optional(),
   agents: arrayType(ThinkingAgentSchema).min(1)
 }).superRefine((config, ctx) => checkThinking("opencode", config, ctx));
-var ClaudeConfigSchema = SimpleConfigSchema.superRefine((config, ctx) => {
+var CLAUDE_OPTIONAL_BUILTINS = ["cron", "chrome", "remote-trigger"];
+var ClaudeConfigSchema = SimpleConfigSchema.extend({
+  disabled_builtins: arrayType(enumType(CLAUDE_OPTIONAL_BUILTINS)).optional()
+}).superRefine((config, ctx) => {
   checkThinking("claude", config, ctx);
   if (config.default_model !== "opusplan" && config.plan_thinking !== undefined && config.plan_thinking !== config.build_thinking) {
     ctx.addIssue({ code: "custom", path: ["plan_thinking"], message: "Separate Claude Plan/Build thinking requires opusplan" });
@@ -32602,6 +32605,16 @@ var CLAUDE_AI_OPT_OUTS = {
   syncClaudeAiSkills: false,
   syncClaudeAiPlugins: false
 };
+var CONFLICTING_BUILTINS = {
+  settings: { disableBundledSkills: true, enableArtifact: false, disableWorkflows: true },
+  deny: ["Artifact", "ArtifactComments", "ArtifactData", "Workflow", "DesignSync"],
+  skillOverrides: ["security-review", "ultrareview"]
+};
+var OPTIONAL_BUILTINS = {
+  cron: { env: { CLAUDE_CODE_DISABLE_CRON: "1" } },
+  chrome: { deniedMcpServers: ["claude-in-chrome"] },
+  "remote-trigger": { deny: ["RemoteTrigger"] }
+};
 var claudeAdapter = {
   name: "claude",
   configSchema: ClaudeConfigSchema,
@@ -32631,7 +32644,15 @@ function modelsForProvider(_provider) {
   return [...ANTHROPIC_MODELS];
 }
 async function promptSection(prompt, section) {
-  return promptForSimpleModels(prompt, section, modelsForProvider());
+  const claude = section;
+  const result = await promptForSimpleModels(prompt, claude, modelsForProvider());
+  const { disabled } = await prompt.prompt([{
+    type: "checkbox",
+    name: "disabled",
+    message: "Disable optional Claude Code built-ins",
+    choices: CLAUDE_OPTIONAL_BUILTINS.map((value) => ({ name: value, value, checked: claude.disabled_builtins?.includes(value) ?? false }))
+  }]);
+  return { ...result, disabled_builtins: disabled };
 }
 function installAgents(section, basePath) {
   const config = ClaudeConfigSchema.parse(section);
@@ -32671,6 +32692,13 @@ function mergeHarnessConfig(section, basePath) {
     model: config.default_model || DEFAULT_MODELS.default_model
   };
   applyModeThinking(settings, config);
+  applyBuiltins(settings, CONFLICTING_BUILTINS);
+  for (const name of CLAUDE_OPTIONAL_BUILTINS) {
+    if (config.disabled_builtins?.includes(name))
+      applyBuiltins(settings, OPTIONAL_BUILTINS[name]);
+    else
+      removeBuiltins(settings, OPTIONAL_BUILTINS[name]);
+  }
   try {
     mkdirSync2(claudeDir, { recursive: true });
     writeFileSync3(settingsPath, JSON.stringify(settings, null, 2) + `
@@ -32729,6 +32757,9 @@ function removeAtelierSettings(claudeDir, config) {
       delete content[key];
   }
   applyModeThinking(content, config, true);
+  removeBuiltins(content, CONFLICTING_BUILTINS);
+  for (const patch of Object.values(OPTIONAL_BUILTINS))
+    removeBuiltins(content, patch);
   writeOrDeleteSettings(settingsPath, content);
 }
 function applyModeThinking(settings, config, remove = false) {
@@ -32753,6 +32784,75 @@ function applyModeThinking(settings, config, remove = false) {
   else
     delete settings.modelSettings;
 }
+function applyBuiltins(settings, patch) {
+  Object.assign(settings, patch.settings);
+  if (patch.env)
+    settings.env = { ...settings.env, ...patch.env };
+  if (patch.deny) {
+    const permissions = { ...settings.permissions };
+    const deny = permissions.deny ?? [];
+    permissions.deny = [...deny, ...patch.deny.filter((rule) => !deny.includes(rule))];
+    settings.permissions = permissions;
+  }
+  if (patch.skillOverrides) {
+    const overrides = { ...settings.skillOverrides };
+    for (const name of patch.skillOverrides)
+      overrides[name] = "off";
+    settings.skillOverrides = overrides;
+  }
+  if (patch.deniedMcpServers) {
+    const denied = settings.deniedMcpServers ?? [];
+    const missing = patch.deniedMcpServers.filter((name) => !denied.some((entry) => entry.serverName === name));
+    settings.deniedMcpServers = [...denied, ...missing.map((serverName) => ({ serverName }))];
+  }
+}
+function removeBuiltins(settings, patch) {
+  for (const [key, value] of Object.entries(patch.settings ?? {})) {
+    if (settings[key] === value)
+      delete settings[key];
+  }
+  if (patch.env) {
+    const env = { ...settings.env };
+    for (const [key, value] of Object.entries(patch.env)) {
+      if (env[key] === value)
+        delete env[key];
+    }
+    if (Object.keys(env).length)
+      settings.env = env;
+    else
+      delete settings.env;
+  }
+  if (patch.deny && settings.permissions) {
+    const permissions = { ...settings.permissions };
+    const deny = (permissions.deny ?? []).filter((rule) => !patch.deny.includes(rule));
+    if (deny.length)
+      permissions.deny = deny;
+    else
+      delete permissions.deny;
+    if (Object.keys(permissions).length)
+      settings.permissions = permissions;
+    else
+      delete settings.permissions;
+  }
+  if (patch.skillOverrides && settings.skillOverrides) {
+    const overrides = { ...settings.skillOverrides };
+    for (const name of patch.skillOverrides) {
+      if (overrides[name] === "off")
+        delete overrides[name];
+    }
+    if (Object.keys(overrides).length)
+      settings.skillOverrides = overrides;
+    else
+      delete settings.skillOverrides;
+  }
+  if (patch.deniedMcpServers && settings.deniedMcpServers) {
+    const denied = settings.deniedMcpServers.filter((entry) => !patch.deniedMcpServers.includes(entry.serverName ?? ""));
+    if (denied.length)
+      settings.deniedMcpServers = denied;
+    else
+      delete settings.deniedMcpServers;
+  }
+}
 function parseSettingsJson(settingsPath) {
   try {
     return JSON.parse(readFileSync4(settingsPath, "utf-8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinffx/atelier",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Personal development toolkit - spec-driven development, code quality, deep thinking, and ecosystem patterns",
   "type": "module",
   "bin": {