@link-assistant/hive-mind 1.54.4 → 1.54.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.54.5
+
+### Patch Changes
+
+- ea79845: Disable noisy Claude Code features for solve runs via merged user settings, subprocess environment variables, and Docker image defaults. Expands the quiet config to also disable fast mode, feedback surveys, mouse tracking, away summaries, Claude attribution (commit/pr), co-authored-by trailer, thinking summaries, and UI animations, sets viewMode to verbose, and caps tool-use concurrency at 4 for deterministic autonomous runs. Keeps Claude's built-in git/PR instructions on (`includeGitInstructions: true`), enables task tracking (`CLAUDE_CODE_ENABLE_TASKS=1`) and turn resume (`CLAUDE_CODE_RESUME_INTERRUPTED_TURN=1`), and makes the bypass-permissions mode audible via `permissions.defaultMode: "bypassPermissions"` + `skipDangerousModePermissionPrompt: true` (complementing the existing `--dangerously-skip-permissions` CLI flag). Adds a reusable `configure-claude` bin with an apply default and a `--verify` check-only mode so users and system administrators can reset or audit Claude Code configuration manually after installing `@link-assistant/hive-mind`. Docker release builds now wait for the npm package version to become available, pass that exact version into Docker as `HIVE_MIND_VERSION`, install `@link-assistant/hive-mind@${HIVE_MIND_VERSION}`, and invoke the published `configure-claude` bin directly instead of copying repo source files into the Docker build.
+
 ## 1.54.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.54.4",
+  "version": "1.54.5",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -9,11 +9,12 @@
     "solve": "./src/solve.mjs",
     "task": "./src/task.mjs",
     "review": "./src/review.mjs",
+    "configure-claude": "./src/configure-claude.mjs",
     "start-screen": "./src/start-screen.mjs",
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",
@@ -25,7 +26,7 @@
     "changeset": "changeset",
     "changeset:version": "changeset version",
     "changeset:publish": "npm run build:pre && changeset publish",
-    "build:pre": "chmod +x src/hive.mjs && chmod +x src/solve.mjs",
+    "build:pre": "chmod +x src/hive.mjs && chmod +x src/solve.mjs && chmod +x src/configure-claude.mjs",
     "prepare": "husky"
   },
   "repository": {

package/src/claude-quiet-config.lib.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export const REQUIRED_CLAUDE_QUIET_ENV = Object.freeze({
+  CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+  CLAUDE_CODE_DISABLE_CRON: '1',
+  CLAUDE_CODE_DISABLE_TERMINAL_TITLE: '1',
+  CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1',
+  CLAUDE_CODE_DISABLE_FAST_MODE: '1',
+  CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY: '1',
+  CLAUDE_CODE_DISABLE_MOUSE: '1',
+  CLAUDE_CODE_ENABLE_AWAY_SUMMARY: '0',
+  CLAUDE_CODE_ENABLE_TASKS: '1',
+  CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY: '4',
+  CLAUDE_CODE_RESUME_INTERRUPTED_TURN: '1',
+  DISABLE_FEEDBACK_COMMAND: '1',
+});
+
+export const REQUIRED_CLAUDE_QUIET_SETTINGS = Object.freeze({
+  autoMemoryEnabled: false,
+  spinnerTipsEnabled: false,
+  awaySummaryEnabled: false,
+  feedbackSurveyRate: 0,
+  includeCoAuthoredBy: false,
+  includeGitInstructions: true,
+  prefersReducedMotion: true,
+  showThinkingSummaries: false,
+  skipDangerousModePermissionPrompt: true,
+  viewMode: 'verbose',
+});
+
+export const REQUIRED_CLAUDE_QUIET_ATTRIBUTION = Object.freeze({
+  commit: '',
+  pr: '',
+});
+
+export const REQUIRED_CLAUDE_QUIET_PERMISSIONS = Object.freeze({
+  defaultMode: 'bypassPermissions',
+});
+
+export const buildClaudeQuietEnv = (baseEnv = process.env) => ({
+  ...baseEnv,
+  ...REQUIRED_CLAUDE_QUIET_ENV,
+});
+
+export const formatClaudeQuietConfigSummary = () => {
+  const settings = Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)
+    .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+    .join(', ');
+  const attribution = `attribution=${JSON.stringify(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)}`;
+  const permissions = `permissions=${JSON.stringify(REQUIRED_CLAUDE_QUIET_PERMISSIONS)}`;
+  const env = Object.entries(REQUIRED_CLAUDE_QUIET_ENV)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(', ');
+  return `settings[${settings}, ${attribution}, ${permissions}], env[${env}]`;
+};
+
+const isPlainObject = value => value && typeof value === 'object' && !Array.isArray(value);
+
+export const ensureClaudeQuietConfig = async ({ settingsPath, log } = {}) => {
+  const resolvedPath = settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
+  let settings = {};
+  try {
+    const content = await fs.readFile(resolvedPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    settings = isPlainObject(parsed) ? parsed : {};
+  } catch (err) {
+    if (err.code !== 'ENOENT' && log) {
+      await log(`⚠️  Could not read ${resolvedPath}: ${err.message}`, { verbose: true });
+    }
+    settings = {};
+  }
+
+  const updatedSettingsKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)) {
+    if (settings[key] !== value) {
+      settings[key] = value;
+      updatedSettingsKeys.push(key);
+    }
+  }
+
+  const existingAttribution = isPlainObject(settings.attribution) ? settings.attribution : {};
+  const updatedAttributionKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)) {
+    if (existingAttribution[key] !== value) {
+      existingAttribution[key] = value;
+      updatedAttributionKeys.push(key);
+    }
+  }
+  settings.attribution = existingAttribution;
+  if (updatedAttributionKeys.length > 0) {
+    updatedSettingsKeys.push('attribution');
+  }
+
+  const existingPermissions = isPlainObject(settings.permissions) ? settings.permissions : {};
+  const updatedPermissionsKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_PERMISSIONS)) {
+    if (existingPermissions[key] !== value) {
+      existingPermissions[key] = value;
+      updatedPermissionsKeys.push(key);
+    }
+  }
+  settings.permissions = existingPermissions;
+  if (updatedPermissionsKeys.length > 0) {
+    updatedSettingsKeys.push('permissions');
+  }
+
+  const existingEnv = isPlainObject(settings.env) ? settings.env : {};
+  const updatedEnvKeys = [];
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ENV)) {
+    if (existingEnv[key] !== value) {
+      existingEnv[key] = value;
+      updatedEnvKeys.push(key);
+    }
+  }
+  settings.env = existingEnv;
+
+  const changed = updatedSettingsKeys.length > 0 || updatedEnvKeys.length > 0;
+  try {
+    if (changed) {
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.writeFile(resolvedPath, JSON.stringify(settings, null, 2));
+    }
+    if (log) {
+      await log(`🧭 Claude Code quiet config ${changed ? 'updated' : 'verified'} at ${resolvedPath}: ${formatClaudeQuietConfigSummary()}`);
+    }
+  } catch (err) {
+    if (log) await log(`⚠️  Could not write ${resolvedPath}: ${err.message}`, { verbose: true });
+  }
+
+  return {
+    path: resolvedPath,
+    changed,
+    updatedSettingsKeys,
+    updatedEnvKeys,
+    updatedAttributionKeys,
+    updatedPermissionsKeys,
+    settings: { ...REQUIRED_CLAUDE_QUIET_SETTINGS },
+    attribution: { ...REQUIRED_CLAUDE_QUIET_ATTRIBUTION },
+    permissions: { ...REQUIRED_CLAUDE_QUIET_PERMISSIONS },
+    env: { ...REQUIRED_CLAUDE_QUIET_ENV },
+  };
+};

package/src/claude.lib.mjs

@@ -21,6 +21,7 @@ import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; //
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
 import { buildMcpConfigWithoutPlaywright } from './playwright-mcp.lib.mjs';
 import { resolveClaudeSessionToolFlags } from './useless-tools.lib.mjs';
+import { ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
 import { fetchModelInfo } from './model-info.lib.mjs';
 export { availableModels }; // Re-export for backward compatibility
 export { fetchModelInfo };
@@ -725,6 +726,7 @@ export const executeClaudeCommand = async params => {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
     }
+    await ensureClaudeQuietConfig({ log });
     const { mcpConfigPath, disallowedToolsList } = await resolveClaudeSessionToolFlags({ argv, log, fallbackBuildMcpConfigWithoutPlaywright: buildMcpConfigWithoutPlaywright });
     if (mcpConfigPath) claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
     if (disallowedToolsList.length) claudeArgs += ` --disallowedTools ${disallowedToolsList.join(' ')}`;

package/src/config.lib.mjs

@@ -24,6 +24,7 @@ const getenv = typeof getenvModule === 'function' ? getenvModule : getenvModule.
 
 // Use semver package for version comparison (see issue #1146)
 import semver from 'semver';
+import { buildClaudeQuietEnv } from './claude-quiet-config.lib.mjs';
 
 // Import lino for parsing Links Notation format
 const { lino } = await import('./lino.lib.mjs');
@@ -419,14 +420,14 @@ export const getClaudeEnv = (options = {}) => {
   // Get max output tokens based on model (Issue #1221)
   const maxOutputTokens = options.model ? getMaxOutputTokensForModel(options.model) : claudeCode.maxOutputTokens;
 
-  const env = {
+  const env = buildClaudeQuietEnv({
     ...process.env,
     CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(maxOutputTokens),
     // MCP timeout configurations to prevent tool calls from hanging indefinitely
     // See: https://github.com/link-assistant/hive-mind/issues/1066
     MCP_TIMEOUT: String(claudeCode.mcpTimeout),
     MCP_TOOL_TIMEOUT: String(claudeCode.mcpToolTimeout),
-  };
+  });
 
   // Opus 4.7+ always uses adaptive thinking — MAX_THINKING_TOKENS has no effect (Issue #1620)
   // For Opus 4.6 and earlier, MAX_THINKING_TOKENS controls extended thinking (Claude Code >= 2.1.12)

package/src/configure-claude.lib.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+/**
+ * Shared runner for the `configure-claude` bin command. Applies or verifies
+ * the quiet Claude Code defaults in a target `settings.json` by reusing the
+ * canonical maps and idempotent merge helpers from:
+ *   - src/claude-quiet-config.lib.mjs (quiet env + settings + attribution
+ *     + permissions)
+ *   - src/useless-tools.lib.mjs      (disallowedTools block-list)
+ *
+ * See issues #1627 and #1642.
+ */
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { REQUIRED_CLAUDE_QUIET_ENV, REQUIRED_CLAUDE_QUIET_SETTINGS, REQUIRED_CLAUDE_QUIET_ATTRIBUTION, REQUIRED_CLAUDE_QUIET_PERMISSIONS, ensureClaudeQuietConfig } from './claude-quiet-config.lib.mjs';
+import { buildDisallowedToolsList, ensureDisallowedToolsInSettings } from './useless-tools.lib.mjs';
+
+export const resolveSettingsPath = settingsPath => settingsPath || path.join(os.homedir(), '.claude', 'settings.json');
+
+export const parseConfigureClaudeArgs = argv => {
+  const args = { settingsPath: null, verify: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--settings-path' || arg === '-s') {
+      args.settingsPath = argv[++i];
+    } else if (arg.startsWith('--settings-path=')) {
+      args.settingsPath = arg.slice('--settings-path='.length);
+    } else if (arg === '--verify') {
+      args.verify = true;
+    } else if (arg === '--help' || arg === '-h') {
+      args.help = true;
+    }
+  }
+  return args;
+};
+
+export const CONFIGURE_CLAUDE_HELP = `Usage: configure-claude [options]
+
+Apply or verify Hive-Mind's quiet, deterministic Claude Code defaults in
+a target ~/.claude/settings.json (env vars, settings, attribution,
+permissions.defaultMode, and the disallowedTools block-list).
+
+Options:
+  -s, --settings-path <path>  Path to settings.json (default: ~/.claude/settings.json)
+      --verify                Report configuration status without writing; exit 1 if incorrect
+  -h, --help                  Show this help and exit
+
+Examples:
+  configure-claude                           # apply defaults to ~/.claude/settings.json
+  configure-claude --verify                  # check only, non-zero exit if drift detected
+  configure-claude -s /workspace/.claude/settings.json
+
+Reference: https://github.com/link-assistant/hive-mind/issues/1642
+`;
+
+const isPlainObject = value => value && typeof value === 'object' && !Array.isArray(value);
+
+const readSettings = async settingsPath => {
+  try {
+    const content = await fs.readFile(settingsPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    return isPlainObject(parsed) ? parsed : {};
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+};
+
+export const verifyConfigureClaude = async ({ settingsPath } = {}) => {
+  const resolvedPath = resolveSettingsPath(settingsPath);
+  const settings = await readSettings(resolvedPath);
+  const missing = {
+    file: settings === null,
+    settings: [],
+    env: [],
+    attribution: [],
+    permissions: [],
+    disallowedTools: [],
+  };
+  const current = settings || {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_SETTINGS)) {
+    if (current[key] !== value) missing.settings.push(key);
+  }
+  const envSection = isPlainObject(current.env) ? current.env : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ENV)) {
+    if (envSection[key] !== value) missing.env.push(key);
+  }
+  const attributionSection = isPlainObject(current.attribution) ? current.attribution : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_ATTRIBUTION)) {
+    if (attributionSection[key] !== value) missing.attribution.push(key);
+  }
+  const permissionsSection = isPlainObject(current.permissions) ? current.permissions : {};
+  for (const [key, value] of Object.entries(REQUIRED_CLAUDE_QUIET_PERMISSIONS)) {
+    if (permissionsSection[key] !== value) missing.permissions.push(key);
+  }
+  const existingDisallowed = Array.isArray(current.disallowedTools) ? current.disallowedTools : [];
+  for (const required of buildDisallowedToolsList()) {
+    if (!existingDisallowed.includes(required)) missing.disallowedTools.push(required);
+  }
+  const ok = !missing.file && missing.settings.length === 0 && missing.env.length === 0 && missing.attribution.length === 0 && missing.permissions.length === 0 && missing.disallowedTools.length === 0;
+  return { ok, path: resolvedPath, missing };
+};
+
+export const runConfigureClaude = async ({ settingsPath, log } = {}) => {
+  const resolvedPath = resolveSettingsPath(settingsPath);
+  const logger = log || (async line => console.log(line));
+  const quietResult = await ensureClaudeQuietConfig({ settingsPath: resolvedPath, log: logger });
+  const disallowedResult = await ensureDisallowedToolsInSettings({ settingsPath: resolvedPath, log: logger });
+  return { quietResult, disallowedResult, path: resolvedPath };
+};
+
+export const formatVerifyReport = ({ ok, path: resolvedPath, missing }) => {
+  if (ok) {
+    return `✅ Quiet Claude Code configuration is up to date in ${resolvedPath}`;
+  }
+  const sections = [];
+  if (missing.file) sections.push('  - settings.json missing');
+  if (missing.settings.length) sections.push(`  - settings: ${missing.settings.join(', ')}`);
+  if (missing.env.length) sections.push(`  - env: ${missing.env.join(', ')}`);
+  if (missing.attribution.length) sections.push(`  - attribution: ${missing.attribution.join(', ')}`);
+  if (missing.permissions.length) sections.push(`  - permissions: ${missing.permissions.join(', ')}`);
+  if (missing.disallowedTools.length) sections.push(`  - disallowedTools: ${missing.disallowedTools.join(', ')}`);
+  return `❌ Quiet Claude Code configuration drift detected in ${resolvedPath}\n${sections.join('\n')}`;
+};

package/src/configure-claude.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+/**
+ * `configure-claude` — reusable bin that resets Hive-Mind's quiet,
+ * deterministic Claude Code defaults (env, settings, attribution,
+ * permissions.defaultMode, and the disallowedTools block-list) in a
+ * target `settings.json`, or verifies that they are already in place.
+ *
+ * Users and system administrators can run this manually after installing
+ * `@link-assistant/hive-mind` to reset Claude Code configuration. Docker
+ * images invoke this published bin after npm release, so the image baseline
+ * stays in lock-step with the package users install.
+ *
+ * See issues #1627 and #1642.
+ */
+
+import { CONFIGURE_CLAUDE_HELP, formatVerifyReport, parseConfigureClaudeArgs, resolveSettingsPath, runConfigureClaude, verifyConfigureClaude } from './configure-claude.lib.mjs';
+
+const args = parseConfigureClaudeArgs(process.argv.slice(2));
+
+if (args.help) {
+  console.log(CONFIGURE_CLAUDE_HELP);
+  process.exit(0);
+}
+
+const settingsPath = resolveSettingsPath(args.settingsPath);
+
+if (args.verify) {
+  const report = await verifyConfigureClaude({ settingsPath });
+  console.log(formatVerifyReport(report));
+  process.exit(report.ok ? 0 : 1);
+}
+
+const { quietResult, disallowedResult } = await runConfigureClaude({ settingsPath });
+console.log(`Configured quiet Claude Code defaults and ${disallowedResult.total} disallowedTools in ${quietResult.path}`);