@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/repo-settings.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Repo-local settings for zeroshot
  *
@@ -7,77 +8,100 @@
  * This complements the global user settings at:
  *   ~/.zeroshot/settings.json
  */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-function _safeJsonParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const childProcess = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const { execSync } = childProcess;
+function safeJsonParse(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed;
+    }
+    catch {
+        return null;
+    }
 }
-
-function _getGitRoot(dir) {
-  try {
-    return execSync('git rev-parse --show-toplevel', {
-      cwd: dir,
-      encoding: 'utf8',
-      stdio: 'pipe',
-    }).trim();
-  } catch {
-    return null;
-  }
+function getGitRoot(dir) {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            cwd: dir,
+            encoding: 'utf8',
+            stdio: 'pipe',
+        }).trim();
+    }
+    catch {
+        return null;
+    }
 }
-
-function _readSettingsFile(filePath) {
-  try {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    const parsed = _safeJsonParse(raw);
-    if (!parsed || typeof parsed !== 'object') {
-      return null;
+function readSettingsFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const parsed = safeJsonParse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
     }
-    return parsed;
-  } catch {
-    return null;
-  }
 }
-
 /**
  * Read repo-local settings if present.
- *
- * @param {string} startDir - Directory inside the repo (usually process.cwd()).
- * @returns {{repoRoot: string|null, settings: object|null, settingsPath: string|null}}
  */
 function readRepoSettings(startDir) {
-  const repoRoot = _getGitRoot(startDir);
-  if (!repoRoot) {
-    return { repoRoot: null, settings: null, settingsPath: null };
-  }
-
-  const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
-  if (!fs.existsSync(settingsPath)) {
-    return { repoRoot, settings: null, settingsPath };
-  }
-
-  const settings = _readSettingsFile(settingsPath);
-  return { repoRoot, settings, settingsPath };
+    const repoRoot = getGitRoot(startDir);
+    if (!repoRoot) {
+        return { repoRoot: null, settings: null, settingsPath: null };
+    }
+    const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
+    if (!fs.existsSync(settingsPath)) {
+        return { repoRoot, settings: null, settingsPath };
+    }
+    const settings = readSettingsFile(settingsPath);
+    return { repoRoot, settings, settingsPath };
 }
-
 /**
  * Write repo-local settings.
- *
- * @param {string} repoRoot - Repo root directory (as returned by readRepoSettings).
- * @param {object} settings - Settings object to persist.
- * @returns {string} The path written to.
  */
 function writeRepoSettings(repoRoot, settings) {
-  const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
-  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
-  return settingsPath;
+    const settingsPath = path.join(repoRoot, '.zeroshot', 'settings.json');
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    const serialized = JSON.stringify(settings, null, 2);
+    fs.writeFileSync(settingsPath, serialized, 'utf8');
+    return settingsPath;
 }
-
 module.exports = { readRepoSettings, writeRepoSettings };

package/lib/run-mode.d.ts

@@ -0,0 +1,21 @@
+type RunMode = 'ship' | 'ship+docker' | 'pr' | 'pr+docker' | 'docker' | 'worktree' | null;
+interface RunModePlan {
+    isolation: 'none' | 'worktree' | 'docker';
+    delivery: 'none' | 'pr' | 'ship';
+}
+interface RunModeOptions {
+    worktree?: unknown;
+    docker?: unknown;
+    pr?: unknown;
+    ship?: unknown;
+    autoMerge?: unknown;
+}
+declare function runModeFromPlan({ isolation, delivery }: RunModePlan): RunMode;
+declare function resolveRunMode(options?: RunModeOptions): RunMode;
+declare function describeRunMode(mode: PropertyKey | null | undefined): string;
+declare const _default: {
+    resolveRunMode: typeof resolveRunMode;
+    runModeFromPlan: typeof runModeFromPlan;
+    describeRunMode: typeof describeRunMode;
+};
+export = _default;

package/lib/run-mode.js

@@ -1,34 +1,35 @@
-const { resolveRunPlan } = require('./run-plan');
-
+"use strict";
+const runPlan = require("./run-plan");
+const { resolveRunPlan } = runPlan;
 // The run-mode label is a VIEW of the canonical plan, never an independent
 // cascade. Deriving it from the plan is what keeps the user-facing label and the
 // actual isolation/delivery/autoMerge behavior from drifting apart. Callers that
 // already hold a plan (e.g. the effective plan with env/settings folded in) use
 // runModeFromPlan directly so the label reflects the SAME plan as behavior.
 function runModeFromPlan({ isolation, delivery }) {
-  const dockerSuffix = isolation === 'docker' ? '+docker' : '';
-  if (delivery === 'ship') return `ship${dockerSuffix}`;
-  if (delivery === 'pr') return `pr${dockerSuffix}`;
-  if (isolation === 'docker') return 'docker';
-  if (isolation === 'worktree') return 'worktree';
-  return null;
+    const dockerSuffix = isolation === 'docker' ? '+docker' : '';
+    if (delivery === 'ship')
+        return `ship${dockerSuffix}`;
+    if (delivery === 'pr')
+        return `pr${dockerSuffix}`;
+    if (isolation === 'docker')
+        return 'docker';
+    if (isolation === 'worktree')
+        return 'worktree';
+    return null;
 }
-
 function resolveRunMode(options) {
-  return runModeFromPlan(resolveRunPlan(options));
+    return runModeFromPlan(resolveRunPlan(options));
 }
-
 const RUN_MODE_LABELS = {
-  ship: 'ship (worktree + PR + auto-merge)',
-  'ship+docker': 'ship (docker + PR + auto-merge)',
-  pr: 'pr (worktree + PR)',
-  'pr+docker': 'pr (docker + PR)',
-  docker: 'docker (isolated container)',
-  worktree: 'worktree (isolated branch)',
+    ship: 'ship (worktree + PR + auto-merge)',
+    'ship+docker': 'ship (docker + PR + auto-merge)',
+    pr: 'pr (worktree + PR)',
+    'pr+docker': 'pr (docker + PR)',
+    docker: 'docker (isolated container)',
+    worktree: 'worktree (isolated branch)',
 };
-
 function describeRunMode(mode) {
-  return RUN_MODE_LABELS[mode] || 'local (no isolation)';
+    return RUN_MODE_LABELS[mode ?? ''] || 'local (no isolation)';
 }
-
 module.exports = { resolveRunMode, runModeFromPlan, describeRunMode };

package/lib/run-plan.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The single canonical run-mode resolver.
+ *
+ * Every consumer (orchestrator, daemon startup, CLI label) derives isolation,
+ * delivery, and autoMerge from THIS function and nowhere else. The raw
+ * worktree/docker/pr/ship/autoMerge booleans are inputs; the frozen plan is the
+ * one truth. Deriving autoMerge separately (the old `Boolean(ship)` scatter) is
+ * what let `--pr` merge and let the run-mode label drift from behavior.
+ */
+type RunIsolation = 'none' | 'worktree' | 'docker';
+type RunDelivery = 'none' | 'pr' | 'ship';
+interface RunOptions {
+    worktree?: unknown;
+    docker?: unknown;
+    pr?: unknown;
+    ship?: unknown;
+    autoMerge?: unknown;
+}
+interface RunPlan {
+    isolation: RunIsolation;
+    delivery: RunDelivery;
+    autoMerge: boolean;
+}
+declare function resolveRunPlan(options?: RunOptions): Readonly<RunPlan>;
+declare const _default: {
+    resolveRunPlan: typeof resolveRunPlan;
+};
+export = _default;

package/lib/run-plan.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * The single canonical run-mode resolver.
  *
@@ -7,26 +8,26 @@
  * one truth. Deriving autoMerge separately (the old `Boolean(ship)` scatter) is
  * what let `--pr` merge and let the run-mode label drift from behavior.
  */
-
 function resolveIsolation(options) {
-  if (options.docker) return 'docker';
-  if (options.worktree || options.pr || options.ship) return 'worktree';
-  return 'none';
+    if (options.docker)
+        return 'docker';
+    if (options.worktree || options.pr || options.ship)
+        return 'worktree';
+    return 'none';
 }
-
 function resolveDelivery(options) {
-  // Explicit autoMerge (e.g. a future `--auto-merge` flag) is ship-equivalent:
-  // "merge it" implies the ship delivery. This is the ONLY place that intent is
-  // interpreted, so it can never be silently overwritten downstream.
-  if (options.ship || options.autoMerge === true) return 'ship';
-  if (options.pr) return 'pr';
-  return 'none';
+    // Explicit autoMerge (e.g. a future `--auto-merge` flag) is ship-equivalent:
+    // "merge it" implies the ship delivery. This is the ONLY place that intent is
+    // interpreted, so it can never be silently overwritten downstream.
+    if (options.ship || options.autoMerge === true)
+        return 'ship';
+    if (options.pr)
+        return 'pr';
+    return 'none';
 }
-
 function resolveRunPlan(options = {}) {
-  const isolation = resolveIsolation(options);
-  const delivery = resolveDelivery(options);
-  return Object.freeze({ isolation, delivery, autoMerge: delivery === 'ship' });
+    const isolation = resolveIsolation(options);
+    const delivery = resolveDelivery(options);
+    return Object.freeze({ isolation, delivery, autoMerge: delivery === 'ship' });
 }
-
 module.exports = { resolveRunPlan };

package/lib/settings/claude-auth.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Claude authentication settings and helpers
+ * Extracted from settings.js for provider-specific isolation
+ */
+interface ClaudeProviderSettings {
+    readonly anthropicApiKey?: string;
+    readonly bedrockApiKey?: string;
+    readonly bedrockRegion?: string;
+}
+interface Settings {
+    readonly providerSettings?: {
+        readonly claude?: ClaudeProviderSettings;
+    };
+}
+/**
+ * Validate an Anthropic API key format
+ */
+declare function isValidAnthropicKey(key: string | null | undefined): boolean;
+/**
+ * Check if Bedrock mode is active based on env and overrides
+ */
+declare function isBedrockMode(envOverrides?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve Claude authentication environment variables from settings.
+ * Bedrock takes priority over direct Anthropic API key and OAuth sessions.
+ */
+declare function resolveClaudeAuth(settings: Settings): NodeJS.ProcessEnv;
+declare const _default: {
+    ANTHROPIC_KEY_PREFIX: string;
+    CLAUDE_AUTH_ENV_VARS: string[];
+    isValidAnthropicKey: typeof isValidAnthropicKey;
+    isBedrockMode: typeof isBedrockMode;
+    resolveClaudeAuth: typeof resolveClaudeAuth;
+};
+export = _default;

package/lib/settings/claude-auth.js

@@ -1,75 +1,58 @@
+"use strict";
 /**
  * Claude authentication settings and helpers
  * Extracted from settings.js for provider-specific isolation
  */
-
-const { getProviderMetadata } = require('../provider-names');
-
+const providerNames = require("../provider-names");
 /**
  * Anthropic API key prefix for validation
  */
 const ANTHROPIC_KEY_PREFIX = 'sk-ant-';
-
 /**
  * Environment variables used for Claude authentication
  */
-const CLAUDE_AUTH_ENV_VARS = [...getProviderMetadata('claude').docker.envPassthrough];
-
+const CLAUDE_AUTH_ENV_VARS = [
+    ...providerNames.getProviderMetadata('claude').docker.envPassthrough,
+];
 /**
  * Validate an Anthropic API key format
- * @param {string|null|undefined} key - API key to validate
- * @returns {boolean} True if key is falsy OR starts with valid prefix
  */
 function isValidAnthropicKey(key) {
-  return !key || key.startsWith(ANTHROPIC_KEY_PREFIX);
+    return !key || key.startsWith(ANTHROPIC_KEY_PREFIX);
 }
-
 /**
  * Check if Bedrock mode is active based on env and overrides
- * @param {Object} [envOverrides={}] - Environment variable overrides to check
- * @returns {boolean} True if Bedrock mode is active
  */
 function isBedrockMode(envOverrides = {}) {
-  return (
-    envOverrides.CLAUDE_CODE_USE_BEDROCK === '1' || process.env.CLAUDE_CODE_USE_BEDROCK === '1'
-  );
+    return (envOverrides.CLAUDE_CODE_USE_BEDROCK === '1' || process.env.CLAUDE_CODE_USE_BEDROCK === '1');
 }
-
 /**
- * Resolve Claude authentication environment variables from settings
- * Bedrock takes priority over direct Anthropic API key AND OAuth session
- * @param {Object} settings - Settings object from loadSettings()
- * @returns {Object} Environment variables to set for Claude auth
+ * Resolve Claude authentication environment variables from settings.
+ * Bedrock takes priority over direct Anthropic API key and OAuth sessions.
  */
 function resolveClaudeAuth(settings) {
-  const claudeSettings = settings.providerSettings?.claude || {};
-  const env = {};
-
-  // Bedrock takes priority over everything (including OAuth)
-  if (!process.env.AWS_BEARER_TOKEN_BEDROCK && claudeSettings.bedrockApiKey) {
-    env.AWS_BEARER_TOKEN_BEDROCK = claudeSettings.bedrockApiKey;
-    env.CLAUDE_CODE_USE_BEDROCK = '1';
-    if (claudeSettings.bedrockRegion && !process.env.AWS_REGION) {
-      env.AWS_REGION = claudeSettings.bedrockRegion;
+    const claudeSettings = settings.providerSettings?.claude || {};
+    const env = {};
+    if (!process.env.AWS_BEARER_TOKEN_BEDROCK && claudeSettings.bedrockApiKey) {
+        env.AWS_BEARER_TOKEN_BEDROCK = claudeSettings.bedrockApiKey;
+        env.CLAUDE_CODE_USE_BEDROCK = '1';
+        if (claudeSettings.bedrockRegion && !process.env.AWS_REGION) {
+            env.AWS_REGION = claudeSettings.bedrockRegion;
+        }
     }
-  } else if (process.env.AWS_BEARER_TOKEN_BEDROCK && !process.env.CLAUDE_CODE_USE_BEDROCK) {
-    // Auto-set CLAUDE_CODE_USE_BEDROCK if token present in env
-    env.CLAUDE_CODE_USE_BEDROCK = '1';
-  }
-
-  // Anthropic API key only if no Bedrock
-  const hasBedrock = env.AWS_BEARER_TOKEN_BEDROCK || process.env.AWS_BEARER_TOKEN_BEDROCK;
-  if (!process.env.ANTHROPIC_API_KEY && !hasBedrock && claudeSettings.anthropicApiKey) {
-    env.ANTHROPIC_API_KEY = claudeSettings.anthropicApiKey;
-  }
-
-  return env;
+    else if (process.env.AWS_BEARER_TOKEN_BEDROCK && !process.env.CLAUDE_CODE_USE_BEDROCK) {
+        env.CLAUDE_CODE_USE_BEDROCK = '1';
+    }
+    const hasBedrock = env.AWS_BEARER_TOKEN_BEDROCK || process.env.AWS_BEARER_TOKEN_BEDROCK;
+    if (!process.env.ANTHROPIC_API_KEY && !hasBedrock && claudeSettings.anthropicApiKey) {
+        env.ANTHROPIC_API_KEY = claudeSettings.anthropicApiKey;
+    }
+    return env;
 }
-
 module.exports = {
-  ANTHROPIC_KEY_PREFIX,
-  CLAUDE_AUTH_ENV_VARS,
-  isValidAnthropicKey,
-  isBedrockMode,
-  resolveClaudeAuth,
+    ANTHROPIC_KEY_PREFIX,
+    CLAUDE_AUTH_ENV_VARS,
+    isValidAnthropicKey,
+    isBedrockMode,
+    resolveClaudeAuth,
 };

package/lib/settings-defaults.d.ts

@@ -0,0 +1,20 @@
+interface ProviderLevelSettings extends Record<string, unknown> {
+    levelOverrides?: Record<string, unknown>;
+}
+type ProviderSettingsRecord = Record<string, ProviderLevelSettings>;
+interface SettingsRecord extends Record<string, unknown> {
+    autoCheckUpdates?: unknown;
+    defaultDocker?: unknown;
+    defaultIsolation?: unknown;
+    defaultProvider?: unknown;
+    lastUpdateCheckClaim?: unknown;
+    providerSettings?: ProviderSettingsRecord;
+}
+declare function resolvedDefaultSettings(): SettingsRecord;
+declare function mergeLoadedSettings(parsed: SettingsRecord): SettingsRecord;
+declare const _default: {
+    DEFAULT_SETTINGS: SettingsRecord;
+    resolvedDefaultSettings: typeof resolvedDefaultSettings;
+    mergeLoadedSettings: typeof mergeLoadedSettings;
+};
+export = _default;

package/lib/settings-defaults.js

@@ -0,0 +1,149 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerDefaults = require('./provider-defaults');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerNames = require('./provider-names');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const settingsModels = require('./settings-models');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const issueProviders = require('./settings-issue-providers');
+const { getProviderDefaults } = providerDefaults;
+const { VALID_PROVIDERS, getDefaultProviderId, normalizeProviderName, normalizeProviderSettings, } = providerNames;
+const { applyLegacyModelBounds } = settingsModels;
+const { getIssueProviderFns } = issueProviders;
+const DEFAULT_SETTINGS_BASE = {
+    maxModel: 'opus',
+    minModel: null,
+    defaultProvider: getDefaultProviderId(),
+    get providerSettings() {
+        return getProviderDefaults();
+    },
+    defaultConfig: 'conductor-bootstrap',
+    defaultIsolation: 'none',
+    defaultDelivery: 'none',
+    setupVersion: null,
+    strictSchema: true,
+    logLevel: 'normal',
+    autoCheckUpdates: true,
+    lastUpdateCheckAt: null,
+    lastSeenVersion: null,
+    lastUpdateCheckClaim: null,
+    claudeCommand: 'claude',
+    dockerMounts: ['gh', 'git', 'ssh'],
+    dockerEnvPassthrough: [],
+    dockerContainerHome: '/home/node',
+    maxRetries: 3,
+    maxRestartAttempts: 3,
+    maxTotalRestarts: 10,
+    staleWarningsBeforeKill: 2,
+    backoffBaseMs: 2000,
+    backoffMaxMs: 30000,
+    jitterFactor: 0.2,
+    defaultIssueSource: 'github',
+};
+let defaultSettingsCache = null;
+function getDefaultSettings() {
+    if (!defaultSettingsCache) {
+        const issueProviderSettings = getIssueProviderFns().getIssueProviderSettingsDefaults();
+        defaultSettingsCache = {
+            ...DEFAULT_SETTINGS_BASE,
+            ...issueProviderSettings,
+        };
+    }
+    return defaultSettingsCache;
+}
+function propertyValue(settings, property) {
+    return typeof property === 'string' ? settings[property] : undefined;
+}
+const DEFAULT_SETTINGS = new Proxy(DEFAULT_SETTINGS_BASE, {
+    get(target, property) {
+        if (property in target) {
+            return propertyValue(target, property);
+        }
+        return propertyValue(getDefaultSettings(), property);
+    },
+    has(target, property) {
+        if (property in target)
+            return true;
+        return property in getDefaultSettings();
+    },
+    ownKeys() {
+        return Object.keys(getDefaultSettings());
+    },
+    getOwnPropertyDescriptor(_target, property) {
+        const merged = getDefaultSettings();
+        if (property in merged) {
+            return { enumerable: true, configurable: true, value: propertyValue(merged, property) };
+        }
+        return undefined;
+    },
+});
+function isUnknownRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function providerOverride(value, provider) {
+    if (!isUnknownRecord(value))
+        return {};
+    const selected = value[provider];
+    return isUnknownRecord(selected) ? selected : {};
+}
+function mergeProviderSettings(current, overrides) {
+    const providerDefaultsValue = getProviderDefaults();
+    const merged = {};
+    for (const provider of VALID_PROVIDERS) {
+        merged[provider] = {
+            ...(providerDefaultsValue[provider] || {}),
+            ...(current[provider] || {}),
+            ...providerOverride(overrides, provider),
+        };
+        if (!merged[provider].levelOverrides) {
+            merged[provider].levelOverrides = {};
+        }
+    }
+    return merged;
+}
+function normalizeLoadedSettings(parsed) {
+    const normalized = { ...parsed };
+    if (!Object.hasOwn(parsed, 'defaultIsolation') && typeof parsed.defaultDocker === 'boolean') {
+        normalized.defaultIsolation = parsed.defaultDocker ? 'docker' : 'none';
+    }
+    delete normalized.defaultDocker;
+    if (parsed.defaultProvider) {
+        normalized.defaultProvider = normalizeProviderName(parsed.defaultProvider);
+    }
+    if (parsed.providerSettings) {
+        const normalizedProviders = normalizeProviderSettings(parsed.providerSettings);
+        if (isProviderSettingsRecord(normalizedProviders)) {
+            normalized.providerSettings = normalizedProviders;
+        }
+    }
+    if (normalized.autoCheckUpdates === false ||
+        typeof normalized.lastUpdateCheckClaim !== 'string' ||
+        normalized.lastUpdateCheckClaim.trim().length === 0) {
+        normalized.lastUpdateCheckClaim = null;
+    }
+    return normalized;
+}
+function isProviderSettingsRecord(value) {
+    return isUnknownRecord(value);
+}
+function resolvedDefaultSettings() {
+    return {
+        ...DEFAULT_SETTINGS,
+        providerSettings: mergeProviderSettings(getProviderDefaults()),
+    };
+}
+function mergeLoadedSettings(parsed) {
+    const normalized = normalizeLoadedSettings(parsed);
+    const merged = { ...resolvedDefaultSettings(), ...normalized };
+    merged.defaultProvider =
+        normalizeProviderName(merged.defaultProvider) || DEFAULT_SETTINGS.defaultProvider;
+    merged.providerSettings = mergeProviderSettings(getProviderDefaults(), normalized.providerSettings);
+    if (merged.autoCheckUpdates === false ||
+        typeof merged.lastUpdateCheckClaim !== 'string' ||
+        merged.lastUpdateCheckClaim.trim().length === 0) {
+        merged.lastUpdateCheckClaim = null;
+    }
+    return applyLegacyModelBounds(merged);
+}
+module.exports = { DEFAULT_SETTINGS, resolvedDefaultSettings, mergeLoadedSettings };

package/lib/settings-error.d.ts

@@ -0,0 +1,7 @@
+declare class SettingsValidationError extends Error {
+    constructor(message: string);
+}
+declare const _default: {
+    SettingsValidationError: typeof SettingsValidationError;
+};
+export = _default;

package/lib/settings-error.js

@@ -0,0 +1,8 @@
+"use strict";
+class SettingsValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SettingsValidationError';
+    }
+}
+module.exports = { SettingsValidationError };

package/lib/settings-issue-providers.d.ts

@@ -0,0 +1,10 @@
+interface IssueProviderFacade {
+    getIssueProviderSettingsDefaults(): Record<string, unknown>;
+    listProviders(): readonly string[];
+    validateIssueProviderSetting(key: string, value: unknown): string | null | undefined;
+}
+declare function getIssueProviderFns(): IssueProviderFacade;
+declare const _default: {
+    getIssueProviderFns: typeof getIssueProviderFns;
+};
+export = _default;